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| 288k|{ 52| 288k| return list->next; 53| 288k|} 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| 288k|{ 405| 288k| ogs_log_t *log = NULL; 406| 288k| ogs_log_domain_t *domain = NULL; 407| | 408| 288k| char logstr[OGS_HUGE_LEN]; 409| 288k| char *p, *last; 410| | 411| 288k| int wrote_stderr = 0; 412| | 413| 288k| ogs_list_for_each(&log_list, log) { ------------------ | | 76| 288k| for (node = ogs_list_first(list); (node); \ | | ------------------ | | | Branch (76:39): [True: 288k, False: 0] | | ------------------ | | 77| 288k| node = ogs_list_next(node)) ------------------ 414| 288k| domain = ogs_pool_find(&domain_pool, id); ------------------ | | 154| 288k| (_index > 0 && _index <= (pool)->size) ? (pool)->index[_index-1] : NULL | | ------------------ | | | Branch (154:6): [True: 288k, False: 0] | | | Branch (154:20): [True: 288k, False: 0] | | ------------------ ------------------ 415| 288k| if (!domain) { ------------------ | Branch (415:13): [True: 0, False: 288k] ------------------ 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| 288k| if (domain->level < level) ------------------ | Branch (419:13): [True: 288k, False: 0] ------------------ 420| 288k| 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| 288k|{ 487| 288k| va_list args; 488| | 489| 288k| va_start(args, format); 490| 288k| ogs_log_vprintf(level, id, 491| 288k| err, file, line, func, content_only, format, args); 492| | va_end(args); 493| 288k|} ogs_log_hexdump_func: 497| 94.9k|{ 498| 94.9k| size_t n, m; 499| 94.9k| char dumpstr[OGS_HUGE_LEN]; 500| 94.9k| 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| 94.9k| if (!len) ------------------ | Branch (506:9): [True: 2.36k, False: 92.6k] ------------------ 507| 2.36k| return; 508| | 509| 92.6k| last = dumpstr + OGS_HUGE_LEN; ------------------ | | 210| 92.6k|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 510| 92.6k| p = dumpstr; 511| | 512| 187k| for (n = 0; n < len; n += 16) { ------------------ | Branch (512:17): [True: 94.5k, False: 92.6k] ------------------ 513| 94.5k| p = ogs_slprintf(p, last, "%04x: ", (int)n); 514| | 515| 1.60M| for (m = n; m < n + 16; m++) { ------------------ | Branch (515:21): [True: 1.51M, False: 94.5k] ------------------ 516| 1.51M| if (m > n && (m % 4) == 0) ------------------ | Branch (516:17): [True: 1.41M, False: 94.5k] | Branch (516:26): [True: 283k, False: 1.13M] ------------------ 517| 283k| p = ogs_slprintf(p, last, " "); 518| 1.51M| if (m < len) ------------------ | Branch (518:17): [True: 144k, False: 1.36M] ------------------ 519| 144k| p = ogs_slprintf(p, last, "%02x", data[m]); 520| 1.36M| else 521| 1.36M| p = ogs_slprintf(p, last, " "); 522| 1.51M| } 523| | 524| 94.5k| p = ogs_slprintf(p, last, " "); 525| | 526| 238k| for (m = n; m < len && m < n + 16; m++) ------------------ | Branch (526:21): [True: 146k, False: 92.6k] | Branch (526:32): [True: 144k, False: 1.98k] ------------------ 527| 144k| p = ogs_slprintf(p, last, "%c", isprint(data[m]) ? data[m] : '.'); ------------------ | Branch (527:45): [True: 21.6k, False: 122k] ------------------ 528| | 529| 94.5k| p = ogs_slprintf(p, last, "\n"); 530| 94.5k| } 531| | 532| | ogs_log_print(level, "%s", dumpstr); ------------------ | | 48| 92.6k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | ------------------ | | | | 32| 92.6k|#define OGS_LOG_DOMAIN 1 | | ------------------ | | 49| 92.6k| 0, NULL, 0, NULL, \ | | 50| 92.6k| 1, __VA_ARGS__) ------------------ 533| 92.6k|} 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.94k|{ 74| 3.94k| void *ptr = NULL; 75| | 76| 3.94k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 3.94k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 77| | 78| 3.94k| ptr = _talloc_zero(ctx, size, name); 79| 3.94k| ogs_expect(ptr); ------------------ | | 128| 3.94k| do { \ | | 129| 3.94k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.94k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.94k, False: 0] | | | | ------------------ | | ------------------ | | 130| 3.94k| else { \ | | 131| 0| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 23| 0|#define OGS_LOG_DOMAIN __ogs_mem_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 0| } \ | | 133| 3.94k| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 3.94k] | | ------------------ ------------------ 80| | 81| 3.94k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 3.94k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 82| | 83| 3.94k| return ptr; 84| 3.94k|} ogs_talloc_free: 102| 3.94k|{ 103| 3.94k| int ret; 104| | 105| 3.94k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 3.94k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 106| | 107| 3.94k| ret = _talloc_free(ptr, location); 108| | 109| 3.94k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 3.94k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 110| | 111| 3.94k| return ret; 112| 3.94k|} ogs_pkbuf_put_data: 91| 3.94k|{ 92| 3.94k| void *tmp = ogs_pkbuf_put(pkbuf, len); 93| | 94| 3.94k| memcpy(tmp, data, len); 95| 3.94k| return tmp; 96| 3.94k|} 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.94k|{ 223| 3.94k|#if OGS_USE_TALLOC == 1 224| 3.94k| ogs_pkbuf_t *pkbuf = NULL; 225| | 226| 3.94k| pkbuf = ogs_talloc_zero_size(pool, sizeof(*pkbuf) + size, file_line); 227| 3.94k| if (!pkbuf) { ------------------ | Branch (227:9): [True: 0, False: 3.94k] ------------------ 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.94k| pkbuf->head = pkbuf->_data; 233| 3.94k| pkbuf->end = pkbuf->_data + size; 234| | 235| 3.94k| pkbuf->len = 0; 236| | 237| 3.94k| pkbuf->data = pkbuf->_data; 238| 3.94k| pkbuf->tail = pkbuf->_data; 239| | 240| 3.94k| pkbuf->file_line = file_line; /* For debug */ 241| | 242| 3.94k| 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.94k|} ogs_pkbuf_free: 290| 3.94k|{ 291| 3.94k|#if OGS_USE_TALLOC == 1 292| 3.94k| ogs_talloc_free(pkbuf, OGS_FILE_LINE); ------------------ | | 213| 3.94k|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | ------------------ | | | | 167| 3.94k|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | ------------------ | | | | | | 168| 3.94k|#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.94k|} decoder.c:ogs_pkbuf_pull: 165| 187k|{ 166| 187k| return ogs_unlikely(len > pkbuf->len) ? ------------------ | | 55| 187k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 187k] | | ------------------ ------------------ 167| 187k| NULL : ogs_pkbuf_pull_inline(pkbuf, len); 168| 187k|} decoder.c:ogs_pkbuf_pull_inline: 159| 187k|{ 160| 187k| pkbuf->len -= len; 161| 187k| return pkbuf->data += len; 162| 187k|} decoder.c:ogs_pkbuf_push: 147| 44.2k|{ 148| 44.2k| if (ogs_unlikely(ogs_pkbuf_headroom(pkbuf) < (int)len)) ------------------ | | 55| 44.2k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 44.2k] | | ------------------ ------------------ 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| 44.2k| pkbuf->data -= len; 152| 44.2k| pkbuf->len += len; 153| | 154| 44.2k| return pkbuf->data; 155| 44.2k|} decoder.c:ogs_pkbuf_headroom: 104| 44.2k|{ 105| 44.2k| return pkbuf->data - pkbuf->head; 106| 44.2k|} ies.c:ogs_pkbuf_pull: 165| 95.5k|{ 166| 95.5k| return ogs_unlikely(len > pkbuf->len) ? ------------------ | | 55| 95.5k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 474, False: 95.0k] | | ------------------ ------------------ 167| 95.5k| NULL : ogs_pkbuf_pull_inline(pkbuf, len); 168| 95.5k|} ies.c:ogs_pkbuf_pull_inline: 159| 95.0k|{ 160| 95.0k| pkbuf->len -= len; 161| 95.0k| return pkbuf->data += len; 162| 95.0k|} ogs-pkbuf.c:ogs_pkbuf_put: 115| 3.94k|{ 116| 3.94k| void *tmp = pkbuf->tail; 117| | 118| 3.94k| if (ogs_unlikely(ogs_pkbuf_tailroom(pkbuf) < (int)len)) ------------------ | | 55| 3.94k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 3.94k] | | ------------------ ------------------ 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.94k| pkbuf->tail += len; 122| 3.94k| pkbuf->len += len; 123| | 124| 3.94k| return tmp; 125| 3.94k|} ogs-pkbuf.c:ogs_pkbuf_tailroom: 99| 3.94k|{ 100| 3.94k| return pkbuf->end - pkbuf->tail; 101| 3.94k|} 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.22M|{ 64| 2.22M| 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.22M| r = vsnprintf(str, size, format, ap); 78| 2.22M|#endif 79| 2.22M| str[size-1] = '\0'; 80| | 81| 2.22M| return r; 82| 2.22M|} ogs_vslprintf: 97| 2.22M|{ 98| 2.22M| int r = -1; 99| | 100| 2.22M| ogs_assert(last); ------------------ | | 113| 2.22M| do { \ | | 114| 2.22M| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.22M|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.22M, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.22M| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.22M| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.22M] | | ------------------ ------------------ 101| | 102| 2.22M| if (!str) ------------------ | Branch (102:9): [True: 0, False: 2.22M] ------------------ 103| 0| return NULL; 104| | 105| 2.22M| if (str < last) ------------------ | Branch (105:9): [True: 2.22M, False: 0] ------------------ 106| 2.22M| r = ogs_vsnprintf(str, last - str, format, ap); 107| | 108| 2.22M| return (str + r); 109| 2.22M|} ogs_slprintf: 112| 2.22M|{ 113| 2.22M| char *r; 114| 2.22M| va_list ap; 115| | 116| 2.22M| va_start(ap, format); 117| 2.22M| r = ogs_vslprintf(str, last, format, ap); 118| 2.22M| va_end(ap); 119| | 120| 2.22M| return r; 121| 2.22M|} 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| 348|{ 88| 348| ogs_nas_eps_attach_request_t *attach_request = &message->emm.attach_request; 89| 348| int decoded = 0; 90| 348| int size = 0; 91| | 92| 348| ogs_trace("[NAS] Decode ATTACH_REQUEST\n"); ------------------ | | 40| 348|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 348| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 348|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 348| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 348|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 348| 0, __VA_ARGS__) | | ------------------ ------------------ 93| | 94| 348| size = ogs_nas_eps_decode_eps_attach_type(&attach_request->eps_attach_type, pkbuf); 95| 348| if (size < 0) { ------------------ | Branch (95:9): [True: 0, False: 348] ------------------ 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| 348| decoded += size; 101| | 102| 348| size = ogs_nas_eps_decode_eps_mobile_identity(&attach_request->eps_mobile_identity, pkbuf); 103| 348| if (size < 0) { ------------------ | Branch (103:9): [True: 4, False: 344] ------------------ 104| 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__) | | ------------------ ------------------ 105| 4| return size; 106| 4| } 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: 9, False: 335] ------------------ 112| 9| ogs_error("ogs_nas_eps_decode_ue_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__) | | ------------------ ------------------ 113| 9| return size; 114| 9| } 115| | 116| 335| decoded += size; 117| | 118| 335| size = ogs_nas_eps_decode_esm_message_container(&attach_request->esm_message_container, pkbuf); 119| 335| if (size < 0) { ------------------ | Branch (119:9): [True: 5, False: 330] ------------------ 120| 5| ogs_error("ogs_nas_eps_decode_esm_message_container() 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__) | | ------------------ ------------------ 121| 5| return size; 122| 5| } 123| | 124| 330| decoded += size; 125| | 126| 18.4k| while (pkbuf->len > 0) { ------------------ | Branch (126:12): [True: 18.1k, False: 303] ------------------ 127| 18.1k| uint8_t *buffer = pkbuf->data; 128| 18.1k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (128:24): [True: 6.65k, False: 11.4k] ------------------ 129| | 130| 18.1k| size = sizeof(uint8_t); 131| 18.1k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (131:13): [True: 0, False: 18.1k] ------------------ 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| 18.1k| decoded += size; 136| | 137| 18.1k| switch (type) { 138| 217| case OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE: ------------------ | | 156| 217|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE 0x19 ------------------ | Branch (138:9): [True: 217, False: 17.9k] ------------------ 139| 217| size = ogs_nas_eps_decode_p_tmsi_signature(&attach_request->old_p_tmsi_signature, pkbuf); 140| 217| if (size < 0) { ------------------ | Branch (140:17): [True: 1, False: 216] ------------------ 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| 216| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT; ------------------ | | 128| 216|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT ((uint64_t)1<<0) ------------------ 146| 216| decoded += size; 147| 216| 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: 17.9k] ------------------ 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| 268| case OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE: ------------------ | | 158| 268|#define OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE 0x52 ------------------ | Branch (158:9): [True: 268, False: 17.8k] ------------------ 159| 268| size = ogs_nas_eps_decode_tracking_area_identity(&attach_request->last_visited_registered_tai, pkbuf); 160| 268| if (size < 0) { ------------------ | Branch (160:17): [True: 1, False: 267] ------------------ 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| 267| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT; ------------------ | | 130| 267|#define OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT ((uint64_t)1<<2) ------------------ 166| 267| decoded += size; 167| 267| break; 168| 202| case OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_TYPE: ------------------ | | 159| 202|#define OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_TYPE 0x5C ------------------ | Branch (168:9): [True: 202, False: 17.9k] ------------------ 169| 202| size = ogs_nas_eps_decode_drx_parameter(&attach_request->drx_parameter, pkbuf); 170| 202| if (size < 0) { ------------------ | Branch (170:17): [True: 1, False: 201] ------------------ 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| 201| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_PRESENT; ------------------ | | 131| 201|#define OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_PRESENT ((uint64_t)1<<3) ------------------ 176| 201| decoded += size; 177| 201| break; 178| 197| case OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_TYPE: ------------------ | | 160| 197|#define OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_TYPE 0x31 ------------------ | Branch (178:9): [True: 197, False: 17.9k] ------------------ 179| 197| size = ogs_nas_eps_decode_ms_network_capability(&attach_request->ms_network_capability, pkbuf); 180| 197| if (size < 0) { ------------------ | Branch (180:17): [True: 1, False: 196] ------------------ 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| 196| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_PRESENT; ------------------ | | 132| 196|#define OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<4) ------------------ 186| 196| decoded += size; 187| 196| break; 188| 340| case OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE: ------------------ | | 161| 340|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 ------------------ | Branch (188:9): [True: 340, False: 17.7k] ------------------ 189| 340| size = ogs_nas_eps_decode_location_area_identification(&attach_request->old_location_area_identification, pkbuf); 190| 340| if (size < 0) { ------------------ | Branch (190:17): [True: 1, False: 339] ------------------ 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| 339| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT; ------------------ | | 133| 339|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT ((uint64_t)1<<5) ------------------ 196| 339| decoded += size; 197| 339| break; 198| 428| case OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_TYPE: ------------------ | | 162| 428|#define OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_TYPE 0x90 ------------------ | Branch (198:9): [True: 428, False: 17.7k] ------------------ 199| 428| decoded--; 200| 428| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 428| do { \ | | 114| 428| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 428|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 428, False: 0] | | | | ------------------ | | ------------------ | | 115| 428| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 428| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 428] | | ------------------ ------------------ 201| 428| size = ogs_nas_eps_decode_tmsi_status(&attach_request->tmsi_status, pkbuf); 202| 428| if (size < 0) { ------------------ | Branch (202:17): [True: 0, False: 428] ------------------ 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| 428| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_PRESENT; ------------------ | | 134| 428|#define OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_PRESENT ((uint64_t)1<<6) ------------------ 208| 428| decoded += size; 209| 428| break; 210| 202| case OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE: ------------------ | | 163| 202|#define OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE 0x11 ------------------ | Branch (210:9): [True: 202, False: 17.9k] ------------------ 211| 202| size = ogs_nas_eps_decode_mobile_station_classmark_2(&attach_request->mobile_station_classmark_2, pkbuf); 212| 202| if (size < 0) { ------------------ | Branch (212:17): [True: 1, False: 201] ------------------ 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| 201| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT; ------------------ | | 135| 201|#define OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT ((uint64_t)1<<7) ------------------ 218| 201| decoded += size; 219| 201| break; 220| 231| case OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE: ------------------ | | 164| 231|#define OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE 0x20 ------------------ | Branch (220:9): [True: 231, False: 17.9k] ------------------ 221| 231| size = ogs_nas_eps_decode_mobile_station_classmark_3(&attach_request->mobile_station_classmark_3, pkbuf); 222| 231| if (size < 0) { ------------------ | Branch (222:17): [True: 2, False: 229] ------------------ 223| 2| ogs_error("ogs_nas_eps_decode_mobile_station_classmark_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__) | | ------------------ ------------------ 224| 2| return size; 225| 2| } 226| | 227| 229| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT; ------------------ | | 136| 229|#define OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT ((uint64_t)1<<8) ------------------ 228| 229| decoded += size; 229| 229| break; 230| 219| case OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_TYPE: ------------------ | | 165| 219|#define OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_TYPE 0x40 ------------------ | Branch (230:9): [True: 219, False: 17.9k] ------------------ 231| 219| size = ogs_nas_eps_decode_supported_codec_list(&attach_request->supported_codecs, pkbuf); 232| 219| if (size < 0) { ------------------ | Branch (232:17): [True: 1, False: 218] ------------------ 233| 1| ogs_error("ogs_nas_eps_decode_supported_codec_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__) | | ------------------ ------------------ 234| 1| return size; 235| 1| } 236| | 237| 218| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_PRESENT; ------------------ | | 137| 218|#define OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_PRESENT ((uint64_t)1<<9) ------------------ 238| 218| decoded += size; 239| 218| break; 240| 2.83k| case OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE: ------------------ | | 166| 2.83k|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE 0xF0 ------------------ | Branch (240:9): [True: 2.83k, False: 15.3k] ------------------ 241| 2.83k| decoded--; 242| 2.83k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 2.83k| do { \ | | 114| 2.83k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.83k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.83k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.83k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.83k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.83k] | | ------------------ ------------------ 243| 2.83k| size = ogs_nas_eps_decode_additional_update_type(&attach_request->additional_update_type, pkbuf); 244| 2.83k| if (size < 0) { ------------------ | Branch (244:17): [True: 0, False: 2.83k] ------------------ 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.83k| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT; ------------------ | | 138| 2.83k|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT ((uint64_t)1<<10) ------------------ 250| 2.83k| decoded += size; 251| 2.83k| break; 252| 212| case OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE: ------------------ | | 167| 212|#define OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE 0x5D ------------------ | Branch (252:9): [True: 212, False: 17.9k] ------------------ 253| 212| size = ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting(&attach_request->voice_domain_preference_and_ue_usage_setting, pkbuf); 254| 212| if (size < 0) { ------------------ | Branch (254:17): [True: 1, False: 211] ------------------ 255| 1| ogs_error("ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting() 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__) | | ------------------ ------------------ 256| 1| return size; 257| 1| } 258| | 259| 211| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT; ------------------ | | 139| 211|#define OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT ((uint64_t)1<<11) ------------------ 260| 211| decoded += size; 261| 211| break; 262| 1.02k| case OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_TYPE: ------------------ | | 168| 1.02k|#define OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_TYPE 0xD0 ------------------ | Branch (262:9): [True: 1.02k, False: 17.1k] ------------------ 263| 1.02k| decoded--; 264| 1.02k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.02k| do { \ | | 114| 1.02k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.02k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.02k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.02k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.02k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.02k] | | ------------------ ------------------ 265| 1.02k| size = ogs_nas_eps_decode_device_properties(&attach_request->device_properties, pkbuf); 266| 1.02k| if (size < 0) { ------------------ | Branch (266:17): [True: 0, False: 1.02k] ------------------ 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| 1.02k| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_PRESENT; ------------------ | | 140| 1.02k|#define OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_PRESENT ((uint64_t)1<<12) ------------------ 272| 1.02k| decoded += size; 273| 1.02k| break; 274| 789| case OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_TYPE: ------------------ | | 169| 789|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_TYPE 0xE0 ------------------ | Branch (274:9): [True: 789, False: 17.3k] ------------------ 275| 789| decoded--; 276| 789| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 789| do { \ | | 114| 789| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 789|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 789, False: 0] | | | | ------------------ | | ------------------ | | 115| 789| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 789| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 789] | | ------------------ ------------------ 277| 789| size = ogs_nas_eps_decode_guti_type(&attach_request->old_guti_type, pkbuf); 278| 789| if (size < 0) { ------------------ | Branch (278:17): [True: 0, False: 789] ------------------ 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| 789| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_PRESENT; ------------------ | | 141| 789|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_PRESENT ((uint64_t)1<<13) ------------------ 284| 789| decoded += size; 285| 789| break; 286| 739| case OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE: ------------------ | | 170| 739|#define OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE 0xC0 ------------------ | Branch (286:9): [True: 739, False: 17.4k] ------------------ 287| 739| decoded--; 288| 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] | | ------------------ ------------------ 289| 739| size = ogs_nas_eps_decode_ms_network_feature_support(&attach_request->ms_network_feature_support, pkbuf); 290| 739| if (size < 0) { ------------------ | Branch (290:17): [True: 0, False: 739] ------------------ 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| 739| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT; ------------------ | | 142| 739|#define OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT ((uint64_t)1<<14) ------------------ 296| 739| decoded += size; 297| 739| break; 298| 209| case OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE: ------------------ | | 171| 209|#define OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE 0x10 ------------------ | Branch (298:9): [True: 209, False: 17.9k] ------------------ 299| 209| size = ogs_nas_eps_decode_network_resource_identifier_container(&attach_request->tmsi_based_nri_container, pkbuf); 300| 209| if (size < 0) { ------------------ | Branch (300:17): [True: 2, False: 207] ------------------ 301| 2| ogs_error("ogs_nas_eps_decode_network_resource_identifier_container() 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__) | | ------------------ ------------------ 302| 2| return size; 303| 2| } 304| | 305| 207| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT; ------------------ | | 143| 207|#define OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT ((uint64_t)1<<15) ------------------ 306| 207| decoded += size; 307| 207| break; 308| 208| case OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_TYPE: ------------------ | | 172| 208|#define OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_TYPE 0x6A ------------------ | Branch (308:9): [True: 208, False: 17.9k] ------------------ 309| 208| size = ogs_nas_eps_decode_gprs_timer_2(&attach_request->t3324_value, pkbuf); 310| 208| if (size < 0) { ------------------ | Branch (310:17): [True: 1, False: 207] ------------------ 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| 207| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_PRESENT; ------------------ | | 144| 207|#define OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_PRESENT ((uint64_t)1<<16) ------------------ 316| 207| decoded += size; 317| 207| break; 318| 208| case OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_TYPE: ------------------ | | 173| 208|#define OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_TYPE 0x5E ------------------ | Branch (318:9): [True: 208, False: 17.9k] ------------------ 319| 208| size = ogs_nas_eps_decode_gprs_timer_3(&attach_request->t3412_extended_value, pkbuf); 320| 208| if (size < 0) { ------------------ | Branch (320:17): [True: 1, False: 207] ------------------ 321| 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__) | | ------------------ ------------------ 322| 1| return size; 323| 1| } 324| | 325| 207| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_PRESENT; ------------------ | | 145| 207|#define OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_PRESENT ((uint64_t)1<<17) ------------------ 326| 207| decoded += size; 327| 207| break; 328| 216| case OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE: ------------------ | | 174| 216|#define OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE 0x6E ------------------ | Branch (328:9): [True: 216, False: 17.9k] ------------------ 329| 216| size = ogs_nas_eps_decode_extended_drx_parameters(&attach_request->extended_drx_parameters, pkbuf); 330| 216| if (size < 0) { ------------------ | Branch (330:17): [True: 1, False: 215] ------------------ 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| 215| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT; ------------------ | | 146| 215|#define OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT ((uint64_t)1<<18) ------------------ 336| 215| decoded += size; 337| 215| break; 338| 310| case OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE: ------------------ | | 175| 310|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE 0x6F ------------------ | Branch (338:9): [True: 310, False: 17.8k] ------------------ 339| 310| size = ogs_nas_eps_decode_ue_additional_security_capability(&attach_request->ue_additional_security_capability, pkbuf); 340| 310| if (size < 0) { ------------------ | Branch (340:17): [True: 1, False: 309] ------------------ 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| 309| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT; ------------------ | | 147| 309|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT ((uint64_t)1<<19) ------------------ 346| 309| decoded += size; 347| 309| break; 348| 250| case OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_TYPE: ------------------ | | 176| 250|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_TYPE 0x6D ------------------ | Branch (348:9): [True: 250, False: 17.8k] ------------------ 349| 250| size = ogs_nas_eps_decode_ue_status(&attach_request->ue_status, pkbuf); 350| 250| if (size < 0) { ------------------ | Branch (350:17): [True: 1, False: 249] ------------------ 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| 249| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_PRESENT; ------------------ | | 148| 249|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_PRESENT ((uint64_t)1<<20) ------------------ 356| 249| decoded += size; 357| 249| break; 358| 214| case OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_TYPE: ------------------ | | 177| 214|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_TYPE 0x17 ------------------ | Branch (358:9): [True: 214, False: 17.9k] ------------------ 359| 214| size = ogs_nas_eps_decode_additional_information_requested(&attach_request->additional_information_requested, pkbuf); 360| 214| if (size < 0) { ------------------ | Branch (360:17): [True: 1, False: 213] ------------------ 361| 1| ogs_error("ogs_nas_eps_decode_additional_information_requested() 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__) | | ------------------ ------------------ 362| 1| return size; 363| 1| } 364| | 365| 213| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_PRESENT; ------------------ | | 149| 213|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_PRESENT ((uint64_t)1<<21) ------------------ 366| 213| decoded += size; 367| 213| 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: 17.9k] ------------------ 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: 2, False: 214] ------------------ 371| 2| ogs_error("ogs_nas_eps_decode_n1_ue_network_capability() 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__) | | ------------------ ------------------ 372| 2| return size; 373| 2| } 374| | 375| 214| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_N1_UE_NETWORK_CAPABILITY_PRESENT; ------------------ | | 150| 214|#define OGS_NAS_EPS_ATTACH_REQUEST_N1_UE_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<22) ------------------ 376| 214| decoded += size; 377| 214| break; 378| 203| case OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_TYPE: ------------------ | | 179| 203|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_TYPE 0x34 ------------------ | Branch (378:9): [True: 203, False: 17.9k] ------------------ 379| 203| size = ogs_nas_eps_decode_ue_radio_capability_id_availability(&attach_request->ue_radio_capability_id_availability, pkbuf); 380| 203| if (size < 0) { ------------------ | Branch (380:17): [True: 1, False: 202] ------------------ 381| 1| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_availability() 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__) | | ------------------ ------------------ 382| 1| return size; 383| 1| } 384| | 385| 202| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_PRESENT; ------------------ | | 151| 202|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_PRESENT ((uint64_t)1<<23) ------------------ 386| 202| decoded += size; 387| 202| break; 388| 216| case OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_TYPE: ------------------ | | 180| 216|#define OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_TYPE 0x35 ------------------ | Branch (388:9): [True: 216, False: 17.9k] ------------------ 389| 216| size = ogs_nas_eps_decode_wus_assistance_information(&attach_request->requested_wus_assistance_information, pkbuf); 390| 216| if (size < 0) { ------------------ | Branch (390:17): [True: 2, False: 214] ------------------ 391| 2| ogs_error("ogs_nas_eps_decode_wus_assistance_information() 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__) | | ------------------ ------------------ 392| 2| return size; 393| 2| } 394| | 395| 214| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_PRESENT; ------------------ | | 152| 214|#define OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_PRESENT ((uint64_t)1<<24) ------------------ 396| 214| decoded += size; 397| 214| break; 398| 196| case OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_TYPE: ------------------ | | 181| 196|#define OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_TYPE 0x36 ------------------ | Branch (398:9): [True: 196, False: 17.9k] ------------------ 399| 196| size = ogs_nas_eps_decode_nb_s1_drx_parameter(&attach_request->drx_parameter_in_nb_s1_mode, pkbuf); 400| 196| if (size < 0) { ------------------ | Branch (400:17): [True: 1, False: 195] ------------------ 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| 195| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT; ------------------ | | 153| 195|#define OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT ((uint64_t)1<<25) ------------------ 406| 195| decoded += size; 407| 195| break; 408| 231| case OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_TYPE: ------------------ | | 182| 231|#define OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_TYPE 0x38 ------------------ | Branch (408:9): [True: 231, False: 17.9k] ------------------ 409| 231| size = ogs_nas_eps_decode_imsi_offset(&attach_request->requested_imsi_offset, pkbuf); 410| 231| if (size < 0) { ------------------ | Branch (410:17): [True: 1, False: 230] ------------------ 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| 230| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_PRESENT; ------------------ | | 154| 230|#define OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_PRESENT ((uint64_t)1<<26) ------------------ 416| 230| decoded += size; 417| 230| break; 418| 212| case OGS_NAS_EPS_ATTACH_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_TYPE: ------------------ | | 183| 212|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_TYPE 0x26 ------------------ | Branch (418:9): [True: 212, False: 17.9k] ------------------ 419| 212| size = ogs_nas_eps_decode_plmn_identity(&attach_request->ue_determined_plmn_with_disaster_condition, pkbuf); 420| 212| if (size < 0) { ------------------ | Branch (420:17): [True: 1, False: 211] ------------------ 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| 211| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_PRESENT; ------------------ | | 155| 211|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_PRESENT ((uint64_t)1<<27) ------------------ 426| 211| decoded += size; 427| 211| break; 428| 7.14k| default: ------------------ | Branch (428:9): [True: 7.14k, False: 10.9k] ------------------ 429| 7.14k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 7.14k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7.14k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7.14k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7.14k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7.14k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7.14k| 0, __VA_ARGS__) | | ------------------ ------------------ 430| 7.14k| break; 431| 18.1k| } 432| 18.1k| } 433| | 434| 303| return decoded; 435| 330|} ogs_nas_eps_decode_attach_accept: 438| 435|{ 439| 435| ogs_nas_eps_attach_accept_t *attach_accept = &message->emm.attach_accept; 440| 435| int decoded = 0; 441| 435| int size = 0; 442| | 443| 435| ogs_trace("[NAS] Decode ATTACH_ACCEPT\n"); ------------------ | | 40| 435|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 435| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 435|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 435| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 435|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 435| 0, __VA_ARGS__) | | ------------------ ------------------ 444| | 445| 435| size = ogs_nas_eps_decode_eps_attach_result(&attach_accept->eps_attach_result, pkbuf); 446| 435| if (size < 0) { ------------------ | Branch (446:9): [True: 0, False: 435] ------------------ 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| 435| decoded += size; 452| | 453| 435| size = ogs_nas_eps_decode_gprs_timer(&attach_accept->t3412_value, pkbuf); 454| 435| if (size < 0) { ------------------ | Branch (454:9): [True: 0, False: 435] ------------------ 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| 435| decoded += size; 460| | 461| 435| size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_accept->tai_list, pkbuf); 462| 435| if (size < 0) { ------------------ | Branch (462:9): [True: 4, False: 431] ------------------ 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| 431| decoded += size; 468| | 469| 431| size = ogs_nas_eps_decode_esm_message_container(&attach_accept->esm_message_container, pkbuf); 470| 431| if (size < 0) { ------------------ | Branch (470:9): [True: 8, False: 423] ------------------ 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| 423| decoded += size; 476| | 477| 19.0k| while (pkbuf->len > 0) { ------------------ | Branch (477:12): [True: 18.6k, False: 391] ------------------ 478| 18.6k| uint8_t *buffer = pkbuf->data; 479| 18.6k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (479:24): [True: 6.88k, False: 11.7k] ------------------ 480| | 481| 18.6k| size = sizeof(uint8_t); 482| 18.6k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (482:13): [True: 0, False: 18.6k] ------------------ 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.6k| decoded += size; 487| | 488| 18.6k| switch (type) { 489| 213| case OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_TYPE: ------------------ | | 262| 213|#define OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_TYPE 0x50 ------------------ | Branch (489:9): [True: 213, False: 18.4k] ------------------ 490| 213| size = ogs_nas_eps_decode_eps_mobile_identity(&attach_accept->guti, pkbuf); 491| 213| if (size < 0) { ------------------ | Branch (491:17): [True: 1, False: 212] ------------------ 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| 212| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_PRESENT; ------------------ | | 228| 212|#define OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_PRESENT ((uint64_t)1<<0) ------------------ 497| 212| decoded += size; 498| 212| break; 499| 253| case OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE: ------------------ | | 263| 253|#define OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 ------------------ | Branch (499:9): [True: 253, False: 18.3k] ------------------ 500| 253| size = ogs_nas_eps_decode_location_area_identification(&attach_accept->location_area_identification, pkbuf); 501| 253| if (size < 0) { ------------------ | Branch (501:17): [True: 1, False: 252] ------------------ 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| 252| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT; ------------------ | | 229| 252|#define OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT ((uint64_t)1<<1) ------------------ 507| 252| decoded += size; 508| 252| break; 509| 203| case OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_TYPE: ------------------ | | 264| 203|#define OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_TYPE 0x23 ------------------ | Branch (509:9): [True: 203, False: 18.4k] ------------------ 510| 203| size = ogs_nas_eps_decode_mobile_identity(&attach_accept->ms_identity, pkbuf); 511| 203| if (size < 0) { ------------------ | Branch (511:17): [True: 1, False: 202] ------------------ 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| 202| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_PRESENT; ------------------ | | 230| 202|#define OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_PRESENT ((uint64_t)1<<2) ------------------ 517| 202| decoded += size; 518| 202| break; 519| 388| case OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_TYPE: ------------------ | | 265| 388|#define OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_TYPE 0x53 ------------------ | Branch (519:9): [True: 388, False: 18.2k] ------------------ 520| 388| size = ogs_nas_eps_decode_emm_cause(&attach_accept->emm_cause, pkbuf); 521| 388| if (size < 0) { ------------------ | Branch (521:17): [True: 1, False: 387] ------------------ 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| 387| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_PRESENT; ------------------ | | 231| 387|#define OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_PRESENT ((uint64_t)1<<3) ------------------ 527| 387| decoded += size; 528| 387| break; 529| 221| case OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_TYPE: ------------------ | | 266| 221|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_TYPE 0x17 ------------------ | Branch (529:9): [True: 221, False: 18.4k] ------------------ 530| 221| size = ogs_nas_eps_decode_gprs_timer(&attach_accept->t3402_value, pkbuf); 531| 221| if (size < 0) { ------------------ | Branch (531:17): [True: 1, False: 220] ------------------ 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| 220| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_PRESENT; ------------------ | | 232| 220|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_PRESENT ((uint64_t)1<<4) ------------------ 537| 220| decoded += size; 538| 220| break; 539| 227| case OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_TYPE: ------------------ | | 267| 227|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_TYPE 0x59 ------------------ | Branch (539:9): [True: 227, False: 18.3k] ------------------ 540| 227| size = ogs_nas_eps_decode_gprs_timer(&attach_accept->t3423_value, pkbuf); 541| 227| if (size < 0) { ------------------ | Branch (541:17): [True: 1, False: 226] ------------------ 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| 226| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_PRESENT; ------------------ | | 233| 226|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_PRESENT ((uint64_t)1<<5) ------------------ 547| 226| decoded += size; 548| 226| break; 549| 208| case OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_TYPE: ------------------ | | 268| 208|#define OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_TYPE 0x4A ------------------ | Branch (549:9): [True: 208, False: 18.4k] ------------------ 550| 208| size = ogs_nas_eps_decode_plmn_list(&attach_accept->equivalent_plmns, pkbuf); 551| 208| if (size < 0) { ------------------ | Branch (551:17): [True: 1, False: 207] ------------------ 552| 1| ogs_error("ogs_nas_eps_decode_plmn_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__) | | ------------------ ------------------ 553| 1| return size; 554| 1| } 555| | 556| 207| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_PRESENT; ------------------ | | 234| 207|#define OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_PRESENT ((uint64_t)1<<6) ------------------ 557| 207| decoded += size; 558| 207| break; 559| 224| case OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE: ------------------ | | 269| 224|#define OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE 0x34 ------------------ | Branch (559:9): [True: 224, False: 18.4k] ------------------ 560| 224| size = ogs_nas_eps_decode_emergency_number_list(&attach_accept->emergency_number_list, pkbuf); 561| 224| if (size < 0) { ------------------ | Branch (561:17): [True: 1, False: 223] ------------------ 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| 223| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT; ------------------ | | 235| 223|#define OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT ((uint64_t)1<<7) ------------------ 567| 223| decoded += size; 568| 223| break; 569| 215| case OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE: ------------------ | | 270| 215|#define OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE 0x64 ------------------ | Branch (569:9): [True: 215, False: 18.4k] ------------------ 570| 215| size = ogs_nas_eps_decode_eps_network_feature_support(&attach_accept->eps_network_feature_support, pkbuf); 571| 215| if (size < 0) { ------------------ | Branch (571:17): [True: 2, False: 213] ------------------ 572| 2| ogs_error("ogs_nas_eps_decode_eps_network_feature_support() 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__) | | ------------------ ------------------ 573| 2| return size; 574| 2| } 575| | 576| 213| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT; ------------------ | | 236| 213|#define OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT ((uint64_t)1<<8) ------------------ 577| 213| decoded += size; 578| 213| break; 579| 3.23k| case OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE: ------------------ | | 271| 3.23k|#define OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE 0xF0 ------------------ | Branch (579:9): [True: 3.23k, False: 15.3k] ------------------ 580| 3.23k| decoded--; 581| 3.23k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 3.23k| do { \ | | 114| 3.23k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.23k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.23k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.23k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.23k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.23k] | | ------------------ ------------------ 582| 3.23k| size = ogs_nas_eps_decode_additional_update_result(&attach_accept->additional_update_result, pkbuf); 583| 3.23k| if (size < 0) { ------------------ | Branch (583:17): [True: 0, False: 3.23k] ------------------ 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| 3.23k| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT; ------------------ | | 237| 3.23k|#define OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT ((uint64_t)1<<9) ------------------ 589| 3.23k| decoded += size; 590| 3.23k| break; 591| 213| case OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_TYPE: ------------------ | | 272| 213|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_TYPE 0x5E ------------------ | Branch (591:9): [True: 213, False: 18.4k] ------------------ 592| 213| size = ogs_nas_eps_decode_gprs_timer_3(&attach_accept->t3412_extended_value, pkbuf); 593| 213| if (size < 0) { ------------------ | Branch (593:17): [True: 1, False: 212] ------------------ 594| 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__) | | ------------------ ------------------ 595| 1| return size; 596| 1| } 597| | 598| 212| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_PRESENT; ------------------ | | 238| 212|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_PRESENT ((uint64_t)1<<10) ------------------ 599| 212| decoded += size; 600| 212| break; 601| 196| case OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_TYPE: ------------------ | | 273| 196|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_TYPE 0x6A ------------------ | Branch (601:9): [True: 196, False: 18.4k] ------------------ 602| 196| size = ogs_nas_eps_decode_gprs_timer_2(&attach_accept->t3324_value, pkbuf); 603| 196| if (size < 0) { ------------------ | Branch (603:17): [True: 1, False: 195] ------------------ 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| 195| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_PRESENT; ------------------ | | 239| 195|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_PRESENT ((uint64_t)1<<11) ------------------ 609| 195| decoded += size; 610| 195| break; 611| 223| case OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE: ------------------ | | 274| 223|#define OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE 0x6E ------------------ | Branch (611:9): [True: 223, False: 18.4k] ------------------ 612| 223| size = ogs_nas_eps_decode_extended_drx_parameters(&attach_accept->extended_drx_parameters, pkbuf); 613| 223| if (size < 0) { ------------------ | Branch (613:17): [True: 1, False: 222] ------------------ 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| 222| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT; ------------------ | | 240| 222|#define OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT ((uint64_t)1<<12) ------------------ 619| 222| decoded += size; 620| 222| break; 621| 205| case OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_TYPE: ------------------ | | 275| 205|#define OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_TYPE 0x65 ------------------ | Branch (621:9): [True: 205, False: 18.4k] ------------------ 622| 205| size = ogs_nas_eps_decode_dcn_id(&attach_accept->dcn_id, pkbuf); 623| 205| if (size < 0) { ------------------ | Branch (623:17): [True: 1, False: 204] ------------------ 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| 204| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_PRESENT; ------------------ | | 241| 204|#define OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_PRESENT ((uint64_t)1<<13) ------------------ 629| 204| decoded += size; 630| 204| break; 631| 1.10k| case OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_TYPE: ------------------ | | 276| 1.10k|#define OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_TYPE 0xE0 ------------------ | Branch (631:9): [True: 1.10k, False: 17.5k] ------------------ 632| 1.10k| decoded--; 633| 1.10k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.10k| do { \ | | 114| 1.10k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.10k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.10k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.10k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 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.10k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.10k] | | ------------------ ------------------ 634| 1.10k| size = ogs_nas_eps_decode_sms_services_status(&attach_accept->sms_services_status, pkbuf); 635| 1.10k| if (size < 0) { ------------------ | Branch (635:17): [True: 0, False: 1.10k] ------------------ 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| 1.10k| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_PRESENT; ------------------ | | 242| 1.10k|#define OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_PRESENT ((uint64_t)1<<14) ------------------ 641| 1.10k| decoded += size; 642| 1.10k| break; 643| 509| case OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_TYPE: ------------------ | | 277| 509|#define OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_TYPE 0xD0 ------------------ | Branch (643:9): [True: 509, False: 18.1k] ------------------ 644| 509| decoded--; 645| 509| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 509| do { \ | | 114| 509| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 509|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 509, False: 0] | | | | ------------------ | | ------------------ | | 115| 509| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 509| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 509] | | ------------------ ------------------ 646| 509| size = ogs_nas_eps_decode_non_nw_provided_policies(&attach_accept->non_nw_provided_policies, pkbuf); 647| 509| if (size < 0) { ------------------ | Branch (647:17): [True: 0, False: 509] ------------------ 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| 509| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_PRESENT; ------------------ | | 243| 509|#define OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_PRESENT ((uint64_t)1<<15) ------------------ 653| 509| decoded += size; 654| 509| break; 655| 221| case OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_TYPE: ------------------ | | 278| 221|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_TYPE 0x6B ------------------ | Branch (655:9): [True: 221, False: 18.4k] ------------------ 656| 221| size = ogs_nas_eps_decode_gprs_timer_2(&attach_accept->t3448_value, pkbuf); 657| 221| if (size < 0) { ------------------ | Branch (657:17): [True: 1, False: 220] ------------------ 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| 220| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_PRESENT; ------------------ | | 244| 220|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_PRESENT ((uint64_t)1<<16) ------------------ 663| 220| decoded += size; 664| 220| break; 665| 297| case OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_TYPE: ------------------ | | 279| 297|#define OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_TYPE 0xC0 ------------------ | Branch (665:9): [True: 297, False: 18.3k] ------------------ 666| 297| decoded--; 667| 297| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 297| do { \ | | 114| 297| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 297|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 297, False: 0] | | | | ------------------ | | ------------------ | | 115| 297| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 297| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 297] | | ------------------ ------------------ 668| 297| size = ogs_nas_eps_decode_network_policy(&attach_accept->network_policy, pkbuf); 669| 297| if (size < 0) { ------------------ | Branch (669:17): [True: 0, False: 297] ------------------ 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| 297| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_PRESENT; ------------------ | | 245| 297|#define OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_PRESENT ((uint64_t)1<<17) ------------------ 675| 297| decoded += size; 676| 297| 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.4k] ------------------ 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| 219| case OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_TYPE: ------------------ | | 281| 219|#define OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_TYPE 0x7A ------------------ | Branch (687:9): [True: 219, False: 18.4k] ------------------ 688| 219| size = ogs_nas_eps_decode_extended_emergency_number_list(&attach_accept->extended_emergency_number_list, pkbuf); 689| 219| if (size < 0) { ------------------ | Branch (689:17): [True: 1, False: 218] ------------------ 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| 218| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_PRESENT; ------------------ | | 247| 218|#define OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_PRESENT ((uint64_t)1<<19) ------------------ 695| 218| decoded += size; 696| 218| break; 697| 211| case OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_TYPE: ------------------ | | 282| 211|#define OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_TYPE 0x7C ------------------ | Branch (697:9): [True: 211, False: 18.4k] ------------------ 698| 211| size = ogs_nas_eps_decode_ciphering_key_data(&attach_accept->ciphering_key_data, pkbuf); 699| 211| if (size < 0) { ------------------ | Branch (699:17): [True: 1, False: 210] ------------------ 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| 210| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_PRESENT; ------------------ | | 248| 210|#define OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_PRESENT ((uint64_t)1<<20) ------------------ 705| 210| decoded += size; 706| 210| break; 707| 198| case OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_TYPE: ------------------ | | 283| 198|#define OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_TYPE 0x66 ------------------ | Branch (707:9): [True: 198, False: 18.4k] ------------------ 708| 198| size = ogs_nas_eps_decode_ue_radio_capability_id(&attach_accept->ue_radio_capability_id, pkbuf); 709| 198| if (size < 0) { ------------------ | Branch (709:17): [True: 1, False: 197] ------------------ 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| 197| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_PRESENT; ------------------ | | 249| 197|#define OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_PRESENT ((uint64_t)1<<21) ------------------ 715| 197| decoded += size; 716| 197| break; 717| 918| case OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE: ------------------ | | 284| 918|#define OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE 0xB0 ------------------ | Branch (717:9): [True: 918, False: 17.7k] ------------------ 718| 918| decoded--; 719| 918| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 918| do { \ | | 114| 918| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 918|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 918, False: 0] | | | | ------------------ | | ------------------ | | 115| 918| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 918| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 918] | | ------------------ ------------------ 720| 918| size = ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication(&attach_accept->ue_radio_capability_id_deletion_indication, pkbuf); 721| 918| if (size < 0) { ------------------ | Branch (721:17): [True: 0, False: 918] ------------------ 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| 918| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT; ------------------ | | 250| 918|#define OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT ((uint64_t)1<<22) ------------------ 727| 918| decoded += size; 728| 918| break; 729| 203| case OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_TYPE: ------------------ | | 285| 203|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_TYPE 0x35 ------------------ | Branch (729:9): [True: 203, False: 18.4k] ------------------ 730| 203| size = ogs_nas_eps_decode_wus_assistance_information(&attach_accept->negotiated_wus_assistance_information, pkbuf); 731| 203| if (size < 0) { ------------------ | Branch (731:17): [True: 1, False: 202] ------------------ 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| 202| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_PRESENT; ------------------ | | 251| 202|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_PRESENT ((uint64_t)1<<23) ------------------ 737| 202| decoded += size; 738| 202| break; 739| 229| case OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_TYPE: ------------------ | | 286| 229|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_TYPE 0x36 ------------------ | Branch (739:9): [True: 229, False: 18.3k] ------------------ 740| 229| size = ogs_nas_eps_decode_nb_s1_drx_parameter(&attach_accept->negotiated_drx_parameter_in_nb_s1_mode, pkbuf); 741| 229| if (size < 0) { ------------------ | Branch (741:17): [True: 1, False: 228] ------------------ 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| 228| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT; ------------------ | | 252| 228|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT ((uint64_t)1<<24) ------------------ 747| 228| decoded += size; 748| 228| break; 749| 200| case OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_TYPE: ------------------ | | 287| 200|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_TYPE 0x38 ------------------ | Branch (749:9): [True: 200, False: 18.4k] ------------------ 750| 200| size = ogs_nas_eps_decode_imsi_offset(&attach_accept->negotiated_imsi_offset, pkbuf); 751| 200| if (size < 0) { ------------------ | Branch (751:17): [True: 1, False: 199] ------------------ 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| 199| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_PRESENT; ------------------ | | 253| 199|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_PRESENT ((uint64_t)1<<25) ------------------ 757| 199| decoded += size; 758| 199| break; 759| 211| case OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 288| 211|#define OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE 0x1D ------------------ | Branch (759:9): [True: 211, False: 18.4k] ------------------ 760| 211| size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_accept->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf); 761| 211| if (size < 0) { ------------------ | Branch (761:17): [True: 1, False: 210] ------------------ 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| 210| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT; ------------------ | | 254| 210|#define OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT ((uint64_t)1<<26) ------------------ 767| 210| decoded += size; 768| 210| break; 769| 222| case OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE: ------------------ | | 289| 222|#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: 222, False: 18.4k] ------------------ 770| 222| 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| 222| if (size < 0) { ------------------ | Branch (771:17): [True: 1, False: 221] ------------------ 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| 221| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT; ------------------ | | 255| 221|#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| 221| decoded += size; 778| 221| break; 779| 240| case OGS_NAS_EPS_ATTACH_ACCEPT_UNAVAILABILITY_CONFIGURATION_TYPE: ------------------ | | 290| 240|#define OGS_NAS_EPS_ATTACH_ACCEPT_UNAVAILABILITY_CONFIGURATION_TYPE 0x1F ------------------ | Branch (779:9): [True: 240, False: 18.3k] ------------------ 780| 240| size = ogs_nas_eps_decode_unavailability_configuration(&attach_accept->unavailability_configuration, pkbuf); 781| 240| if (size < 0) { ------------------ | Branch (781:17): [True: 2, False: 238] ------------------ 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| 238| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_UNAVAILABILITY_CONFIGURATION_PRESENT; ------------------ | | 256| 238|#define OGS_NAS_EPS_ATTACH_ACCEPT_UNAVAILABILITY_CONFIGURATION_PRESENT ((uint64_t)1<<28) ------------------ 787| 238| decoded += size; 788| 238| break; 789| 225| case OGS_NAS_EPS_ATTACH_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 291| 225|#define OGS_NAS_EPS_ATTACH_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (789:9): [True: 225, False: 18.3k] ------------------ 790| 225| size = ogs_nas_eps_decode_access_technology_utilization_control(&attach_accept->access_technology_utilization_control, pkbuf); 791| 225| if (size < 0) { ------------------ | Branch (791:17): [True: 1, False: 224] ------------------ 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| 224| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 257| 224|#define OGS_NAS_EPS_ATTACH_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<29) ------------------ 797| 224| decoded += size; 798| 224| break; 799| 219| case OGS_NAS_EPS_ATTACH_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 292| 219|#define OGS_NAS_EPS_ATTACH_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (799:9): [True: 219, False: 18.4k] ------------------ 800| 219| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&attach_accept->s_f_satellite_operation_parameters, pkbuf); 801| 219| if (size < 0) { ------------------ | Branch (801:17): [True: 1, False: 218] ------------------ 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| 218| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 258| 218|#define OGS_NAS_EPS_ATTACH_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<30) ------------------ 807| 218| decoded += size; 808| 218| break; 809| 200| case OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_TYPE: ------------------ | | 293| 200|#define OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_TYPE 0x22 ------------------ | Branch (809:9): [True: 200, False: 18.4k] ------------------ 810| 200| size = ogs_nas_eps_decode_registration_wait_range(&attach_accept->disaster_roaming_wait_range, pkbuf); 811| 200| if (size < 0) { ------------------ | Branch (811:17): [True: 2, False: 198] ------------------ 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| 198| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_PRESENT; ------------------ | | 259| 198|#define OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_PRESENT ((uint64_t)1<<31) ------------------ 817| 198| decoded += size; 818| 198| break; 819| 203| case OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_RETURN_WAIT_RANGE_TYPE: ------------------ | | 294| 203|#define OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_RETURN_WAIT_RANGE_TYPE 0x24 ------------------ | Branch (819:9): [True: 203, False: 18.4k] ------------------ 820| 203| size = ogs_nas_eps_decode_registration_wait_range(&attach_accept->disaster_return_wait_range, pkbuf); 821| 203| if (size < 0) { ------------------ | Branch (821:17): [True: 1, False: 202] ------------------ 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| 202| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_RETURN_WAIT_RANGE_PRESENT; ------------------ | | 260| 202|#define OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_RETURN_WAIT_RANGE_PRESENT ((uint64_t)1<<32) ------------------ 827| 202| decoded += size; 828| 202| break; 829| 234| case OGS_NAS_EPS_ATTACH_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_TYPE: ------------------ | | 295| 234|#define OGS_NAS_EPS_ATTACH_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_TYPE 0x25 ------------------ | Branch (829:9): [True: 234, False: 18.3k] ------------------ 830| 234| 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| 234| if (size < 0) { ------------------ | Branch (831:17): [True: 1, False: 233] ------------------ 832| 1| ogs_error("ogs_nas_eps_decode_list_of_plmns_to_be_used_in_disaster_condition() 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__) | | ------------------ ------------------ 833| 1| return size; 834| 1| } 835| | 836| 233| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_PRESENT; ------------------ | | 261| 233|#define OGS_NAS_EPS_ATTACH_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_PRESENT ((uint64_t)1<<33) ------------------ 837| 233| decoded += size; 838| 233| break; 839| 6.13k| default: ------------------ | Branch (839:9): [True: 6.13k, False: 12.4k] ------------------ 840| 6.13k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 6.13k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6.13k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6.13k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6.13k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6.13k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6.13k| 0, __VA_ARGS__) | | ------------------ ------------------ 841| 6.13k| break; 842| 18.6k| } 843| 18.6k| } 844| | 845| 391| return decoded; 846| 423|} ogs_nas_eps_decode_attach_complete: 849| 39|{ 850| 39| ogs_nas_eps_attach_complete_t *attach_complete = &message->emm.attach_complete; 851| 39| int decoded = 0; 852| 39| int size = 0; 853| | 854| 39| ogs_trace("[NAS] Decode ATTACH_COMPLETE\n"); ------------------ | | 40| 39|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 39| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 39|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 39| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 39|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 39| 0, __VA_ARGS__) | | ------------------ ------------------ 855| | 856| 39| size = ogs_nas_eps_decode_esm_message_container(&attach_complete->esm_message_container, pkbuf); 857| 39| if (size < 0) { ------------------ | Branch (857:9): [True: 19, False: 20] ------------------ 858| 19| ogs_error("ogs_nas_eps_decode_esm_message_container() failed"); ------------------ | | 36| 19|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 19| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 19|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 19| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 19|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 19| 0, __VA_ARGS__) | | ------------------ ------------------ 859| 19| return size; 860| 19| } 861| | 862| 20| decoded += size; 863| | 864| 20| return decoded; 865| 39|} ogs_nas_eps_decode_attach_reject: 868| 164|{ 869| 164| ogs_nas_eps_attach_reject_t *attach_reject = &message->emm.attach_reject; 870| 164| int decoded = 0; 871| 164| int size = 0; 872| | 873| 164| ogs_trace("[NAS] Decode ATTACH_REJECT\n"); ------------------ | | 40| 164|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 164| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 164|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 164| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 164|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 164| 0, __VA_ARGS__) | | ------------------ ------------------ 874| | 875| 164| size = ogs_nas_eps_decode_emm_cause(&attach_reject->emm_cause, pkbuf); 876| 164| if (size < 0) { ------------------ | Branch (876:9): [True: 0, False: 164] ------------------ 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| 164| decoded += size; 882| | 883| 9.37k| while (pkbuf->len > 0) { ------------------ | Branch (883:12): [True: 9.23k, False: 135] ------------------ 884| 9.23k| uint8_t *buffer = pkbuf->data; 885| 9.23k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (885:24): [True: 2.81k, False: 6.42k] ------------------ 886| | 887| 9.23k| size = sizeof(uint8_t); 888| 9.23k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (888:13): [True: 0, False: 9.23k] ------------------ 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| 9.23k| decoded += size; 893| | 894| 9.23k| switch (type) { 895| 285| case OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_TYPE: ------------------ | | 365| 285|#define OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_TYPE 0x78 ------------------ | Branch (895:9): [True: 285, False: 8.95k] ------------------ 896| 285| size = ogs_nas_eps_decode_esm_message_container(&attach_reject->esm_message_container, pkbuf); 897| 285| if (size < 0) { ------------------ | Branch (897:17): [True: 8, False: 277] ------------------ 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| 277| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_PRESENT; ------------------ | | 356| 277|#define OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_PRESENT ((uint64_t)1<<0) ------------------ 903| 277| decoded += size; 904| 277| break; 905| 200| case OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_TYPE: ------------------ | | 366| 200|#define OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_TYPE 0x5F ------------------ | Branch (905:9): [True: 200, False: 9.03k] ------------------ 906| 200| size = ogs_nas_eps_decode_gprs_timer_2(&attach_reject->t3346_value, pkbuf); 907| 200| if (size < 0) { ------------------ | Branch (907:17): [True: 1, False: 199] ------------------ 908| 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__) | | ------------------ ------------------ 909| 1| return size; 910| 1| } 911| | 912| 199| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_PRESENT; ------------------ | | 357| 199|#define OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_PRESENT ((uint64_t)1<<1) ------------------ 913| 199| decoded += size; 914| 199| break; 915| 219| case OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_TYPE: ------------------ | | 367| 219|#define OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_TYPE 0x16 ------------------ | Branch (915:9): [True: 219, False: 9.02k] ------------------ 916| 219| size = ogs_nas_eps_decode_gprs_timer_2(&attach_reject->t3402_value, pkbuf); 917| 219| if (size < 0) { ------------------ | Branch (917:17): [True: 7, False: 212] ------------------ 918| 7| ogs_error("ogs_nas_eps_decode_gprs_timer_2() 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__) | | ------------------ ------------------ 919| 7| return size; 920| 7| } 921| | 922| 212| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_PRESENT; ------------------ | | 358| 212|#define OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_PRESENT ((uint64_t)1<<2) ------------------ 923| 212| decoded += size; 924| 212| break; 925| 903| case OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_TYPE: ------------------ | | 368| 903|#define OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_TYPE 0xA0 ------------------ | Branch (925:9): [True: 903, False: 8.33k] ------------------ 926| 903| decoded--; 927| 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] | | ------------------ ------------------ 928| 903| size = ogs_nas_eps_decode_extended_emm_cause(&attach_reject->extended_emm_cause, pkbuf); 929| 903| if (size < 0) { ------------------ | Branch (929:17): [True: 0, False: 903] ------------------ 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| 903| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_PRESENT; ------------------ | | 359| 903|#define OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_PRESENT ((uint64_t)1<<3) ------------------ 935| 903| decoded += size; 936| 903| break; 937| 313| case OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE: ------------------ | | 369| 313|#define OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE 0x1C ------------------ | Branch (937:9): [True: 313, False: 8.92k] ------------------ 938| 313| size = ogs_nas_eps_decode_gprs_timer_3(&attach_reject->lower_bound_timer_value, pkbuf); 939| 313| if (size < 0) { ------------------ | Branch (939:17): [True: 5, False: 308] ------------------ 940| 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__) | | ------------------ ------------------ 941| 5| return size; 942| 5| } 943| | 944| 308| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT; ------------------ | | 360| 308|#define OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT ((uint64_t)1<<4) ------------------ 945| 308| decoded += size; 946| 308| break; 947| 206| case OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 370| 206|#define OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE 0x1D ------------------ | Branch (947:9): [True: 206, False: 9.03k] ------------------ 948| 206| size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf); 949| 206| if (size < 0) { ------------------ | Branch (949:17): [True: 1, False: 205] ------------------ 950| 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__) | | ------------------ ------------------ 951| 1| return size; 952| 1| } 953| | 954| 205| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT; ------------------ | | 361| 205|#define OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT ((uint64_t)1<<5) ------------------ 955| 205| decoded += size; 956| 205| break; 957| 205| case OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE: ------------------ | | 371| 205|#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: 205, False: 9.03k] ------------------ 958| 205| 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| 205| if (size < 0) { ------------------ | Branch (959:17): [True: 2, False: 203] ------------------ 960| 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__) | | ------------------ ------------------ 961| 2| return size; 962| 2| } 963| | 964| 203| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT; ------------------ | | 362| 203|#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| 203| decoded += size; 966| 203| break; 967| 235| case OGS_NAS_EPS_ATTACH_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 372| 235|#define OGS_NAS_EPS_ATTACH_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (967:9): [True: 235, False: 9.00k] ------------------ 968| 235| size = ogs_nas_eps_decode_access_technology_utilization_control(&attach_reject->access_technology_utilization_control, pkbuf); 969| 235| if (size < 0) { ------------------ | Branch (969:17): [True: 1, False: 234] ------------------ 970| 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__) | | ------------------ ------------------ 971| 1| return size; 972| 1| } 973| | 974| 234| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 363| 234|#define OGS_NAS_EPS_ATTACH_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<7) ------------------ 975| 234| decoded += size; 976| 234| break; 977| 241| case OGS_NAS_EPS_ATTACH_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 373| 241|#define OGS_NAS_EPS_ATTACH_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (977:9): [True: 241, False: 8.99k] ------------------ 978| 241| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&attach_reject->s_f_satellite_operation_parameters, pkbuf); 979| 241| if (size < 0) { ------------------ | Branch (979:17): [True: 4, False: 237] ------------------ 980| 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__) | | ------------------ ------------------ 981| 4| return size; 982| 4| } 983| | 984| 237| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 364| 237|#define OGS_NAS_EPS_ATTACH_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<8) ------------------ 985| 237| decoded += size; 986| 237| break; 987| 6.43k| default: ------------------ | Branch (987:9): [True: 6.43k, False: 2.80k] ------------------ 988| 6.43k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 6.43k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6.43k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6.43k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6.43k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6.43k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6.43k| 0, __VA_ARGS__) | | ------------------ ------------------ 989| 6.43k| break; 990| 9.23k| } 991| 9.23k| } 992| | 993| 135| return decoded; 994| 164|} ogs_nas_eps_decode_detach_request_from_ue: 997| 8|{ 998| 8| ogs_nas_eps_detach_request_from_ue_t *detach_request_from_ue = &message->emm.detach_request_from_ue; 999| 8| int decoded = 0; 1000| 8| int size = 0; 1001| | 1002| 8| ogs_trace("[NAS] Decode DETACH_REQUEST\n"); ------------------ | | 40| 8|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 1003| | 1004| 8| size = ogs_nas_eps_decode_detach_type(&detach_request_from_ue->detach_type, pkbuf); 1005| 8| if (size < 0) { ------------------ | Branch (1005:9): [True: 0, False: 8] ------------------ 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| 8| decoded += size; 1011| | 1012| 8| size = ogs_nas_eps_decode_eps_mobile_identity(&detach_request_from_ue->eps_mobile_identity, pkbuf); 1013| 8| if (size < 0) { ------------------ | Branch (1013:9): [True: 2, False: 6] ------------------ 1014| 2| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() 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__) | | ------------------ ------------------ 1015| 2| return size; 1016| 2| } 1017| | 1018| 6| decoded += size; 1019| | 1020| 6| return decoded; 1021| 8|} ogs_nas_eps_decode_tracking_area_update_request: 1131| 689|{ 1132| 689| ogs_nas_eps_tracking_area_update_request_t *tracking_area_update_request = &message->emm.tracking_area_update_request; 1133| 689| int decoded = 0; 1134| 689| int size = 0; 1135| | 1136| 689| ogs_trace("[NAS] Decode TRACKING_AREA_UPDATE_REQUEST\n"); ------------------ | | 40| 689|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 689| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 689|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 689| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 689|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 689| 0, __VA_ARGS__) | | ------------------ ------------------ 1137| | 1138| 689| size = ogs_nas_eps_decode_eps_update_type(&tracking_area_update_request->eps_update_type, pkbuf); 1139| 689| if (size < 0) { ------------------ | Branch (1139:9): [True: 0, False: 689] ------------------ 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| 689| decoded += size; 1145| | 1146| 689| size = ogs_nas_eps_decode_eps_mobile_identity(&tracking_area_update_request->old_guti, pkbuf); 1147| 689| if (size < 0) { ------------------ | Branch (1147:9): [True: 5, False: 684] ------------------ 1148| 5| ogs_error("ogs_nas_eps_decode_eps_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__) | | ------------------ ------------------ 1149| 5| return size; 1150| 5| } 1151| | 1152| 684| decoded += size; 1153| | 1154| 36.5k| while (pkbuf->len > 0) { ------------------ | Branch (1154:12): [True: 36.0k, False: 490] ------------------ 1155| 36.0k| uint8_t *buffer = pkbuf->data; 1156| 36.0k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (1156:24): [True: 13.4k, False: 22.5k] ------------------ 1157| | 1158| 36.0k| size = sizeof(uint8_t); 1159| 36.0k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1159:13): [True: 0, False: 36.0k] ------------------ 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| 36.0k| decoded += size; 1164| | 1165| 36.0k| switch (type) { 1166| 780| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_TYPE: ------------------ | | 478| 780|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_TYPE 0xB0 ------------------ | Branch (1166:9): [True: 780, False: 35.2k] ------------------ 1167| 780| decoded--; 1168| 780| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 780| do { \ | | 114| 780| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 780|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 780, False: 0] | | | | ------------------ | | ------------------ | | 115| 780| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 780| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 780] | | ------------------ ------------------ 1169| 780| size = ogs_nas_eps_decode_key_set_identifier(&tracking_area_update_request->non_current_native_nas_key_set_identifier, pkbuf); 1170| 780| if (size < 0) { ------------------ | Branch (1170:17): [True: 0, False: 780] ------------------ 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| 780| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_PRESENT; ------------------ | | 441| 780|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_PRESENT ((uint64_t)1<<0) ------------------ 1176| 780| decoded += size; 1177| 780| break; 1178| 1.00k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_TYPE: ------------------ | | 479| 1.00k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_TYPE 0x80 ------------------ | Branch (1178:9): [True: 1.00k, False: 35.0k] ------------------ 1179| 1.00k| decoded--; 1180| 1.00k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.00k| do { \ | | 114| 1.00k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.00k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.00k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.00k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.00k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.00k] | | ------------------ ------------------ 1181| 1.00k| size = ogs_nas_eps_decode_ciphering_key_sequence_number(&tracking_area_update_request->gprs_ciphering_key_sequence_number, pkbuf); 1182| 1.00k| if (size < 0) { ------------------ | Branch (1182:17): [True: 0, False: 1.00k] ------------------ 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.00k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_PRESENT; ------------------ | | 442| 1.00k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_PRESENT ((uint64_t)1<<1) ------------------ 1188| 1.00k| decoded += size; 1189| 1.00k| break; 1190| 295| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE: ------------------ | | 480| 295|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE 0x19 ------------------ | Branch (1190:9): [True: 295, False: 35.7k] ------------------ 1191| 295| size = ogs_nas_eps_decode_p_tmsi_signature(&tracking_area_update_request->old_p_tmsi_signature, pkbuf); 1192| 295| if (size < 0) { ------------------ | Branch (1192:17): [True: 8, False: 287] ------------------ 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| 287| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT; ------------------ | | 443| 287|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT ((uint64_t)1<<2) ------------------ 1198| 287| decoded += size; 1199| 287| break; 1200| 601| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_TYPE: ------------------ | | 481| 601|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_TYPE 0x50 ------------------ | Branch (1200:9): [True: 601, False: 35.4k] ------------------ 1201| 601| size = ogs_nas_eps_decode_eps_mobile_identity(&tracking_area_update_request->additional_guti, pkbuf); 1202| 601| if (size < 0) { ------------------ | Branch (1202:17): [True: 6, False: 595] ------------------ 1203| 6| ogs_error("ogs_nas_eps_decode_eps_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__) | | ------------------ ------------------ 1204| 6| return size; 1205| 6| } 1206| | 1207| 595| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_PRESENT; ------------------ | | 444| 595|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_PRESENT ((uint64_t)1<<3) ------------------ 1208| 595| decoded += size; 1209| 595| break; 1210| 296| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_TYPE: ------------------ | | 482| 296|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_TYPE 0x55 ------------------ | Branch (1210:9): [True: 296, False: 35.7k] ------------------ 1211| 296| size = ogs_nas_eps_decode_nonce(&tracking_area_update_request->nonceue, pkbuf); 1212| 296| if (size < 0) { ------------------ | Branch (1212:17): [True: 9, False: 287] ------------------ 1213| 9| ogs_error("ogs_nas_eps_decode_nonce() 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__) | | ------------------ ------------------ 1214| 9| return size; 1215| 9| } 1216| | 1217| 287| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_PRESENT; ------------------ | | 445| 287|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_PRESENT ((uint64_t)1<<4) ------------------ 1218| 287| decoded += size; 1219| 287| break; 1220| 423| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_TYPE: ------------------ | | 483| 423|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_TYPE 0x58 ------------------ | Branch (1220:9): [True: 423, False: 35.6k] ------------------ 1221| 423| size = ogs_nas_eps_decode_ue_network_capability(&tracking_area_update_request->ue_network_capability, pkbuf); 1222| 423| if (size < 0) { ------------------ | Branch (1222:17): [True: 7, False: 416] ------------------ 1223| 7| ogs_error("ogs_nas_eps_decode_ue_network_capability() 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__) | | ------------------ ------------------ 1224| 7| return size; 1225| 7| } 1226| | 1227| 416| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_PRESENT; ------------------ | | 446| 416|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<5) ------------------ 1228| 416| decoded += size; 1229| 416| break; 1230| 359| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE: ------------------ | | 484| 359|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE 0x52 ------------------ | Branch (1230:9): [True: 359, False: 35.6k] ------------------ 1231| 359| size = ogs_nas_eps_decode_tracking_area_identity(&tracking_area_update_request->last_visited_registered_tai, pkbuf); 1232| 359| if (size < 0) { ------------------ | Branch (1232:17): [True: 10, False: 349] ------------------ 1233| 10| ogs_error("ogs_nas_eps_decode_tracking_area_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__) | | ------------------ ------------------ 1234| 10| return size; 1235| 10| } 1236| | 1237| 349| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT; ------------------ | | 447| 349|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT ((uint64_t)1<<6) ------------------ 1238| 349| decoded += size; 1239| 349| break; 1240| 453| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_TYPE: ------------------ | | 485| 453|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_TYPE 0x5C ------------------ | Branch (1240:9): [True: 453, False: 35.5k] ------------------ 1241| 453| size = ogs_nas_eps_decode_drx_parameter(&tracking_area_update_request->drx_parameter, pkbuf); 1242| 453| if (size < 0) { ------------------ | Branch (1242:17): [True: 7, False: 446] ------------------ 1243| 7| ogs_error("ogs_nas_eps_decode_drx_parameter() 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__) | | ------------------ ------------------ 1244| 7| return size; 1245| 7| } 1246| | 1247| 446| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_PRESENT; ------------------ | | 448| 446|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_PRESENT ((uint64_t)1<<7) ------------------ 1248| 446| decoded += size; 1249| 446| break; 1250| 1.11k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_TYPE: ------------------ | | 486| 1.11k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_TYPE 0xA0 ------------------ | Branch (1250:9): [True: 1.11k, False: 34.9k] ------------------ 1251| 1.11k| decoded--; 1252| 1.11k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.11k| do { \ | | 114| 1.11k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.11k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.11k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.11k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 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.11k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.11k] | | ------------------ ------------------ 1253| 1.11k| size = ogs_nas_eps_decode_ue_radio_capability_information_update_needed(&tracking_area_update_request->ue_radio_capability_information_update_needed, pkbuf); 1254| 1.11k| if (size < 0) { ------------------ | Branch (1254:17): [True: 0, False: 1.11k] ------------------ 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| 1.11k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_PRESENT; ------------------ | | 449| 1.11k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_PRESENT ((uint64_t)1<<8) ------------------ 1260| 1.11k| decoded += size; 1261| 1.11k| break; 1262| 280| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE: ------------------ | | 487| 280|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE 0x57 ------------------ | Branch (1262:9): [True: 280, False: 35.7k] ------------------ 1263| 280| size = ogs_nas_eps_decode_eps_bearer_context_status(&tracking_area_update_request->eps_bearer_context_status, pkbuf); 1264| 280| if (size < 0) { ------------------ | Branch (1264:17): [True: 2, False: 278] ------------------ 1265| 2| ogs_error("ogs_nas_eps_decode_eps_bearer_context_status() 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__) | | ------------------ ------------------ 1266| 2| return size; 1267| 2| } 1268| | 1269| 278| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT; ------------------ | | 450| 278|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT ((uint64_t)1<<9) ------------------ 1270| 278| decoded += size; 1271| 278| break; 1272| 230| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_TYPE: ------------------ | | 488| 230|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_TYPE 0x31 ------------------ | Branch (1272:9): [True: 230, False: 35.8k] ------------------ 1273| 230| size = ogs_nas_eps_decode_ms_network_capability(&tracking_area_update_request->ms_network_capability, pkbuf); 1274| 230| if (size < 0) { ------------------ | Branch (1274:17): [True: 7, False: 223] ------------------ 1275| 7| ogs_error("ogs_nas_eps_decode_ms_network_capability() 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__) | | ------------------ ------------------ 1276| 7| return size; 1277| 7| } 1278| | 1279| 223| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_PRESENT; ------------------ | | 451| 223|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<10) ------------------ 1280| 223| decoded += size; 1281| 223| break; 1282| 263| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE: ------------------ | | 489| 263|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 ------------------ | Branch (1282:9): [True: 263, False: 35.7k] ------------------ 1283| 263| size = ogs_nas_eps_decode_location_area_identification(&tracking_area_update_request->old_location_area_identification, pkbuf); 1284| 263| if (size < 0) { ------------------ | Branch (1284:17): [True: 1, False: 262] ------------------ 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| 262| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT; ------------------ | | 452| 262|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT ((uint64_t)1<<11) ------------------ 1290| 262| decoded += size; 1291| 262| break; 1292| 1.14k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_TYPE: ------------------ | | 490| 1.14k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_TYPE 0x90 ------------------ | Branch (1292:9): [True: 1.14k, False: 34.8k] ------------------ 1293| 1.14k| decoded--; 1294| 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] | | ------------------ ------------------ 1295| 1.14k| size = ogs_nas_eps_decode_tmsi_status(&tracking_area_update_request->tmsi_status, pkbuf); 1296| 1.14k| if (size < 0) { ------------------ | Branch (1296:17): [True: 0, False: 1.14k] ------------------ 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.14k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_PRESENT; ------------------ | | 453| 1.14k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_PRESENT ((uint64_t)1<<12) ------------------ 1302| 1.14k| decoded += size; 1303| 1.14k| break; 1304| 223| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE: ------------------ | | 491| 223|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE 0x11 ------------------ | Branch (1304:9): [True: 223, False: 35.8k] ------------------ 1305| 223| size = ogs_nas_eps_decode_mobile_station_classmark_2(&tracking_area_update_request->mobile_station_classmark_2, pkbuf); 1306| 223| if (size < 0) { ------------------ | Branch (1306:17): [True: 4, False: 219] ------------------ 1307| 4| ogs_error("ogs_nas_eps_decode_mobile_station_classmark_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__) | | ------------------ ------------------ 1308| 4| return size; 1309| 4| } 1310| | 1311| 219| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT; ------------------ | | 454| 219|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT ((uint64_t)1<<13) ------------------ 1312| 219| decoded += size; 1313| 219| break; 1314| 290| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE: ------------------ | | 492| 290|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE 0x20 ------------------ | Branch (1314:9): [True: 290, False: 35.7k] ------------------ 1315| 290| size = ogs_nas_eps_decode_mobile_station_classmark_3(&tracking_area_update_request->mobile_station_classmark_3, pkbuf); 1316| 290| if (size < 0) { ------------------ | Branch (1316:17): [True: 7, False: 283] ------------------ 1317| 7| ogs_error("ogs_nas_eps_decode_mobile_station_classmark_3() 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__) | | ------------------ ------------------ 1318| 7| return size; 1319| 7| } 1320| | 1321| 283| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT; ------------------ | | 455| 283|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT ((uint64_t)1<<14) ------------------ 1322| 283| decoded += size; 1323| 283| break; 1324| 294| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_TYPE: ------------------ | | 493| 294|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_TYPE 0x40 ------------------ | Branch (1324:9): [True: 294, False: 35.7k] ------------------ 1325| 294| size = ogs_nas_eps_decode_supported_codec_list(&tracking_area_update_request->supported_codecs, pkbuf); 1326| 294| if (size < 0) { ------------------ | Branch (1326:17): [True: 5, False: 289] ------------------ 1327| 5| ogs_error("ogs_nas_eps_decode_supported_codec_list() 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__) | | ------------------ ------------------ 1328| 5| return size; 1329| 5| } 1330| | 1331| 289| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_PRESENT; ------------------ | | 456| 289|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_PRESENT ((uint64_t)1<<15) ------------------ 1332| 289| decoded += size; 1333| 289| break; 1334| 5.40k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE: ------------------ | | 494| 5.40k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE 0xF0 ------------------ | Branch (1334:9): [True: 5.40k, False: 30.6k] ------------------ 1335| 5.40k| decoded--; 1336| 5.40k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 5.40k| do { \ | | 114| 5.40k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 5.40k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 5.40k, False: 0] | | | | ------------------ | | ------------------ | | 115| 5.40k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 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| 5.40k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 5.40k] | | ------------------ ------------------ 1337| 5.40k| size = ogs_nas_eps_decode_additional_update_type(&tracking_area_update_request->additional_update_type, pkbuf); 1338| 5.40k| if (size < 0) { ------------------ | Branch (1338:17): [True: 0, False: 5.40k] ------------------ 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| 5.40k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT; ------------------ | | 457| 5.40k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT ((uint64_t)1<<16) ------------------ 1344| 5.40k| decoded += size; 1345| 5.40k| break; 1346| 231| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE: ------------------ | | 495| 231|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE 0x5D ------------------ | Branch (1346:9): [True: 231, False: 35.8k] ------------------ 1347| 231| 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| 231| if (size < 0) { ------------------ | Branch (1348:17): [True: 7, False: 224] ------------------ 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| 224| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT; ------------------ | | 458| 224|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT ((uint64_t)1<<17) ------------------ 1354| 224| decoded += size; 1355| 224| break; 1356| 1.02k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_TYPE: ------------------ | | 496| 1.02k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_TYPE 0xE0 ------------------ | Branch (1356:9): [True: 1.02k, False: 35.0k] ------------------ 1357| 1.02k| decoded--; 1358| 1.02k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.02k| do { \ | | 114| 1.02k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.02k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.02k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.02k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.02k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.02k] | | ------------------ ------------------ 1359| 1.02k| size = ogs_nas_eps_decode_guti_type(&tracking_area_update_request->old_guti_type, pkbuf); 1360| 1.02k| if (size < 0) { ------------------ | Branch (1360:17): [True: 0, False: 1.02k] ------------------ 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| 1.02k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_PRESENT; ------------------ | | 459| 1.02k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_PRESENT ((uint64_t)1<<18) ------------------ 1366| 1.02k| decoded += size; 1367| 1.02k| break; 1368| 1.26k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_TYPE: ------------------ | | 497| 1.26k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_TYPE 0xD0 ------------------ | Branch (1368:9): [True: 1.26k, False: 34.7k] ------------------ 1369| 1.26k| decoded--; 1370| 1.26k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.26k| do { \ | | 114| 1.26k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.26k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.26k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.26k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.26k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.26k] | | ------------------ ------------------ 1371| 1.26k| size = ogs_nas_eps_decode_device_properties(&tracking_area_update_request->device_properties, pkbuf); 1372| 1.26k| if (size < 0) { ------------------ | Branch (1372:17): [True: 0, False: 1.26k] ------------------ 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.26k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_PRESENT; ------------------ | | 460| 1.26k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_PRESENT ((uint64_t)1<<19) ------------------ 1378| 1.26k| decoded += size; 1379| 1.26k| break; 1380| 1.70k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE: ------------------ | | 498| 1.70k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE 0xC0 ------------------ | Branch (1380:9): [True: 1.70k, False: 34.3k] ------------------ 1381| 1.70k| decoded--; 1382| 1.70k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.70k| do { \ | | 114| 1.70k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.70k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.70k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.70k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 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.70k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.70k] | | ------------------ ------------------ 1383| 1.70k| size = ogs_nas_eps_decode_ms_network_feature_support(&tracking_area_update_request->ms_network_feature_support, pkbuf); 1384| 1.70k| if (size < 0) { ------------------ | Branch (1384:17): [True: 0, False: 1.70k] ------------------ 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| 1.70k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT; ------------------ | | 461| 1.70k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT ((uint64_t)1<<20) ------------------ 1390| 1.70k| decoded += size; 1391| 1.70k| break; 1392| 327| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE: ------------------ | | 499| 327|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE 0x10 ------------------ | Branch (1392:9): [True: 327, False: 35.7k] ------------------ 1393| 327| size = ogs_nas_eps_decode_network_resource_identifier_container(&tracking_area_update_request->tmsi_based_nri_container, pkbuf); 1394| 327| if (size < 0) { ------------------ | Branch (1394:17): [True: 15, False: 312] ------------------ 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| 312| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT; ------------------ | | 462| 312|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT ((uint64_t)1<<21) ------------------ 1400| 312| decoded += size; 1401| 312| break; 1402| 201| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_TYPE: ------------------ | | 500| 201|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_TYPE 0x6A ------------------ | Branch (1402:9): [True: 201, False: 35.8k] ------------------ 1403| 201| size = ogs_nas_eps_decode_gprs_timer_2(&tracking_area_update_request->t3324_value, pkbuf); 1404| 201| if (size < 0) { ------------------ | Branch (1404:17): [True: 1, False: 200] ------------------ 1405| 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__) | | ------------------ ------------------ 1406| 1| return size; 1407| 1| } 1408| | 1409| 200| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_PRESENT; ------------------ | | 463| 200|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_PRESENT ((uint64_t)1<<22) ------------------ 1410| 200| decoded += size; 1411| 200| break; 1412| 219| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_TYPE: ------------------ | | 501| 219|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_TYPE 0x5E ------------------ | Branch (1412:9): [True: 219, False: 35.8k] ------------------ 1413| 219| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_request->t3412_extended_value, pkbuf); 1414| 219| if (size < 0) { ------------------ | Branch (1414:17): [True: 2, False: 217] ------------------ 1415| 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__) | | ------------------ ------------------ 1416| 2| return size; 1417| 2| } 1418| | 1419| 217| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_PRESENT; ------------------ | | 464| 217|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_PRESENT ((uint64_t)1<<23) ------------------ 1420| 217| decoded += size; 1421| 217| break; 1422| 207| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE: ------------------ | | 502| 207|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE 0x6E ------------------ | Branch (1422:9): [True: 207, False: 35.8k] ------------------ 1423| 207| size = ogs_nas_eps_decode_extended_drx_parameters(&tracking_area_update_request->extended_drx_parameters, pkbuf); 1424| 207| if (size < 0) { ------------------ | Branch (1424:17): [True: 1, False: 206] ------------------ 1425| 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__) | | ------------------ ------------------ 1426| 1| return size; 1427| 1| } 1428| | 1429| 206| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT; ------------------ | | 465| 206|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT ((uint64_t)1<<24) ------------------ 1430| 206| decoded += size; 1431| 206| break; 1432| 277| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE: ------------------ | | 503| 277|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE 0x6F ------------------ | Branch (1432:9): [True: 277, False: 35.7k] ------------------ 1433| 277| size = ogs_nas_eps_decode_ue_additional_security_capability(&tracking_area_update_request->ue_additional_security_capability, pkbuf); 1434| 277| if (size < 0) { ------------------ | Branch (1434:17): [True: 10, False: 267] ------------------ 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| 267| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT; ------------------ | | 466| 267|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT ((uint64_t)1<<25) ------------------ 1440| 267| decoded += size; 1441| 267| break; 1442| 248| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_STATUS_TYPE: ------------------ | | 504| 248|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_STATUS_TYPE 0x6D ------------------ | Branch (1442:9): [True: 248, False: 35.7k] ------------------ 1443| 248| size = ogs_nas_eps_decode_ue_status(&tracking_area_update_request->ue_status, pkbuf); 1444| 248| if (size < 0) { ------------------ | Branch (1444:17): [True: 8, False: 240] ------------------ 1445| 8| ogs_error("ogs_nas_eps_decode_ue_status() 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__) | | ------------------ ------------------ 1446| 8| return size; 1447| 8| } 1448| | 1449| 240| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_STATUS_PRESENT; ------------------ | | 467| 240|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_STATUS_PRESENT ((uint64_t)1<<26) ------------------ 1450| 240| decoded += size; 1451| 240| break; 1452| 554| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_TYPE: ------------------ | | 505| 554|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_TYPE 0x17 ------------------ | Branch (1452:9): [True: 554, False: 35.4k] ------------------ 1453| 554| size = ogs_nas_eps_decode_additional_information_requested(&tracking_area_update_request->additional_information_requested, pkbuf); 1454| 554| if (size < 0) { ------------------ | Branch (1454:17): [True: 9, False: 545] ------------------ 1455| 9| ogs_error("ogs_nas_eps_decode_additional_information_requested() 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__) | | ------------------ ------------------ 1456| 9| return size; 1457| 9| } 1458| | 1459| 545| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_PRESENT; ------------------ | | 468| 545|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_PRESENT ((uint64_t)1<<27) ------------------ 1460| 545| decoded += size; 1461| 545| break; 1462| 490| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_N1_UE_NETWORK_CAPABILITY_TYPE: ------------------ | | 506| 490|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_N1_UE_NETWORK_CAPABILITY_TYPE 0x32 ------------------ | Branch (1462:9): [True: 490, False: 35.5k] ------------------ 1463| 490| size = ogs_nas_eps_decode_n1_ue_network_capability(&tracking_area_update_request->n1_ue_network_capability, pkbuf); 1464| 490| if (size < 0) { ------------------ | Branch (1464:17): [True: 15, False: 475] ------------------ 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| 475| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_N1_UE_NETWORK_CAPABILITY_PRESENT; ------------------ | | 469| 475|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_N1_UE_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<28) ------------------ 1470| 475| decoded += size; 1471| 475| break; 1472| 379| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_TYPE: ------------------ | | 507| 379|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_TYPE 0x34 ------------------ | Branch (1472:9): [True: 379, False: 35.6k] ------------------ 1473| 379| size = ogs_nas_eps_decode_ue_radio_capability_id_availability(&tracking_area_update_request->ue_radio_capability_id_availability, pkbuf); 1474| 379| if (size < 0) { ------------------ | Branch (1474:17): [True: 16, False: 363] ------------------ 1475| 16| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_availability() 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__) | | ------------------ ------------------ 1476| 16| return size; 1477| 16| } 1478| | 1479| 363| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_PRESENT; ------------------ | | 470| 363|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_PRESENT ((uint64_t)1<<29) ------------------ 1480| 363| decoded += size; 1481| 363| break; 1482| 281| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_TYPE: ------------------ | | 508| 281|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_TYPE 0x35 ------------------ | Branch (1482:9): [True: 281, False: 35.7k] ------------------ 1483| 281| size = ogs_nas_eps_decode_wus_assistance_information(&tracking_area_update_request->requested_wus_assistance_information, pkbuf); 1484| 281| if (size < 0) { ------------------ | Branch (1484:17): [True: 1, False: 280] ------------------ 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| 280| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_PRESENT; ------------------ | | 471| 280|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_PRESENT ((uint64_t)1<<30) ------------------ 1490| 280| decoded += size; 1491| 280| 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: 35.8k] ------------------ 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: 1, False: 212] ------------------ 1495| 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__) | | ------------------ ------------------ 1496| 1| return size; 1497| 1| } 1498| | 1499| 212| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT; ------------------ | | 472| 212|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT ((uint64_t)1<<31) ------------------ 1500| 212| decoded += size; 1501| 212| break; 1502| 234| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_IMSI_OFFSET_TYPE: ------------------ | | 510| 234|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_IMSI_OFFSET_TYPE 0x38 ------------------ | Branch (1502:9): [True: 234, False: 35.8k] ------------------ 1503| 234| size = ogs_nas_eps_decode_imsi_offset(&tracking_area_update_request->requested_imsi_offset, pkbuf); 1504| 234| if (size < 0) { ------------------ | Branch (1504:17): [True: 1, False: 233] ------------------ 1505| 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__) | | ------------------ ------------------ 1506| 1| return size; 1507| 1| } 1508| | 1509| 233| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_IMSI_OFFSET_PRESENT; ------------------ | | 473| 233|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_IMSI_OFFSET_PRESENT ((uint64_t)1<<32) ------------------ 1510| 233| decoded += size; 1511| 233| break; 1512| 401| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_REQUEST_TYPE_TYPE: ------------------ | | 511| 401|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_REQUEST_TYPE_TYPE 0x29 ------------------ | Branch (1512:9): [True: 401, False: 35.6k] ------------------ 1513| 401| size = ogs_nas_eps_decode_ue_request_type(&tracking_area_update_request->ue_request_type, pkbuf); 1514| 401| if (size < 0) { ------------------ | Branch (1514:17): [True: 7, False: 394] ------------------ 1515| 7| ogs_error("ogs_nas_eps_decode_ue_request_type() 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__) | | ------------------ ------------------ 1516| 7| return size; 1517| 7| } 1518| | 1519| 394| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_REQUEST_TYPE_PRESENT; ------------------ | | 474| 394|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_REQUEST_TYPE_PRESENT ((uint64_t)1<<33) ------------------ 1520| 394| decoded += size; 1521| 394| break; 1522| 401| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_PAGING_RESTRICTION_TYPE: ------------------ | | 512| 401|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_PAGING_RESTRICTION_TYPE 0x28 ------------------ | Branch (1522:9): [True: 401, False: 35.6k] ------------------ 1523| 401| size = ogs_nas_eps_decode_paging_restriction(&tracking_area_update_request->paging_restriction, pkbuf); 1524| 401| if (size < 0) { ------------------ | Branch (1524:17): [True: 11, False: 390] ------------------ 1525| 11| ogs_error("ogs_nas_eps_decode_paging_restriction() 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__) | | ------------------ ------------------ 1526| 11| return size; 1527| 11| } 1528| | 1529| 390| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_PAGING_RESTRICTION_PRESENT; ------------------ | | 475| 390|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_PAGING_RESTRICTION_PRESENT ((uint64_t)1<<34) ------------------ 1530| 390| decoded += size; 1531| 390| break; 1532| 389| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UNAVAILABILITY_INFORMATION_TYPE: ------------------ | | 513| 389|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UNAVAILABILITY_INFORMATION_TYPE 0x30 ------------------ | Branch (1532:9): [True: 389, False: 35.6k] ------------------ 1533| 389| size = ogs_nas_eps_decode_unavailability_information(&tracking_area_update_request->unavailability_information, pkbuf); 1534| 389| if (size < 0) { ------------------ | Branch (1534:17): [True: 8, False: 381] ------------------ 1535| 8| ogs_error("ogs_nas_eps_decode_unavailability_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__) | | ------------------ ------------------ 1536| 8| return size; 1537| 8| } 1538| | 1539| 381| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UNAVAILABILITY_INFORMATION_PRESENT; ------------------ | | 476| 381|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UNAVAILABILITY_INFORMATION_PRESENT ((uint64_t)1<<35) ------------------ 1540| 381| decoded += size; 1541| 381| break; 1542| 344| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_TYPE: ------------------ | | 514| 344|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_TYPE 0x26 ------------------ | Branch (1542:9): [True: 344, False: 35.6k] ------------------ 1543| 344| size = ogs_nas_eps_decode_plmn_identity(&tracking_area_update_request->ue_determined_plmn_with_disaster_condition, pkbuf); 1544| 344| if (size < 0) { ------------------ | Branch (1544:17): [True: 8, False: 336] ------------------ 1545| 8| ogs_error("ogs_nas_eps_decode_plmn_identity() 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__) | | ------------------ ------------------ 1546| 8| return size; 1547| 8| } 1548| | 1549| 336| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_PRESENT; ------------------ | | 477| 336|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_PRESENT ((uint64_t)1<<36) ------------------ 1550| 336| decoded += size; 1551| 336| break; 1552| 13.1k| default: ------------------ | Branch (1552:9): [True: 13.1k, False: 22.8k] ------------------ 1553| 13.1k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 13.1k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 13.1k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 13.1k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 13.1k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 13.1k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 13.1k| 0, __VA_ARGS__) | | ------------------ ------------------ 1554| 13.1k| break; 1555| 36.0k| } 1556| 36.0k| } 1557| | 1558| 490| return decoded; 1559| 684|} ogs_nas_eps_decode_tracking_area_update_accept: 1562| 810|{ 1563| 810| ogs_nas_eps_tracking_area_update_accept_t *tracking_area_update_accept = &message->emm.tracking_area_update_accept; 1564| 810| int decoded = 0; 1565| 810| int size = 0; 1566| | 1567| 810| ogs_trace("[NAS] Decode TRACKING_AREA_UPDATE_ACCEPT\n"); ------------------ | | 40| 810|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 810| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 810|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 810| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 810|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 810| 0, __VA_ARGS__) | | ------------------ ------------------ 1568| | 1569| 810| size = ogs_nas_eps_decode_eps_update_result(&tracking_area_update_accept->eps_update_result, pkbuf); 1570| 810| if (size < 0) { ------------------ | Branch (1570:9): [True: 0, False: 810] ------------------ 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| 810| decoded += size; 1576| | 1577| 37.7k| while (pkbuf->len > 0) { ------------------ | Branch (1577:12): [True: 37.2k, False: 535] ------------------ 1578| 37.2k| uint8_t *buffer = pkbuf->data; 1579| 37.2k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (1579:24): [True: 12.6k, False: 24.5k] ------------------ 1580| | 1581| 37.2k| size = sizeof(uint8_t); 1582| 37.2k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1582:13): [True: 0, False: 37.2k] ------------------ 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| 37.2k| decoded += size; 1587| | 1588| 37.2k| switch (type) { 1589| 253| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_TYPE: ------------------ | | 606| 253|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_TYPE 0x5A ------------------ | Branch (1589:9): [True: 253, False: 36.9k] ------------------ 1590| 253| size = ogs_nas_eps_decode_gprs_timer(&tracking_area_update_accept->t3412_value, pkbuf); 1591| 253| if (size < 0) { ------------------ | Branch (1591:17): [True: 1, False: 252] ------------------ 1592| 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__) | | ------------------ ------------------ 1593| 1| return size; 1594| 1| } 1595| | 1596| 252| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_PRESENT; ------------------ | | 566| 252|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_PRESENT ((uint64_t)1<<0) ------------------ 1597| 252| decoded += size; 1598| 252| break; 1599| 445| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_TYPE: ------------------ | | 607| 445|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_TYPE 0x50 ------------------ | Branch (1599:9): [True: 445, False: 36.7k] ------------------ 1600| 445| size = ogs_nas_eps_decode_eps_mobile_identity(&tracking_area_update_accept->guti, pkbuf); 1601| 445| if (size < 0) { ------------------ | Branch (1601:17): [True: 2, False: 443] ------------------ 1602| 2| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() 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__) | | ------------------ ------------------ 1603| 2| return size; 1604| 2| } 1605| | 1606| 443| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_PRESENT; ------------------ | | 567| 443|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_PRESENT ((uint64_t)1<<1) ------------------ 1607| 443| decoded += size; 1608| 443| break; 1609| 237| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_TYPE: ------------------ | | 608| 237|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_TYPE 0x54 ------------------ | Branch (1609:9): [True: 237, False: 36.9k] ------------------ 1610| 237| size = ogs_nas_eps_decode_tracking_area_identity_list(&tracking_area_update_accept->tai_list, pkbuf); 1611| 237| if (size < 0) { ------------------ | Branch (1611:17): [True: 2, False: 235] ------------------ 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| 235| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_PRESENT; ------------------ | | 568| 235|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_PRESENT ((uint64_t)1<<2) ------------------ 1617| 235| decoded += size; 1618| 235| break; 1619| 582| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_TYPE: ------------------ | | 609| 582|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_TYPE 0x57 ------------------ | Branch (1619:9): [True: 582, False: 36.6k] ------------------ 1620| 582| size = ogs_nas_eps_decode_eps_bearer_context_status(&tracking_area_update_accept->eps_bearer_context_status, pkbuf); 1621| 582| if (size < 0) { ------------------ | Branch (1621:17): [True: 16, False: 566] ------------------ 1622| 16| ogs_error("ogs_nas_eps_decode_eps_bearer_context_status() 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__) | | ------------------ ------------------ 1623| 16| return size; 1624| 16| } 1625| | 1626| 566| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_PRESENT; ------------------ | | 569| 566|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_PRESENT ((uint64_t)1<<3) ------------------ 1627| 566| decoded += size; 1628| 566| break; 1629| 504| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE: ------------------ | | 610| 504|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 ------------------ | Branch (1629:9): [True: 504, False: 36.7k] ------------------ 1630| 504| size = ogs_nas_eps_decode_location_area_identification(&tracking_area_update_accept->location_area_identification, pkbuf); 1631| 504| if (size < 0) { ------------------ | Branch (1631:17): [True: 9, False: 495] ------------------ 1632| 9| ogs_error("ogs_nas_eps_decode_location_area_identification() 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__) | | ------------------ ------------------ 1633| 9| return size; 1634| 9| } 1635| | 1636| 495| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT; ------------------ | | 570| 495|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT ((uint64_t)1<<4) ------------------ 1637| 495| decoded += size; 1638| 495| break; 1639| 240| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_TYPE: ------------------ | | 611| 240|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_TYPE 0x23 ------------------ | Branch (1639:9): [True: 240, False: 36.9k] ------------------ 1640| 240| size = ogs_nas_eps_decode_mobile_identity(&tracking_area_update_accept->ms_identity, pkbuf); 1641| 240| if (size < 0) { ------------------ | Branch (1641:17): [True: 3, False: 237] ------------------ 1642| 3| ogs_error("ogs_nas_eps_decode_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__) | | ------------------ ------------------ 1643| 3| return size; 1644| 3| } 1645| | 1646| 237| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_PRESENT; ------------------ | | 571| 237|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_PRESENT ((uint64_t)1<<5) ------------------ 1647| 237| decoded += size; 1648| 237| break; 1649| 592| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_TYPE: ------------------ | | 612| 592|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_TYPE 0x53 ------------------ | Branch (1649:9): [True: 592, False: 36.6k] ------------------ 1650| 592| size = ogs_nas_eps_decode_emm_cause(&tracking_area_update_accept->emm_cause, pkbuf); 1651| 592| if (size < 0) { ------------------ | Branch (1651:17): [True: 7, False: 585] ------------------ 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| 585| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_PRESENT; ------------------ | | 572| 585|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_PRESENT ((uint64_t)1<<6) ------------------ 1657| 585| decoded += size; 1658| 585| break; 1659| 273| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_TYPE: ------------------ | | 613| 273|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_TYPE 0x17 ------------------ | Branch (1659:9): [True: 273, False: 36.9k] ------------------ 1660| 273| size = ogs_nas_eps_decode_gprs_timer(&tracking_area_update_accept->t3402_value, pkbuf); 1661| 273| if (size < 0) { ------------------ | Branch (1661:17): [True: 1, False: 272] ------------------ 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| 272| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_PRESENT; ------------------ | | 573| 272|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_PRESENT ((uint64_t)1<<7) ------------------ 1667| 272| decoded += size; 1668| 272| break; 1669| 240| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_TYPE: ------------------ | | 614| 240|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_TYPE 0x59 ------------------ | Branch (1669:9): [True: 240, False: 36.9k] ------------------ 1670| 240| size = ogs_nas_eps_decode_gprs_timer(&tracking_area_update_accept->t3423_value, pkbuf); 1671| 240| if (size < 0) { ------------------ | Branch (1671:17): [True: 4, False: 236] ------------------ 1672| 4| ogs_error("ogs_nas_eps_decode_gprs_timer() 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__) | | ------------------ ------------------ 1673| 4| return size; 1674| 4| } 1675| | 1676| 236| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_PRESENT; ------------------ | | 574| 236|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_PRESENT ((uint64_t)1<<8) ------------------ 1677| 236| decoded += size; 1678| 236| break; 1679| 501| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_TYPE: ------------------ | | 615| 501|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_TYPE 0x4A ------------------ | Branch (1679:9): [True: 501, False: 36.7k] ------------------ 1680| 501| size = ogs_nas_eps_decode_plmn_list(&tracking_area_update_accept->equivalent_plmns, pkbuf); 1681| 501| if (size < 0) { ------------------ | Branch (1681:17): [True: 16, False: 485] ------------------ 1682| 16| ogs_error("ogs_nas_eps_decode_plmn_list() 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__) | | ------------------ ------------------ 1683| 16| return size; 1684| 16| } 1685| | 1686| 485| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_PRESENT; ------------------ | | 575| 485|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_PRESENT ((uint64_t)1<<9) ------------------ 1687| 485| decoded += size; 1688| 485| break; 1689| 345| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE: ------------------ | | 616| 345|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE 0x34 ------------------ | Branch (1689:9): [True: 345, False: 36.8k] ------------------ 1690| 345| size = ogs_nas_eps_decode_emergency_number_list(&tracking_area_update_accept->emergency_number_list, pkbuf); 1691| 345| if (size < 0) { ------------------ | Branch (1691:17): [True: 13, False: 332] ------------------ 1692| 13| ogs_error("ogs_nas_eps_decode_emergency_number_list() 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__) | | ------------------ ------------------ 1693| 13| return size; 1694| 13| } 1695| | 1696| 332| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT; ------------------ | | 576| 332|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT ((uint64_t)1<<10) ------------------ 1697| 332| decoded += size; 1698| 332| break; 1699| 394| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE: ------------------ | | 617| 394|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE 0x64 ------------------ | Branch (1699:9): [True: 394, False: 36.8k] ------------------ 1700| 394| size = ogs_nas_eps_decode_eps_network_feature_support(&tracking_area_update_accept->eps_network_feature_support, pkbuf); 1701| 394| if (size < 0) { ------------------ | Branch (1701:17): [True: 15, False: 379] ------------------ 1702| 15| ogs_error("ogs_nas_eps_decode_eps_network_feature_support() 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__) | | ------------------ ------------------ 1703| 15| return size; 1704| 15| } 1705| | 1706| 379| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT; ------------------ | | 577| 379|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT ((uint64_t)1<<11) ------------------ 1707| 379| decoded += size; 1708| 379| break; 1709| 5.47k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE: ------------------ | | 618| 5.47k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE 0xF0 ------------------ | Branch (1709:9): [True: 5.47k, False: 31.7k] ------------------ 1710| 5.47k| decoded--; 1711| 5.47k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 5.47k| do { \ | | 114| 5.47k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 5.47k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 5.47k, False: 0] | | | | ------------------ | | ------------------ | | 115| 5.47k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 5.47k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 5.47k] | | ------------------ ------------------ 1712| 5.47k| size = ogs_nas_eps_decode_additional_update_result(&tracking_area_update_accept->additional_update_result, pkbuf); 1713| 5.47k| if (size < 0) { ------------------ | Branch (1713:17): [True: 0, False: 5.47k] ------------------ 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| 5.47k| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT; ------------------ | | 578| 5.47k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT ((uint64_t)1<<12) ------------------ 1719| 5.47k| decoded += size; 1720| 5.47k| break; 1721| 275| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_TYPE: ------------------ | | 619| 275|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_TYPE 0x5E ------------------ | Branch (1721:9): [True: 275, False: 36.9k] ------------------ 1722| 275| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_accept->t3412_extended_value, pkbuf); 1723| 275| if (size < 0) { ------------------ | Branch (1723:17): [True: 4, False: 271] ------------------ 1724| 4| ogs_error("ogs_nas_eps_decode_gprs_timer_3() 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__) | | ------------------ ------------------ 1725| 4| return size; 1726| 4| } 1727| | 1728| 271| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_PRESENT; ------------------ | | 579| 271|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_PRESENT ((uint64_t)1<<13) ------------------ 1729| 271| decoded += size; 1730| 271| break; 1731| 243| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_TYPE: ------------------ | | 620| 243|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_TYPE 0x6A ------------------ | Branch (1731:9): [True: 243, False: 36.9k] ------------------ 1732| 243| size = ogs_nas_eps_decode_gprs_timer_2(&tracking_area_update_accept->t3324_value, pkbuf); 1733| 243| if (size < 0) { ------------------ | Branch (1733:17): [True: 2, False: 241] ------------------ 1734| 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__) | | ------------------ ------------------ 1735| 2| return size; 1736| 2| } 1737| | 1738| 241| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_PRESENT; ------------------ | | 580| 241|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_PRESENT ((uint64_t)1<<14) ------------------ 1739| 241| decoded += size; 1740| 241| break; 1741| 414| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE: ------------------ | | 621| 414|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE 0x6E ------------------ | Branch (1741:9): [True: 414, False: 36.7k] ------------------ 1742| 414| size = ogs_nas_eps_decode_extended_drx_parameters(&tracking_area_update_accept->extended_drx_parameters, pkbuf); 1743| 414| if (size < 0) { ------------------ | Branch (1743:17): [True: 11, False: 403] ------------------ 1744| 11| ogs_error("ogs_nas_eps_decode_extended_drx_parameters() 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__) | | ------------------ ------------------ 1745| 11| return size; 1746| 11| } 1747| | 1748| 403| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT; ------------------ | | 581| 403|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT ((uint64_t)1<<15) ------------------ 1749| 403| decoded += size; 1750| 403| break; 1751| 373| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_TYPE: ------------------ | | 622| 373|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_TYPE 0x68 ------------------ | Branch (1751:9): [True: 373, False: 36.8k] ------------------ 1752| 373| size = ogs_nas_eps_decode_header_compression_configuration_status(&tracking_area_update_accept->header_compression_configuration_status, pkbuf); 1753| 373| if (size < 0) { ------------------ | Branch (1753:17): [True: 9, False: 364] ------------------ 1754| 9| ogs_error("ogs_nas_eps_decode_header_compression_configuration_status() 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__) | | ------------------ ------------------ 1755| 9| return size; 1756| 9| } 1757| | 1758| 364| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_PRESENT; ------------------ | | 582| 364|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_PRESENT ((uint64_t)1<<16) ------------------ 1759| 364| decoded += size; 1760| 364| break; 1761| 331| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DCN_ID_TYPE: ------------------ | | 623| 331|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DCN_ID_TYPE 0x65 ------------------ | Branch (1761:9): [True: 331, False: 36.8k] ------------------ 1762| 331| size = ogs_nas_eps_decode_dcn_id(&tracking_area_update_accept->dcn_id, pkbuf); 1763| 331| if (size < 0) { ------------------ | Branch (1763:17): [True: 11, False: 320] ------------------ 1764| 11| ogs_error("ogs_nas_eps_decode_dcn_id() 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__) | | ------------------ ------------------ 1765| 11| return size; 1766| 11| } 1767| | 1768| 320| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DCN_ID_PRESENT; ------------------ | | 583| 320|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DCN_ID_PRESENT ((uint64_t)1<<17) ------------------ 1769| 320| decoded += size; 1770| 320| break; 1771| 1.08k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_SMS_SERVICES_STATUS_TYPE: ------------------ | | 624| 1.08k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_SMS_SERVICES_STATUS_TYPE 0xE0 ------------------ | Branch (1771:9): [True: 1.08k, False: 36.1k] ------------------ 1772| 1.08k| decoded--; 1773| 1.08k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.08k| do { \ | | 114| 1.08k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.08k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.08k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.08k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.08k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.08k] | | ------------------ ------------------ 1774| 1.08k| size = ogs_nas_eps_decode_sms_services_status(&tracking_area_update_accept->sms_services_status, pkbuf); 1775| 1.08k| if (size < 0) { ------------------ | Branch (1775:17): [True: 0, False: 1.08k] ------------------ 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.08k| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_SMS_SERVICES_STATUS_PRESENT; ------------------ | | 584| 1.08k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_SMS_SERVICES_STATUS_PRESENT ((uint64_t)1<<18) ------------------ 1781| 1.08k| decoded += size; 1782| 1.08k| break; 1783| 1.27k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NON__NW_POLICIES_TYPE: ------------------ | | 625| 1.27k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NON__NW_POLICIES_TYPE 0xD0 ------------------ | Branch (1783:9): [True: 1.27k, False: 35.9k] ------------------ 1784| 1.27k| decoded--; 1785| 1.27k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.27k| do { \ | | 114| 1.27k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.27k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.27k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.27k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.27k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.27k] | | ------------------ ------------------ 1786| 1.27k| size = ogs_nas_eps_decode_non_nw_provided_policies(&tracking_area_update_accept->non_nw_policies, pkbuf); 1787| 1.27k| if (size < 0) { ------------------ | Branch (1787:17): [True: 0, False: 1.27k] ------------------ 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.27k| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NON__NW_POLICIES_PRESENT; ------------------ | | 585| 1.27k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NON__NW_POLICIES_PRESENT ((uint64_t)1<<19) ------------------ 1793| 1.27k| decoded += size; 1794| 1.27k| break; 1795| 220| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3448_VALUE_TYPE: ------------------ | | 626| 220|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3448_VALUE_TYPE 0x6B ------------------ | Branch (1795:9): [True: 220, False: 36.9k] ------------------ 1796| 220| size = ogs_nas_eps_decode_gprs_timer_2(&tracking_area_update_accept->t3448_value, pkbuf); 1797| 220| if (size < 0) { ------------------ | Branch (1797:17): [True: 5, False: 215] ------------------ 1798| 5| ogs_error("ogs_nas_eps_decode_gprs_timer_2() 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__) | | ------------------ ------------------ 1799| 5| return size; 1800| 5| } 1801| | 1802| 215| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3448_VALUE_PRESENT; ------------------ | | 586| 215|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3448_VALUE_PRESENT ((uint64_t)1<<20) ------------------ 1803| 215| decoded += size; 1804| 215| break; 1805| 1.52k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NETWORK_POLICY_TYPE: ------------------ | | 627| 1.52k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NETWORK_POLICY_TYPE 0xC0 ------------------ | Branch (1805:9): [True: 1.52k, False: 35.6k] ------------------ 1806| 1.52k| decoded--; 1807| 1.52k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.52k| do { \ | | 114| 1.52k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.52k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.52k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.52k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 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.52k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.52k] | | ------------------ ------------------ 1808| 1.52k| size = ogs_nas_eps_decode_network_policy(&tracking_area_update_accept->network_policy, pkbuf); 1809| 1.52k| if (size < 0) { ------------------ | Branch (1809:17): [True: 0, False: 1.52k] ------------------ 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| 1.52k| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NETWORK_POLICY_PRESENT; ------------------ | | 587| 1.52k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NETWORK_POLICY_PRESENT ((uint64_t)1<<21) ------------------ 1815| 1.52k| decoded += size; 1816| 1.52k| break; 1817| 338| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3447_VALUE_TYPE: ------------------ | | 628| 338|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3447_VALUE_TYPE 0x6C ------------------ | Branch (1817:9): [True: 338, False: 36.8k] ------------------ 1818| 338| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_accept->t3447_value, pkbuf); 1819| 338| if (size < 0) { ------------------ | Branch (1819:17): [True: 4, False: 334] ------------------ 1820| 4| ogs_error("ogs_nas_eps_decode_gprs_timer_3() 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__) | | ------------------ ------------------ 1821| 4| return size; 1822| 4| } 1823| | 1824| 334| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3447_VALUE_PRESENT; ------------------ | | 588| 334|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3447_VALUE_PRESENT ((uint64_t)1<<22) ------------------ 1825| 334| decoded += size; 1826| 334| break; 1827| 307| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_TYPE: ------------------ | | 629| 307|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_TYPE 0x7A ------------------ | Branch (1827:9): [True: 307, False: 36.9k] ------------------ 1828| 307| size = ogs_nas_eps_decode_extended_emergency_number_list(&tracking_area_update_accept->extended_emergency_number_list, pkbuf); 1829| 307| if (size < 0) { ------------------ | Branch (1829:17): [True: 30, False: 277] ------------------ 1830| 30| ogs_error("ogs_nas_eps_decode_extended_emergency_number_list() failed"); ------------------ | | 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__) | | ------------------ ------------------ 1831| 30| return size; 1832| 30| } 1833| | 1834| 277| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_PRESENT; ------------------ | | 589| 277|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_PRESENT ((uint64_t)1<<23) ------------------ 1835| 277| decoded += size; 1836| 277| break; 1837| 324| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_CIPHERING_KEY_DATA_TYPE: ------------------ | | 630| 324|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_CIPHERING_KEY_DATA_TYPE 0x7C ------------------ | Branch (1837:9): [True: 324, False: 36.8k] ------------------ 1838| 324| size = ogs_nas_eps_decode_ciphering_key_data(&tracking_area_update_accept->ciphering_key_data, pkbuf); 1839| 324| if (size < 0) { ------------------ | Branch (1839:17): [True: 33, False: 291] ------------------ 1840| 33| ogs_error("ogs_nas_eps_decode_ciphering_key_data() 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__) | | ------------------ ------------------ 1841| 33| return size; 1842| 33| } 1843| | 1844| 291| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_CIPHERING_KEY_DATA_PRESENT; ------------------ | | 590| 291|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_CIPHERING_KEY_DATA_PRESENT ((uint64_t)1<<24) ------------------ 1845| 291| decoded += size; 1846| 291| break; 1847| 228| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_TYPE: ------------------ | | 631| 228|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_TYPE 0x66 ------------------ | Branch (1847:9): [True: 228, False: 36.9k] ------------------ 1848| 228| size = ogs_nas_eps_decode_ue_radio_capability_id(&tracking_area_update_accept->ue_radio_capability_id, pkbuf); 1849| 228| if (size < 0) { ------------------ | Branch (1849:17): [True: 3, False: 225] ------------------ 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| 225| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_PRESENT; ------------------ | | 591| 225|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_PRESENT ((uint64_t)1<<25) ------------------ 1855| 225| decoded += size; 1856| 225| break; 1857| 1.35k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE: ------------------ | | 632| 1.35k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE 0xB0 ------------------ | Branch (1857:9): [True: 1.35k, False: 35.8k] ------------------ 1858| 1.35k| decoded--; 1859| 1.35k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.35k| do { \ | | 114| 1.35k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.35k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.35k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.35k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.35k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.35k] | | ------------------ ------------------ 1860| 1.35k| size = ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication(&tracking_area_update_accept->ue_radio_capability_id_deletion_indication, pkbuf); 1861| 1.35k| if (size < 0) { ------------------ | Branch (1861:17): [True: 0, False: 1.35k] ------------------ 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| 1.35k| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT; ------------------ | | 592| 1.35k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT ((uint64_t)1<<26) ------------------ 1867| 1.35k| decoded += size; 1868| 1.35k| break; 1869| 235| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_TYPE: ------------------ | | 633| 235|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_TYPE 0x35 ------------------ | Branch (1869:9): [True: 235, False: 36.9k] ------------------ 1870| 235| size = ogs_nas_eps_decode_wus_assistance_information(&tracking_area_update_accept->negotiated_wus_assistance_information, pkbuf); 1871| 235| if (size < 0) { ------------------ | Branch (1871:17): [True: 5, False: 230] ------------------ 1872| 5| ogs_error("ogs_nas_eps_decode_wus_assistance_information() 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__) | | ------------------ ------------------ 1873| 5| return size; 1874| 5| } 1875| | 1876| 230| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_PRESENT; ------------------ | | 593| 230|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_PRESENT ((uint64_t)1<<27) ------------------ 1877| 230| decoded += size; 1878| 230| break; 1879| 365| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_TYPE: ------------------ | | 634| 365|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_TYPE 0x36 ------------------ | Branch (1879:9): [True: 365, False: 36.8k] ------------------ 1880| 365| size = ogs_nas_eps_decode_nb_s1_drx_parameter(&tracking_area_update_accept->negotiated_drx_parameter_in_nb_s1_mode, pkbuf); 1881| 365| if (size < 0) { ------------------ | Branch (1881:17): [True: 8, False: 357] ------------------ 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| 357| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT; ------------------ | | 594| 357|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT ((uint64_t)1<<28) ------------------ 1887| 357| decoded += size; 1888| 357| break; 1889| 244| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_IMSI_OFFSET_TYPE: ------------------ | | 635| 244|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_IMSI_OFFSET_TYPE 0x38 ------------------ | Branch (1889:9): [True: 244, False: 36.9k] ------------------ 1890| 244| size = ogs_nas_eps_decode_imsi_offset(&tracking_area_update_accept->negotiated_imsi_offset, pkbuf); 1891| 244| if (size < 0) { ------------------ | Branch (1891:17): [True: 8, False: 236] ------------------ 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| 236| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_IMSI_OFFSET_PRESENT; ------------------ | | 595| 236|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_IMSI_OFFSET_PRESENT ((uint64_t)1<<29) ------------------ 1897| 236| decoded += size; 1898| 236| break; 1899| 390| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_ADDITIONAL_REQUEST_RESULT_TYPE: ------------------ | | 636| 390|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_ADDITIONAL_REQUEST_RESULT_TYPE 0x37 ------------------ | Branch (1899:9): [True: 390, False: 36.8k] ------------------ 1900| 390| size = ogs_nas_eps_decode_eps_additional_request_result(&tracking_area_update_accept->eps_additional_request_result, pkbuf); 1901| 390| if (size < 0) { ------------------ | Branch (1901:17): [True: 12, False: 378] ------------------ 1902| 12| ogs_error("ogs_nas_eps_decode_eps_additional_request_result() 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__) | | ------------------ ------------------ 1903| 12| return size; 1904| 12| } 1905| | 1906| 378| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_ADDITIONAL_REQUEST_RESULT_PRESENT; ------------------ | | 596| 378|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_ADDITIONAL_REQUEST_RESULT_PRESENT ((uint64_t)1<<30) ------------------ 1907| 378| decoded += size; 1908| 378| break; 1909| 302| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 637| 302|#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: 302, False: 36.9k] ------------------ 1910| 302| 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| 302| if (size < 0) { ------------------ | Branch (1911:17): [True: 3, False: 299] ------------------ 1912| 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__) | | ------------------ ------------------ 1913| 3| return size; 1914| 3| } 1915| | 1916| 299| 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| 299|#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| 299| decoded += size; 1918| 299| break; 1919| 243| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE: ------------------ | | 638| 243|#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: 243, False: 36.9k] ------------------ 1920| 243| 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| 243| if (size < 0) { ------------------ | Branch (1921:17): [True: 2, False: 241] ------------------ 1922| 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__) | | ------------------ ------------------ 1923| 2| return size; 1924| 2| } 1925| | 1926| 241| 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| 241|#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| 241| decoded += size; 1928| 241| break; 1929| 331| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MAXIMUM_TIME_OFFSET_TYPE: ------------------ | | 639| 331|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MAXIMUM_TIME_OFFSET_TYPE 0x39 ------------------ | Branch (1929:9): [True: 331, False: 36.8k] ------------------ 1930| 331| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_accept->maximum_time_offset, pkbuf); 1931| 331| if (size < 0) { ------------------ | Branch (1931:17): [True: 3, False: 328] ------------------ 1932| 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__) | | ------------------ ------------------ 1933| 3| return size; 1934| 3| } 1935| | 1936| 328| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MAXIMUM_TIME_OFFSET_PRESENT; ------------------ | | 599| 328|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MAXIMUM_TIME_OFFSET_PRESENT ((uint64_t)1<<33) ------------------ 1937| 328| decoded += size; 1938| 328| break; 1939| 247| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UNAVAILABILITY_CONFIGURATION_TYPE: ------------------ | | 640| 247|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UNAVAILABILITY_CONFIGURATION_TYPE 0x1F ------------------ | Branch (1939:9): [True: 247, False: 36.9k] ------------------ 1940| 247| size = ogs_nas_eps_decode_unavailability_configuration(&tracking_area_update_accept->unavailability_configuration, pkbuf); 1941| 247| if (size < 0) { ------------------ | Branch (1941:17): [True: 10, False: 237] ------------------ 1942| 10| ogs_error("ogs_nas_eps_decode_unavailability_configuration() 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__) | | ------------------ ------------------ 1943| 10| return size; 1944| 10| } 1945| | 1946| 237| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UNAVAILABILITY_CONFIGURATION_PRESENT; ------------------ | | 600| 237|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UNAVAILABILITY_CONFIGURATION_PRESENT ((uint64_t)1<<34) ------------------ 1947| 237| decoded += size; 1948| 237| break; 1949| 230| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 641| 230|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (1949:9): [True: 230, False: 36.9k] ------------------ 1950| 230| size = ogs_nas_eps_decode_access_technology_utilization_control(&tracking_area_update_accept->access_technology_utilization_control, pkbuf); 1951| 230| if (size < 0) { ------------------ | Branch (1951:17): [True: 2, False: 228] ------------------ 1952| 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__) | | ------------------ ------------------ 1953| 2| return size; 1954| 2| } 1955| | 1956| 228| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 601| 228|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<35) ------------------ 1957| 228| decoded += size; 1958| 228| break; 1959| 248| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 642| 248|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (1959:9): [True: 248, False: 36.9k] ------------------ 1960| 248| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&tracking_area_update_accept->s_f_satellite_operation_parameters, pkbuf); 1961| 248| if (size < 0) { ------------------ | Branch (1961:17): [True: 5, False: 243] ------------------ 1962| 5| ogs_error("ogs_nas_eps_decode_s_f_satellite_operation_parameters() 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__) | | ------------------ ------------------ 1963| 5| return size; 1964| 5| } 1965| | 1966| 243| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 602| 243|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<36) ------------------ 1967| 243| decoded += size; 1968| 243| break; 1969| 352| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_TYPE: ------------------ | | 643| 352|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_TYPE 0x22 ------------------ | Branch (1969:9): [True: 352, False: 36.8k] ------------------ 1970| 352| size = ogs_nas_eps_decode_registration_wait_range(&tracking_area_update_accept->disaster_roaming_wait_range, pkbuf); 1971| 352| if (size < 0) { ------------------ | Branch (1971:17): [True: 6, False: 346] ------------------ 1972| 6| ogs_error("ogs_nas_eps_decode_registration_wait_range() 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__) | | ------------------ ------------------ 1973| 6| return size; 1974| 6| } 1975| | 1976| 346| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_PRESENT; ------------------ | | 603| 346|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_PRESENT ((uint64_t)1<<37) ------------------ 1977| 346| decoded += size; 1978| 346| break; 1979| 217| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_RETURN_WAIT_RANGE_TYPE: ------------------ | | 644| 217|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_RETURN_WAIT_RANGE_TYPE 0x24 ------------------ | Branch (1979:9): [True: 217, False: 36.9k] ------------------ 1980| 217| size = ogs_nas_eps_decode_registration_wait_range(&tracking_area_update_accept->disaster_return_wait_range, pkbuf); 1981| 217| if (size < 0) { ------------------ | Branch (1981:17): [True: 1, False: 216] ------------------ 1982| 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__) | | ------------------ ------------------ 1983| 1| return size; 1984| 1| } 1985| | 1986| 216| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_RETURN_WAIT_RANGE_PRESENT; ------------------ | | 604| 216|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_RETURN_WAIT_RANGE_PRESENT ((uint64_t)1<<38) ------------------ 1987| 216| decoded += size; 1988| 216| break; 1989| 330| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_TYPE: ------------------ | | 645| 330|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_TYPE 0x25 ------------------ | Branch (1989:9): [True: 330, False: 36.8k] ------------------ 1990| 330| 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| 330| if (size < 0) { ------------------ | Branch (1991:17): [True: 9, False: 321] ------------------ 1992| 9| ogs_error("ogs_nas_eps_decode_list_of_plmns_to_be_used_in_disaster_condition() 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__) | | ------------------ ------------------ 1993| 9| return size; 1994| 9| } 1995| | 1996| 321| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_PRESENT; ------------------ | | 605| 321|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_PRESENT ((uint64_t)1<<39) ------------------ 1997| 321| decoded += size; 1998| 321| break; 1999| 15.1k| default: ------------------ | Branch (1999:9): [True: 15.1k, False: 22.1k] ------------------ 2000| 15.1k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 15.1k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 15.1k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 15.1k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 15.1k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 15.1k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 15.1k| 0, __VA_ARGS__) | | ------------------ ------------------ 2001| 15.1k| break; 2002| 37.2k| } 2003| 37.2k| } 2004| | 2005| 535| return decoded; 2006| 810|} ogs_nas_eps_decode_tracking_area_update_reject: 2009| 145|{ 2010| 145| ogs_nas_eps_tracking_area_update_reject_t *tracking_area_update_reject = &message->emm.tracking_area_update_reject; 2011| 145| int decoded = 0; 2012| 145| int size = 0; 2013| | 2014| 145| ogs_trace("[NAS] Decode TRACKING_AREA_UPDATE_REJECT\n"); ------------------ | | 40| 145|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 145| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 145|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 145| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 145|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 145| 0, __VA_ARGS__) | | ------------------ ------------------ 2015| | 2016| 145| size = ogs_nas_eps_decode_emm_cause(&tracking_area_update_reject->emm_cause, pkbuf); 2017| 145| if (size < 0) { ------------------ | Branch (2017:9): [True: 0, False: 145] ------------------ 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| 145| decoded += size; 2023| | 2024| 7.87k| while (pkbuf->len > 0) { ------------------ | Branch (2024:12): [True: 7.75k, False: 121] ------------------ 2025| 7.75k| uint8_t *buffer = pkbuf->data; 2026| 7.75k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2026:24): [True: 2.01k, False: 5.74k] ------------------ 2027| | 2028| 7.75k| size = sizeof(uint8_t); 2029| 7.75k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2029:13): [True: 0, False: 7.75k] ------------------ 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.75k| decoded += size; 2034| | 2035| 7.75k| switch (type) { 2036| 278| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_TYPE: ------------------ | | 707| 278|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_TYPE 0x5F ------------------ | Branch (2036:9): [True: 278, False: 7.47k] ------------------ 2037| 278| size = ogs_nas_eps_decode_gprs_timer_2(&tracking_area_update_reject->t3346_value, pkbuf); 2038| 278| if (size < 0) { ------------------ | Branch (2038:17): [True: 7, False: 271] ------------------ 2039| 7| ogs_error("ogs_nas_eps_decode_gprs_timer_2() 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__) | | ------------------ ------------------ 2040| 7| return size; 2041| 7| } 2042| | 2043| 271| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_PRESENT; ------------------ | | 699| 271|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_PRESENT ((uint64_t)1<<0) ------------------ 2044| 271| decoded += size; 2045| 271| break; 2046| 677| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_TYPE: ------------------ | | 708| 677|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_TYPE 0xA0 ------------------ | Branch (2046:9): [True: 677, False: 7.08k] ------------------ 2047| 677| decoded--; 2048| 677| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 677| do { \ | | 114| 677| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 677|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 677, False: 0] | | | | ------------------ | | ------------------ | | 115| 677| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 677| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 677] | | ------------------ ------------------ 2049| 677| size = ogs_nas_eps_decode_extended_emm_cause(&tracking_area_update_reject->extended_emm_cause, pkbuf); 2050| 677| if (size < 0) { ------------------ | Branch (2050:17): [True: 0, False: 677] ------------------ 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| 677| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_PRESENT; ------------------ | | 700| 677|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_PRESENT ((uint64_t)1<<1) ------------------ 2056| 677| decoded += size; 2057| 677| break; 2058| 247| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE: ------------------ | | 709| 247|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE 0x1C ------------------ | Branch (2058:9): [True: 247, False: 7.51k] ------------------ 2059| 247| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_reject->lower_bound_timer_value, pkbuf); 2060| 247| if (size < 0) { ------------------ | Branch (2060:17): [True: 3, False: 244] ------------------ 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| 244| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT; ------------------ | | 701| 244|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT ((uint64_t)1<<2) ------------------ 2066| 244| decoded += size; 2067| 244| break; 2068| 249| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 710| 249|#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: 249, False: 7.50k] ------------------ 2069| 249| 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| 249| if (size < 0) { ------------------ | Branch (2070:17): [True: 2, False: 247] ------------------ 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| 247| 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| 247|#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| 247| decoded += size; 2077| 247| break; 2078| 208| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE: ------------------ | | 711| 208|#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: 208, False: 7.54k] ------------------ 2079| 208| 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| 208| if (size < 0) { ------------------ | Branch (2080:17): [True: 1, False: 207] ------------------ 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| 207| 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| 207|#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| 207| decoded += size; 2087| 207| break; 2088| 222| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 712| 222|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (2088:9): [True: 222, False: 7.53k] ------------------ 2089| 222| size = ogs_nas_eps_decode_access_technology_utilization_control(&tracking_area_update_reject->access_technology_utilization_control, pkbuf); 2090| 222| if (size < 0) { ------------------ | Branch (2090:17): [True: 4, False: 218] ------------------ 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| 218| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 704| 218|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<5) ------------------ 2096| 218| decoded += size; 2097| 218| break; 2098| 320| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 713| 320|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (2098:9): [True: 320, False: 7.43k] ------------------ 2099| 320| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&tracking_area_update_reject->s_f_satellite_operation_parameters, pkbuf); 2100| 320| if (size < 0) { ------------------ | Branch (2100:17): [True: 3, False: 317] ------------------ 2101| 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__) | | ------------------ ------------------ 2102| 3| return size; 2103| 3| } 2104| | 2105| 317| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 705| 317|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<6) ------------------ 2106| 317| decoded += size; 2107| 317| break; 2108| 213| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_DISASTER_RETURN_WAIT_RANGE_TYPE: ------------------ | | 714| 213|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_DISASTER_RETURN_WAIT_RANGE_TYPE 0x24 ------------------ | Branch (2108:9): [True: 213, False: 7.54k] ------------------ 2109| 213| size = ogs_nas_eps_decode_registration_wait_range(&tracking_area_update_reject->disaster_return_wait_range, pkbuf); 2110| 213| if (size < 0) { ------------------ | Branch (2110:17): [True: 4, False: 209] ------------------ 2111| 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__) | | ------------------ ------------------ 2112| 4| return size; 2113| 4| } 2114| | 2115| 209| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_DISASTER_RETURN_WAIT_RANGE_PRESENT; ------------------ | | 706| 209|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_DISASTER_RETURN_WAIT_RANGE_PRESENT ((uint64_t)1<<7) ------------------ 2116| 209| decoded += size; 2117| 209| break; 2118| 5.34k| default: ------------------ | Branch (2118:9): [True: 5.34k, False: 2.41k] ------------------ 2119| 5.34k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 5.34k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5.34k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5.34k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5.34k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5.34k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5.34k| 0, __VA_ARGS__) | | ------------------ ------------------ 2120| 5.34k| break; 2121| 7.75k| } 2122| 7.75k| } 2123| | 2124| 121| return decoded; 2125| 145|} ogs_nas_eps_decode_extended_service_request: 2128| 122|{ 2129| 122| ogs_nas_eps_extended_service_request_t *extended_service_request = &message->emm.extended_service_request; 2130| 122| int decoded = 0; 2131| 122| int size = 0; 2132| | 2133| 122| ogs_trace("[NAS] Decode EXTENDED_SERVICE_REQUEST\n"); ------------------ | | 40| 122|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 122| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 122|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 122| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 122|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 122| 0, __VA_ARGS__) | | ------------------ ------------------ 2134| | 2135| 122| size = ogs_nas_eps_decode_service_type(&extended_service_request->service_type, pkbuf); 2136| 122| if (size < 0) { ------------------ | Branch (2136:9): [True: 0, False: 122] ------------------ 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| 122| decoded += size; 2142| | 2143| 122| size = ogs_nas_eps_decode_mobile_identity(&extended_service_request->m_tmsi, pkbuf); 2144| 122| if (size < 0) { ------------------ | Branch (2144:9): [True: 3, False: 119] ------------------ 2145| 3| ogs_error("ogs_nas_eps_decode_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__) | | ------------------ ------------------ 2146| 3| return size; 2147| 3| } 2148| | 2149| 119| decoded += size; 2150| | 2151| 9.65k| while (pkbuf->len > 0) { ------------------ | Branch (2151:12): [True: 9.54k, False: 103] ------------------ 2152| 9.54k| uint8_t *buffer = pkbuf->data; 2153| 9.54k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2153:24): [True: 3.83k, False: 5.70k] ------------------ 2154| | 2155| 9.54k| size = sizeof(uint8_t); 2156| 9.54k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2156:13): [True: 0, False: 9.54k] ------------------ 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| 9.54k| decoded += size; 2161| | 2162| 9.54k| switch (type) { 2163| 746| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_TYPE: ------------------ | | 741| 746|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_TYPE 0xB0 ------------------ | Branch (2163:9): [True: 746, False: 8.80k] ------------------ 2164| 746| decoded--; 2165| 746| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 746| do { \ | | 114| 746| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 746|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 746, False: 0] | | | | ------------------ | | ------------------ | | 115| 746| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 746| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 746] | | ------------------ ------------------ 2166| 746| size = ogs_nas_eps_decode_csfb_response(&extended_service_request->csfb_response, pkbuf); 2167| 746| if (size < 0) { ------------------ | Branch (2167:17): [True: 0, False: 746] ------------------ 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| 746| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_PRESENT; ------------------ | | 736| 746|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_PRESENT ((uint64_t)1<<0) ------------------ 2173| 746| decoded += size; 2174| 746| break; 2175| 251| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE: ------------------ | | 742| 251|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE 0x57 ------------------ | Branch (2175:9): [True: 251, False: 9.29k] ------------------ 2176| 251| size = ogs_nas_eps_decode_eps_bearer_context_status(&extended_service_request->eps_bearer_context_status, pkbuf); 2177| 251| if (size < 0) { ------------------ | Branch (2177:17): [True: 3, False: 248] ------------------ 2178| 3| ogs_error("ogs_nas_eps_decode_eps_bearer_context_status() 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__) | | ------------------ ------------------ 2179| 3| return size; 2180| 3| } 2181| | 2182| 248| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT; ------------------ | | 737| 248|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT ((uint64_t)1<<1) ------------------ 2183| 248| decoded += size; 2184| 248| break; 2185| 1.09k| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_TYPE: ------------------ | | 743| 1.09k|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_TYPE 0xD0 ------------------ | Branch (2185:9): [True: 1.09k, False: 8.45k] ------------------ 2186| 1.09k| decoded--; 2187| 1.09k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.09k| do { \ | | 114| 1.09k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.09k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.09k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.09k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.09k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.09k] | | ------------------ ------------------ 2188| 1.09k| size = ogs_nas_eps_decode_device_properties(&extended_service_request->device_properties, pkbuf); 2189| 1.09k| if (size < 0) { ------------------ | Branch (2189:17): [True: 0, False: 1.09k] ------------------ 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| 1.09k| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_PRESENT; ------------------ | | 738| 1.09k|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_PRESENT ((uint64_t)1<<2) ------------------ 2195| 1.09k| decoded += size; 2196| 1.09k| break; 2197| 243| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_UE_REQUEST_TYPE_TYPE: ------------------ | | 744| 243|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_UE_REQUEST_TYPE_TYPE 0x29 ------------------ | Branch (2197:9): [True: 243, False: 9.30k] ------------------ 2198| 243| size = ogs_nas_eps_decode_ue_request_type(&extended_service_request->ue_request_type, pkbuf); 2199| 243| if (size < 0) { ------------------ | Branch (2199:17): [True: 8, False: 235] ------------------ 2200| 8| ogs_error("ogs_nas_eps_decode_ue_request_type() 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__) | | ------------------ ------------------ 2201| 8| return size; 2202| 8| } 2203| | 2204| 235| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_UE_REQUEST_TYPE_PRESENT; ------------------ | | 739| 235|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_UE_REQUEST_TYPE_PRESENT ((uint64_t)1<<3) ------------------ 2205| 235| decoded += size; 2206| 235| break; 2207| 232| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_PAGING_RESTRICTION_TYPE: ------------------ | | 745| 232|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_PAGING_RESTRICTION_TYPE 0x28 ------------------ | Branch (2207:9): [True: 232, False: 9.31k] ------------------ 2208| 232| size = ogs_nas_eps_decode_paging_restriction(&extended_service_request->paging_restriction, pkbuf); 2209| 232| if (size < 0) { ------------------ | Branch (2209:17): [True: 5, False: 227] ------------------ 2210| 5| ogs_error("ogs_nas_eps_decode_paging_restriction() 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__) | | ------------------ ------------------ 2211| 5| return size; 2212| 5| } 2213| | 2214| 227| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_PAGING_RESTRICTION_PRESENT; ------------------ | | 740| 227|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_PAGING_RESTRICTION_PRESENT ((uint64_t)1<<4) ------------------ 2215| 227| decoded += size; 2216| 227| break; 2217| 6.97k| default: ------------------ | Branch (2217:9): [True: 6.97k, False: 2.56k] ------------------ 2218| 6.97k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 6.97k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6.97k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6.97k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6.97k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6.97k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6.97k| 0, __VA_ARGS__) | | ------------------ ------------------ 2219| 6.97k| break; 2220| 9.54k| } 2221| 9.54k| } 2222| | 2223| 103| return decoded; 2224| 119|} ogs_nas_eps_decode_service_request: 2227| 13|{ 2228| 13| ogs_nas_eps_service_request_t *service_request = &message->emm.service_request; 2229| 13| int decoded = 0; 2230| 13| int size = 0; 2231| | 2232| 13| ogs_trace("[NAS] Decode SERVICE_REQUEST\n"); ------------------ | | 40| 13|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 2233| | 2234| 13| size = ogs_nas_eps_decode_ksi_and_sequence_number(&service_request->ksi_and_sequence_number, pkbuf); 2235| 13| if (size < 0) { ------------------ | Branch (2235:9): [True: 0, False: 13] ------------------ 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| 13| decoded += size; 2241| | 2242| 13| size = ogs_nas_eps_decode_short_mac(&service_request->message_authentication_code, pkbuf); 2243| 13| if (size < 0) { ------------------ | Branch (2243:9): [True: 0, False: 13] ------------------ 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| 13| decoded += size; 2249| | 2250| 13| return decoded; 2251| 13|} ogs_nas_eps_decode_service_reject: 2254| 134|{ 2255| 134| ogs_nas_eps_service_reject_t *service_reject = &message->emm.service_reject; 2256| 134| int decoded = 0; 2257| 134| int size = 0; 2258| | 2259| 134| ogs_trace("[NAS] Decode SERVICE_REJECT\n"); ------------------ | | 40| 134|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 134| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 134|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 134| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 134|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 134| 0, __VA_ARGS__) | | ------------------ ------------------ 2260| | 2261| 134| size = ogs_nas_eps_decode_emm_cause(&service_reject->emm_cause, pkbuf); 2262| 134| if (size < 0) { ------------------ | Branch (2262:9): [True: 0, False: 134] ------------------ 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| 134| decoded += size; 2268| | 2269| 6.25k| while (pkbuf->len > 0) { ------------------ | Branch (2269:12): [True: 6.14k, False: 114] ------------------ 2270| 6.14k| uint8_t *buffer = pkbuf->data; 2271| 6.14k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2271:24): [True: 1.08k, False: 5.06k] ------------------ 2272| | 2273| 6.14k| size = sizeof(uint8_t); 2274| 6.14k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2274:13): [True: 0, False: 6.14k] ------------------ 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| 6.14k| decoded += size; 2279| | 2280| 6.14k| switch (type) { 2281| 212| case OGS_NAS_EPS_SERVICE_REJECT_T3442_VALUE_TYPE: ------------------ | | 785| 212|#define OGS_NAS_EPS_SERVICE_REJECT_T3442_VALUE_TYPE 0x5B ------------------ | Branch (2281:9): [True: 212, False: 5.93k] ------------------ 2282| 212| size = ogs_nas_eps_decode_gprs_timer(&service_reject->t3442_value, pkbuf); 2283| 212| if (size < 0) { ------------------ | Branch (2283:17): [True: 3, False: 209] ------------------ 2284| 3| ogs_error("ogs_nas_eps_decode_gprs_timer() 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__) | | ------------------ ------------------ 2285| 3| return size; 2286| 3| } 2287| | 2288| 209| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_T3442_VALUE_PRESENT; ------------------ | | 776| 209|#define OGS_NAS_EPS_SERVICE_REJECT_T3442_VALUE_PRESENT ((uint64_t)1<<0) ------------------ 2289| 209| decoded += size; 2290| 209| break; 2291| 216| case OGS_NAS_EPS_SERVICE_REJECT_T3346_VALUE_TYPE: ------------------ | | 786| 216|#define OGS_NAS_EPS_SERVICE_REJECT_T3346_VALUE_TYPE 0x5F ------------------ | Branch (2291:9): [True: 216, False: 5.92k] ------------------ 2292| 216| size = ogs_nas_eps_decode_gprs_timer_2(&service_reject->t3346_value, pkbuf); 2293| 216| if (size < 0) { ------------------ | Branch (2293:17): [True: 2, False: 214] ------------------ 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| 214| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_T3346_VALUE_PRESENT; ------------------ | | 777| 214|#define OGS_NAS_EPS_SERVICE_REJECT_T3346_VALUE_PRESENT ((uint64_t)1<<1) ------------------ 2299| 214| decoded += size; 2300| 214| break; 2301| 198| case OGS_NAS_EPS_SERVICE_REJECT_T3448_VALUE_TYPE: ------------------ | | 787| 198|#define OGS_NAS_EPS_SERVICE_REJECT_T3448_VALUE_TYPE 0x6B ------------------ | Branch (2301:9): [True: 198, False: 5.94k] ------------------ 2302| 198| size = ogs_nas_eps_decode_gprs_timer_2(&service_reject->t3448_value, pkbuf); 2303| 198| if (size < 0) { ------------------ | Branch (2303:17): [True: 2, False: 196] ------------------ 2304| 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__) | | ------------------ ------------------ 2305| 2| return size; 2306| 2| } 2307| | 2308| 196| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_T3448_VALUE_PRESENT; ------------------ | | 778| 196|#define OGS_NAS_EPS_SERVICE_REJECT_T3448_VALUE_PRESENT ((uint64_t)1<<2) ------------------ 2309| 196| decoded += size; 2310| 196| break; 2311| 199| case OGS_NAS_EPS_SERVICE_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE: ------------------ | | 788| 199|#define OGS_NAS_EPS_SERVICE_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE 0x1C ------------------ | Branch (2311:9): [True: 199, False: 5.94k] ------------------ 2312| 199| size = ogs_nas_eps_decode_gprs_timer_3(&service_reject->lower_bound_timer_value, pkbuf); 2313| 199| if (size < 0) { ------------------ | Branch (2313:17): [True: 2, False: 197] ------------------ 2314| 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__) | | ------------------ ------------------ 2315| 2| return size; 2316| 2| } 2317| | 2318| 197| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT; ------------------ | | 779| 197|#define OGS_NAS_EPS_SERVICE_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT ((uint64_t)1<<3) ------------------ 2319| 197| decoded += size; 2320| 197| break; 2321| 344| case OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 789| 344|#define OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE 0x1D ------------------ | Branch (2321:9): [True: 344, False: 5.79k] ------------------ 2322| 344| size = ogs_nas_eps_decode_tracking_area_identity_list(&service_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf); 2323| 344| if (size < 0) { ------------------ | Branch (2323:17): [True: 2, False: 342] ------------------ 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| 342| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT; ------------------ | | 780| 342|#define OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT ((uint64_t)1<<4) ------------------ 2329| 342| decoded += size; 2330| 342| 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.93k] ------------------ 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: 2, False: 206] ------------------ 2334| 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__) | | ------------------ ------------------ 2335| 2| return size; 2336| 2| } 2337| | 2338| 206| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT; ------------------ | | 781| 206|#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| 206| decoded += size; 2340| 206| break; 2341| 251| case OGS_NAS_EPS_SERVICE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 791| 251|#define OGS_NAS_EPS_SERVICE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (2341:9): [True: 251, False: 5.89k] ------------------ 2342| 251| size = ogs_nas_eps_decode_access_technology_utilization_control(&service_reject->access_technology_utilization_control, pkbuf); 2343| 251| if (size < 0) { ------------------ | Branch (2343:17): [True: 2, False: 249] ------------------ 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| 249| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 782| 249|#define OGS_NAS_EPS_SERVICE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<6) ------------------ 2349| 249| decoded += size; 2350| 249| break; 2351| 219| case OGS_NAS_EPS_SERVICE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 792| 219|#define OGS_NAS_EPS_SERVICE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (2351:9): [True: 219, False: 5.92k] ------------------ 2352| 219| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&service_reject->s_f_satellite_operation_parameters, pkbuf); 2353| 219| if (size < 0) { ------------------ | Branch (2353:17): [True: 3, False: 216] ------------------ 2354| 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__) | | ------------------ ------------------ 2355| 3| return size; 2356| 3| } 2357| | 2358| 216| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 783| 216|#define OGS_NAS_EPS_SERVICE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<7) ------------------ 2359| 216| decoded += size; 2360| 216| break; 2361| 245| case OGS_NAS_EPS_SERVICE_REJECT_DISASTER_RETURN_WAIT_RANGE_TYPE: ------------------ | | 793| 245|#define OGS_NAS_EPS_SERVICE_REJECT_DISASTER_RETURN_WAIT_RANGE_TYPE 0x24 ------------------ | Branch (2361:9): [True: 245, False: 5.89k] ------------------ 2362| 245| size = ogs_nas_eps_decode_registration_wait_range(&service_reject->disaster_return_wait_range, pkbuf); 2363| 245| if (size < 0) { ------------------ | Branch (2363:17): [True: 2, False: 243] ------------------ 2364| 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__) | | ------------------ ------------------ 2365| 2| return size; 2366| 2| } 2367| | 2368| 243| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_DISASTER_RETURN_WAIT_RANGE_PRESENT; ------------------ | | 784| 243|#define OGS_NAS_EPS_SERVICE_REJECT_DISASTER_RETURN_WAIT_RANGE_PRESENT ((uint64_t)1<<8) ------------------ 2369| 243| decoded += size; 2370| 243| break; 2371| 4.05k| default: ------------------ | Branch (2371:9): [True: 4.05k, False: 2.09k] ------------------ 2372| 4.05k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 4.05k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4.05k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4.05k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4.05k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4.05k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4.05k| 0, __VA_ARGS__) | | ------------------ ------------------ 2373| 4.05k| break; 2374| 6.14k| } 2375| 6.14k| } 2376| | 2377| 114| return decoded; 2378| 134|} ogs_nas_eps_decode_guti_reallocation_command: 2381| 110|{ 2382| 110| ogs_nas_eps_guti_reallocation_command_t *guti_reallocation_command = &message->emm.guti_reallocation_command; 2383| 110| int decoded = 0; 2384| 110| int size = 0; 2385| | 2386| 110| ogs_trace("[NAS] Decode GUTI_REALLOCATION_COMMAND\n"); ------------------ | | 40| 110|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 110| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 110|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 110| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 110|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 110| 0, __VA_ARGS__) | | ------------------ ------------------ 2387| | 2388| 110| size = ogs_nas_eps_decode_eps_mobile_identity(&guti_reallocation_command->guti, pkbuf); 2389| 110| if (size < 0) { ------------------ | Branch (2389:9): [True: 3, False: 107] ------------------ 2390| 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__) | | ------------------ ------------------ 2391| 3| return size; 2392| 3| } 2393| | 2394| 107| decoded += size; 2395| | 2396| 5.12k| while (pkbuf->len > 0) { ------------------ | Branch (2396:12): [True: 5.03k, False: 94] ------------------ 2397| 5.03k| uint8_t *buffer = pkbuf->data; 2398| 5.03k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2398:24): [True: 2.23k, False: 2.79k] ------------------ 2399| | 2400| 5.03k| size = sizeof(uint8_t); 2401| 5.03k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2401:13): [True: 0, False: 5.03k] ------------------ 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| 5.03k| decoded += size; 2406| | 2407| 5.03k| switch (type) { 2408| 205| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_TAI_LIST_TYPE: ------------------ | | 821| 205|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_TAI_LIST_TYPE 0x54 ------------------ | Branch (2408:9): [True: 205, False: 4.82k] ------------------ 2409| 205| size = ogs_nas_eps_decode_tracking_area_identity_list(&guti_reallocation_command->tai_list, pkbuf); 2410| 205| if (size < 0) { ------------------ | Branch (2410:17): [True: 1, False: 204] ------------------ 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| 204| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_TAI_LIST_PRESENT; ------------------ | | 816| 204|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_TAI_LIST_PRESENT ((uint64_t)1<<0) ------------------ 2416| 204| decoded += size; 2417| 204| break; 2418| 238| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_DCN_ID_TYPE: ------------------ | | 822| 238|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_DCN_ID_TYPE 0x65 ------------------ | Branch (2418:9): [True: 238, False: 4.79k] ------------------ 2419| 238| size = ogs_nas_eps_decode_dcn_id(&guti_reallocation_command->dcn_id, pkbuf); 2420| 238| if (size < 0) { ------------------ | Branch (2420:17): [True: 7, False: 231] ------------------ 2421| 7| ogs_error("ogs_nas_eps_decode_dcn_id() 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__) | | ------------------ ------------------ 2422| 7| return size; 2423| 7| } 2424| | 2425| 231| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_DCN_ID_PRESENT; ------------------ | | 817| 231|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_DCN_ID_PRESENT ((uint64_t)1<<1) ------------------ 2426| 231| decoded += size; 2427| 231| break; 2428| 269| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_TYPE: ------------------ | | 823| 269|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_TYPE 0x66 ------------------ | Branch (2428:9): [True: 269, False: 4.76k] ------------------ 2429| 269| size = ogs_nas_eps_decode_ue_radio_capability_id(&guti_reallocation_command->ue_radio_capability_id, pkbuf); 2430| 269| if (size < 0) { ------------------ | Branch (2430:17): [True: 2, False: 267] ------------------ 2431| 2| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id() 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__) | | ------------------ ------------------ 2432| 2| return size; 2433| 2| } 2434| | 2435| 267| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_PRESENT; ------------------ | | 818| 267|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_PRESENT ((uint64_t)1<<2) ------------------ 2436| 267| decoded += size; 2437| 267| break; 2438| 605| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE: ------------------ | | 824| 605|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE 0xB0 ------------------ | Branch (2438:9): [True: 605, False: 4.42k] ------------------ 2439| 605| decoded--; 2440| 605| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 605| do { \ | | 114| 605| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 605|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 605, False: 0] | | | | ------------------ | | ------------------ | | 115| 605| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 605| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 605] | | ------------------ ------------------ 2441| 605| size = ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication(&guti_reallocation_command->ue_radio_capability_id_deletion_indication, pkbuf); 2442| 605| if (size < 0) { ------------------ | Branch (2442:17): [True: 0, False: 605] ------------------ 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| 605| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT; ------------------ | | 819| 605|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT ((uint64_t)1<<3) ------------------ 2448| 605| decoded += size; 2449| 605| break; 2450| 236| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 825| 236|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (2450:9): [True: 236, False: 4.79k] ------------------ 2451| 236| size = ogs_nas_eps_decode_access_technology_utilization_control(&guti_reallocation_command->access_technology_utilization_control, pkbuf); 2452| 236| if (size < 0) { ------------------ | Branch (2452:17): [True: 3, False: 233] ------------------ 2453| 3| ogs_error("ogs_nas_eps_decode_access_technology_utilization_control() 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__) | | ------------------ ------------------ 2454| 3| return size; 2455| 3| } 2456| | 2457| 233| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 820| 233|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<4) ------------------ 2458| 233| decoded += size; 2459| 233| break; 2460| 3.47k| default: ------------------ | Branch (2460:9): [True: 3.47k, False: 1.55k] ------------------ 2461| 3.47k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 3.47k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.47k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.47k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.47k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.47k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.47k| 0, __VA_ARGS__) | | ------------------ ------------------ 2462| 3.47k| break; 2463| 5.03k| } 2464| 5.03k| } 2465| | 2466| 94| return decoded; 2467| 107|} ogs_nas_eps_decode_authentication_request: 2470| 26|{ 2471| 26| ogs_nas_eps_authentication_request_t *authentication_request = &message->emm.authentication_request; 2472| 26| int decoded = 0; 2473| 26| int size = 0; 2474| | 2475| 26| ogs_trace("[NAS] Decode AUTHENTICATION_REQUEST\n"); ------------------ | | 40| 26|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 2476| | 2477| 26| size = ogs_nas_eps_decode_key_set_identifier(&authentication_request->nas_key_set_identifierasme, pkbuf); 2478| 26| if (size < 0) { ------------------ | Branch (2478:9): [True: 0, False: 26] ------------------ 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| 26| decoded += size; 2484| | 2485| 26| size = ogs_nas_eps_decode_authentication_parameter_rand(&authentication_request->authentication_parameter_rand, pkbuf); 2486| 26| if (size < 0) { ------------------ | Branch (2486:9): [True: 8, False: 18] ------------------ 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| 18| decoded += size; 2492| | 2493| 18| size = ogs_nas_eps_decode_authentication_parameter_autn(&authentication_request->authentication_parameter_autn, pkbuf); 2494| 18| if (size < 0) { ------------------ | Branch (2494:9): [True: 6, False: 12] ------------------ 2495| 6| ogs_error("ogs_nas_eps_decode_authentication_parameter_autn() 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__) | | ------------------ ------------------ 2496| 6| return size; 2497| 6| } 2498| | 2499| 12| decoded += size; 2500| | 2501| 12| return decoded; 2502| 18|} ogs_nas_eps_decode_authentication_response: 2505| 26|{ 2506| 26| ogs_nas_eps_authentication_response_t *authentication_response = &message->emm.authentication_response; 2507| 26| int decoded = 0; 2508| 26| int size = 0; 2509| | 2510| 26| ogs_trace("[NAS] Decode AUTHENTICATION_RESPONSE\n"); ------------------ | | 40| 26|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 2511| | 2512| 26| size = ogs_nas_eps_decode_authentication_response_parameter(&authentication_response->authentication_response_parameter, pkbuf); 2513| 26| if (size < 0) { ------------------ | Branch (2513:9): [True: 4, False: 22] ------------------ 2514| 4| ogs_error("ogs_nas_eps_decode_authentication_response_parameter() 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__) | | ------------------ ------------------ 2515| 4| return size; 2516| 4| } 2517| | 2518| 22| decoded += size; 2519| | 2520| 22| return decoded; 2521| 26|} ogs_nas_eps_decode_identity_request: 2524| 10|{ 2525| 10| ogs_nas_eps_identity_request_t *identity_request = &message->emm.identity_request; 2526| 10| int decoded = 0; 2527| 10| int size = 0; 2528| | 2529| 10| ogs_trace("[NAS] Decode IDENTITY_REQUEST\n"); ------------------ | | 40| 10|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 2530| | 2531| 10| size = ogs_nas_eps_decode_identity_type_2(&identity_request->identity_type, pkbuf); 2532| 10| if (size < 0) { ------------------ | Branch (2532:9): [True: 0, False: 10] ------------------ 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| 10| decoded += size; 2538| | 2539| 10| return decoded; 2540| 10|} ogs_nas_eps_decode_identity_response: 2543| 23|{ 2544| 23| ogs_nas_eps_identity_response_t *identity_response = &message->emm.identity_response; 2545| 23| int decoded = 0; 2546| 23| int size = 0; 2547| | 2548| 23| ogs_trace("[NAS] Decode IDENTITY_RESPONSE\n"); ------------------ | | 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__) | | ------------------ ------------------ 2549| | 2550| 23| size = ogs_nas_eps_decode_mobile_identity(&identity_response->mobile_identity, pkbuf); 2551| 23| if (size < 0) { ------------------ | Branch (2551:9): [True: 4, False: 19] ------------------ 2552| 4| ogs_error("ogs_nas_eps_decode_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__) | | ------------------ ------------------ 2553| 4| return size; 2554| 4| } 2555| | 2556| 19| decoded += size; 2557| | 2558| 19| return decoded; 2559| 23|} ogs_nas_eps_decode_authentication_failure: 2562| 69|{ 2563| 69| ogs_nas_eps_authentication_failure_t *authentication_failure = &message->emm.authentication_failure; 2564| 69| int decoded = 0; 2565| 69| int size = 0; 2566| | 2567| 69| ogs_trace("[NAS] Decode AUTHENTICATION_FAILURE\n"); ------------------ | | 40| 69|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 69| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 69|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 69| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 69|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 69| 0, __VA_ARGS__) | | ------------------ ------------------ 2568| | 2569| 69| size = ogs_nas_eps_decode_emm_cause(&authentication_failure->emm_cause, pkbuf); 2570| 69| if (size < 0) { ------------------ | Branch (2570:9): [True: 0, False: 69] ------------------ 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| 69| decoded += size; 2576| | 2577| 4.61k| while (pkbuf->len > 0) { ------------------ | Branch (2577:12): [True: 4.56k, False: 50] ------------------ 2578| 4.56k| uint8_t *buffer = pkbuf->data; 2579| 4.56k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2579:24): [True: 1.87k, False: 2.69k] ------------------ 2580| | 2581| 4.56k| size = sizeof(uint8_t); 2582| 4.56k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2582:13): [True: 0, False: 4.56k] ------------------ 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| 4.56k| decoded += size; 2587| | 2588| 4.56k| switch (type) { 2589| 455| case OGS_NAS_EPS_AUTHENTICATION_FAILURE_AUTHENTICATION_FAILURE_PARAMETER_TYPE: ------------------ | | 887| 455|#define OGS_NAS_EPS_AUTHENTICATION_FAILURE_AUTHENTICATION_FAILURE_PARAMETER_TYPE 0x30 ------------------ | Branch (2589:9): [True: 455, False: 4.10k] ------------------ 2590| 455| size = ogs_nas_eps_decode_authentication_failure_parameter(&authentication_failure->authentication_failure_parameter, pkbuf); 2591| 455| if (size < 0) { ------------------ | Branch (2591:17): [True: 19, False: 436] ------------------ 2592| 19| ogs_error("ogs_nas_eps_decode_authentication_failure_parameter() failed"); ------------------ | | 36| 19|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 19| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 19|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 19| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 19|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 19| 0, __VA_ARGS__) | | ------------------ ------------------ 2593| 19| return size; 2594| 19| } 2595| | 2596| 436| authentication_failure->presencemask |= OGS_NAS_EPS_AUTHENTICATION_FAILURE_AUTHENTICATION_FAILURE_PARAMETER_PRESENT; ------------------ | | 886| 436|#define OGS_NAS_EPS_AUTHENTICATION_FAILURE_AUTHENTICATION_FAILURE_PARAMETER_PRESENT ((uint64_t)1<<0) ------------------ 2597| 436| decoded += size; 2598| 436| break; 2599| 4.10k| default: ------------------ | Branch (2599:9): [True: 4.10k, False: 455] ------------------ 2600| 4.10k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 4.10k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4.10k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4.10k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4.10k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4.10k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4.10k| 0, __VA_ARGS__) | | ------------------ ------------------ 2601| 4.10k| break; 2602| 4.56k| } 2603| 4.56k| } 2604| | 2605| 50| return decoded; 2606| 69|} ogs_nas_eps_decode_security_mode_command: 2609| 120|{ 2610| 120| ogs_nas_eps_security_mode_command_t *security_mode_command = &message->emm.security_mode_command; 2611| 120| int decoded = 0; 2612| 120| int size = 0; 2613| | 2614| 120| ogs_trace("[NAS] Decode SECURITY_MODE_COMMAND\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__) | | ------------------ ------------------ 2615| | 2616| 120| size = ogs_nas_eps_decode_security_algorithms(&security_mode_command->selected_nas_security_algorithms, pkbuf); 2617| 120| if (size < 0) { ------------------ | Branch (2617:9): [True: 0, False: 120] ------------------ 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| 120| decoded += size; 2623| | 2624| 120| size = ogs_nas_eps_decode_key_set_identifier(&security_mode_command->nas_key_set_identifier, pkbuf); 2625| 120| if (size < 0) { ------------------ | Branch (2625:9): [True: 0, False: 120] ------------------ 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| 120| decoded += size; 2631| | 2632| 120| size = ogs_nas_eps_decode_ue_security_capability(&security_mode_command->replayed_ue_security_capabilities, pkbuf); 2633| 120| if (size < 0) { ------------------ | Branch (2633:9): [True: 4, False: 116] ------------------ 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| 116| decoded += size; 2639| | 2640| 6.15k| while (pkbuf->len > 0) { ------------------ | Branch (2640:12): [True: 6.05k, False: 95] ------------------ 2641| 6.05k| uint8_t *buffer = pkbuf->data; 2642| 6.05k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2642:24): [True: 2.18k, False: 3.87k] ------------------ 2643| | 2644| 6.05k| size = sizeof(uint8_t); 2645| 6.05k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2645:13): [True: 0, False: 6.05k] ------------------ 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| 6.05k| decoded += size; 2650| | 2651| 6.05k| switch (type) { 2652| 722| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_IMEISV_REQUEST_TYPE: ------------------ | | 909| 722|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_IMEISV_REQUEST_TYPE 0xC0 ------------------ | Branch (2652:9): [True: 722, False: 5.33k] ------------------ 2653| 722| decoded--; 2654| 722| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 722| do { \ | | 114| 722| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 722|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 722, False: 0] | | | | ------------------ | | ------------------ | | 115| 722| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 722| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 722] | | ------------------ ------------------ 2655| 722| size = ogs_nas_eps_decode_imeisv_request(&security_mode_command->imeisv_request, pkbuf); 2656| 722| if (size < 0) { ------------------ | Branch (2656:17): [True: 0, False: 722] ------------------ 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| 722| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_IMEISV_REQUEST_PRESENT; ------------------ | | 902| 722|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_IMEISV_REQUEST_PRESENT ((uint64_t)1<<0) ------------------ 2662| 722| decoded += size; 2663| 722| break; 2664| 454| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_NONCEUE_TYPE: ------------------ | | 910| 454|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_NONCEUE_TYPE 0x55 ------------------ | Branch (2664:9): [True: 454, False: 5.60k] ------------------ 2665| 454| size = ogs_nas_eps_decode_nonce(&security_mode_command->replayed_nonceue, pkbuf); 2666| 454| if (size < 0) { ------------------ | Branch (2666:17): [True: 2, False: 452] ------------------ 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| 452| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_NONCEUE_PRESENT; ------------------ | | 903| 452|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_NONCEUE_PRESENT ((uint64_t)1<<1) ------------------ 2672| 452| decoded += size; 2673| 452| break; 2674| 198| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_NONCEMME_TYPE: ------------------ | | 911| 198|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_NONCEMME_TYPE 0x56 ------------------ | Branch (2674:9): [True: 198, False: 5.86k] ------------------ 2675| 198| size = ogs_nas_eps_decode_nonce(&security_mode_command->noncemme, pkbuf); 2676| 198| if (size < 0) { ------------------ | Branch (2676:17): [True: 1, False: 197] ------------------ 2677| 1| ogs_error("ogs_nas_eps_decode_nonce() 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__) | | ------------------ ------------------ 2678| 1| return size; 2679| 1| } 2680| | 2681| 197| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_NONCEMME_PRESENT; ------------------ | | 904| 197|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_NONCEMME_PRESENT ((uint64_t)1<<2) ------------------ 2682| 197| decoded += size; 2683| 197| break; 2684| 369| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_HASHMME_TYPE: ------------------ | | 912| 369|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_HASHMME_TYPE 0x4F ------------------ | Branch (2684:9): [True: 369, False: 5.69k] ------------------ 2685| 369| size = ogs_nas_eps_decode_hashmme(&security_mode_command->hashmme, pkbuf); 2686| 369| if (size < 0) { ------------------ | Branch (2686:17): [True: 9, False: 360] ------------------ 2687| 9| ogs_error("ogs_nas_eps_decode_hashmme() 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__) | | ------------------ ------------------ 2688| 9| return size; 2689| 9| } 2690| | 2691| 360| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_HASHMME_PRESENT; ------------------ | | 905| 360|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_HASHMME_PRESENT ((uint64_t)1<<3) ------------------ 2692| 360| decoded += size; 2693| 360| break; 2694| 198| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE: ------------------ | | 913| 198|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE 0x6F ------------------ | Branch (2694:9): [True: 198, False: 5.86k] ------------------ 2695| 198| size = ogs_nas_eps_decode_ue_additional_security_capability(&security_mode_command->replayed_ue_additional_security_capability, pkbuf); 2696| 198| if (size < 0) { ------------------ | Branch (2696:17): [True: 1, False: 197] ------------------ 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| 197| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT; ------------------ | | 906| 197|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT ((uint64_t)1<<4) ------------------ 2702| 197| decoded += size; 2703| 197| break; 2704| 352| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_RADIO_CAPABILITY_ID_REQUEST_TYPE: ------------------ | | 914| 352|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_RADIO_CAPABILITY_ID_REQUEST_TYPE 0x37 ------------------ | Branch (2704:9): [True: 352, False: 5.70k] ------------------ 2705| 352| size = ogs_nas_eps_decode_ue_radio_capability_id_request(&security_mode_command->ue_radio_capability_id_request, pkbuf); 2706| 352| if (size < 0) { ------------------ | Branch (2706:17): [True: 8, False: 344] ------------------ 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| 344| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_RADIO_CAPABILITY_ID_REQUEST_PRESENT; ------------------ | | 907| 344|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_RADIO_CAPABILITY_ID_REQUEST_PRESENT ((uint64_t)1<<5) ------------------ 2712| 344| decoded += size; 2713| 344| break; 2714| 453| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_COARSE_LOCATION_INFORMATION_REQUEST_TYPE: ------------------ | | 915| 453|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_COARSE_LOCATION_INFORMATION_REQUEST_TYPE 0xD0 ------------------ | Branch (2714:9): [True: 453, False: 5.60k] ------------------ 2715| 453| decoded--; 2716| 453| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 453| do { \ | | 114| 453| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 453|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 453, False: 0] | | | | ------------------ | | ------------------ | | 115| 453| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 453| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 453] | | ------------------ ------------------ 2717| 453| size = ogs_nas_eps_decode_ue_information_request(&security_mode_command->ue_coarse_location_information_request, pkbuf); 2718| 453| if (size < 0) { ------------------ | Branch (2718:17): [True: 0, False: 453] ------------------ 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| 453| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_COARSE_LOCATION_INFORMATION_REQUEST_PRESENT; ------------------ | | 908| 453|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_COARSE_LOCATION_INFORMATION_REQUEST_PRESENT ((uint64_t)1<<6) ------------------ 2724| 453| decoded += size; 2725| 453| break; 2726| 3.31k| default: ------------------ | Branch (2726:9): [True: 3.31k, False: 2.74k] ------------------ 2727| 3.31k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 3.31k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.31k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.31k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.31k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.31k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.31k| 0, __VA_ARGS__) | | ------------------ ------------------ 2728| 3.31k| break; 2729| 6.05k| } 2730| 6.05k| } 2731| | 2732| 95| return decoded; 2733| 116|} ogs_nas_eps_decode_security_mode_complete: 2736| 164|{ 2737| 164| ogs_nas_eps_security_mode_complete_t *security_mode_complete = &message->emm.security_mode_complete; 2738| 164| int decoded = 0; 2739| 164| int size = 0; 2740| | 2741| 164| ogs_trace("[NAS] Decode SECURITY_MODE_COMPLETE\n"); ------------------ | | 40| 164|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 164| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 164|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 164| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 164|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 164| 0, __VA_ARGS__) | | ------------------ ------------------ 2742| | 2743| 9.09k| while (pkbuf->len > 0) { ------------------ | Branch (2743:12): [True: 8.99k, False: 103] ------------------ 2744| 8.99k| uint8_t *buffer = pkbuf->data; 2745| 8.99k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2745:24): [True: 2.18k, False: 6.80k] ------------------ 2746| | 2747| 8.99k| size = sizeof(uint8_t); 2748| 8.99k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2748:13): [True: 0, False: 8.99k] ------------------ 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| 8.99k| decoded += size; 2753| | 2754| 8.99k| switch (type) { 2755| 842| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE_IMEISV_TYPE: ------------------ | | 942| 842|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_IMEISV_TYPE 0x23 ------------------ | Branch (2755:9): [True: 842, False: 8.15k] ------------------ 2756| 842| size = ogs_nas_eps_decode_mobile_identity(&security_mode_complete->imeisv, pkbuf); 2757| 842| if (size < 0) { ------------------ | Branch (2757:17): [True: 9, False: 833] ------------------ 2758| 9| ogs_error("ogs_nas_eps_decode_mobile_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__) | | ------------------ ------------------ 2759| 9| return size; 2760| 9| } 2761| | 2762| 833| security_mode_complete->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMPLETE_IMEISV_PRESENT; ------------------ | | 938| 833|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_IMEISV_PRESENT ((uint64_t)1<<0) ------------------ 2763| 833| decoded += size; 2764| 833| break; 2765| 330| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE_REPLAYED_NAS_MESSAGE_CONTAINER_TYPE: ------------------ | | 943| 330|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_REPLAYED_NAS_MESSAGE_CONTAINER_TYPE 0x79 ------------------ | Branch (2765:9): [True: 330, False: 8.66k] ------------------ 2766| 330| size = ogs_nas_eps_decode_replayed_nas_message_container(&security_mode_complete->replayed_nas_message_container, pkbuf); 2767| 330| if (size < 0) { ------------------ | Branch (2767:17): [True: 34, False: 296] ------------------ 2768| 34| ogs_error("ogs_nas_eps_decode_replayed_nas_message_container() failed"); ------------------ | | 36| 34|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 34| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 34|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 34| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 34|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 34| 0, __VA_ARGS__) | | ------------------ ------------------ 2769| 34| return size; 2770| 34| } 2771| | 2772| 296| security_mode_complete->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMPLETE_REPLAYED_NAS_MESSAGE_CONTAINER_PRESENT; ------------------ | | 939| 296|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_REPLAYED_NAS_MESSAGE_CONTAINER_PRESENT ((uint64_t)1<<1) ------------------ 2773| 296| decoded += size; 2774| 296| break; 2775| 487| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_RADIO_CAPABILITY_ID_TYPE: ------------------ | | 944| 487|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_RADIO_CAPABILITY_ID_TYPE 0x66 ------------------ | Branch (2775:9): [True: 487, False: 8.50k] ------------------ 2776| 487| size = ogs_nas_eps_decode_ue_radio_capability_id(&security_mode_complete->ue_radio_capability_id, pkbuf); 2777| 487| if (size < 0) { ------------------ | Branch (2777:17): [True: 10, False: 477] ------------------ 2778| 10| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id() 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__) | | ------------------ ------------------ 2779| 10| return size; 2780| 10| } 2781| | 2782| 477| security_mode_complete->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_RADIO_CAPABILITY_ID_PRESENT; ------------------ | | 940| 477|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_RADIO_CAPABILITY_ID_PRESENT ((uint64_t)1<<2) ------------------ 2783| 477| decoded += size; 2784| 477| break; 2785| 273| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_COARSE_LOCATION_INFORMATION_TYPE: ------------------ | | 945| 273|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_COARSE_LOCATION_INFORMATION_TYPE 0x67 ------------------ | Branch (2785:9): [True: 273, False: 8.72k] ------------------ 2786| 273| size = ogs_nas_eps_decode_ue_coarse_location_information(&security_mode_complete->ue_coarse_location_information, pkbuf); 2787| 273| if (size < 0) { ------------------ | Branch (2787:17): [True: 8, False: 265] ------------------ 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| 265| security_mode_complete->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_COARSE_LOCATION_INFORMATION_PRESENT; ------------------ | | 941| 265|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_COARSE_LOCATION_INFORMATION_PRESENT ((uint64_t)1<<3) ------------------ 2793| 265| decoded += size; 2794| 265| break; 2795| 7.06k| default: ------------------ | Branch (2795:9): [True: 7.06k, False: 1.93k] ------------------ 2796| 7.06k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 7.06k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7.06k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7.06k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7.06k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7.06k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7.06k| 0, __VA_ARGS__) | | ------------------ ------------------ 2797| 7.06k| break; 2798| 8.99k| } 2799| 8.99k| } 2800| | 2801| 103| return decoded; 2802| 164|} 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| 132|{ 2844| 132| ogs_nas_eps_emm_information_t *emm_information = &message->emm.emm_information; 2845| 132| int decoded = 0; 2846| 132| int size = 0; 2847| | 2848| 132| ogs_trace("[NAS] Decode EMM_INFORMATION\n"); ------------------ | | 40| 132|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 132| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 132|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 132| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 132|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 132| 0, __VA_ARGS__) | | ------------------ ------------------ 2849| | 2850| 5.53k| while (pkbuf->len > 0) { ------------------ | Branch (2850:12): [True: 5.44k, False: 91] ------------------ 2851| 5.44k| uint8_t *buffer = pkbuf->data; 2852| 5.44k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2852:24): [True: 1.77k, False: 3.66k] ------------------ 2853| | 2854| 5.44k| size = sizeof(uint8_t); 2855| 5.44k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2855:13): [True: 0, False: 5.44k] ------------------ 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| 5.44k| decoded += size; 2860| | 2861| 5.44k| switch (type) { 2862| 248| case OGS_NAS_EPS_EMM_INFORMATION_FULL_NAME_FOR_NETWORK_TYPE: ------------------ | | 986| 248|#define OGS_NAS_EPS_EMM_INFORMATION_FULL_NAME_FOR_NETWORK_TYPE 0x43 ------------------ | Branch (2862:9): [True: 248, False: 5.19k] ------------------ 2863| 248| size = ogs_nas_eps_decode_network_name(&emm_information->full_name_for_network, pkbuf); 2864| 248| if (size < 0) { ------------------ | Branch (2864:17): [True: 9, False: 239] ------------------ 2865| 9| ogs_error("ogs_nas_eps_decode_network_name() 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__) | | ------------------ ------------------ 2866| 9| return size; 2867| 9| } 2868| | 2869| 239| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_FULL_NAME_FOR_NETWORK_PRESENT; ------------------ | | 981| 239|#define OGS_NAS_EPS_EMM_INFORMATION_FULL_NAME_FOR_NETWORK_PRESENT ((uint64_t)1<<0) ------------------ 2870| 239| decoded += size; 2871| 239| break; 2872| 210| case OGS_NAS_EPS_EMM_INFORMATION_SHORT_NAME_FOR_NETWORK_TYPE: ------------------ | | 987| 210|#define OGS_NAS_EPS_EMM_INFORMATION_SHORT_NAME_FOR_NETWORK_TYPE 0x45 ------------------ | Branch (2872:9): [True: 210, False: 5.23k] ------------------ 2873| 210| size = ogs_nas_eps_decode_network_name(&emm_information->short_name_for_network, pkbuf); 2874| 210| if (size < 0) { ------------------ | Branch (2874:17): [True: 2, False: 208] ------------------ 2875| 2| ogs_error("ogs_nas_eps_decode_network_name() 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__) | | ------------------ ------------------ 2876| 2| return size; 2877| 2| } 2878| | 2879| 208| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_SHORT_NAME_FOR_NETWORK_PRESENT; ------------------ | | 982| 208|#define OGS_NAS_EPS_EMM_INFORMATION_SHORT_NAME_FOR_NETWORK_PRESENT ((uint64_t)1<<1) ------------------ 2880| 208| decoded += size; 2881| 208| break; 2882| 315| case OGS_NAS_EPS_EMM_INFORMATION_LOCAL_TIME_ZONE_TYPE: ------------------ | | 988| 315|#define OGS_NAS_EPS_EMM_INFORMATION_LOCAL_TIME_ZONE_TYPE 0x46 ------------------ | Branch (2882:9): [True: 315, False: 5.12k] ------------------ 2883| 315| size = ogs_nas_eps_decode_time_zone(&emm_information->local_time_zone, pkbuf); 2884| 315| if (size < 0) { ------------------ | Branch (2884:17): [True: 7, False: 308] ------------------ 2885| 7| ogs_error("ogs_nas_eps_decode_time_zone() 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__) | | ------------------ ------------------ 2886| 7| return size; 2887| 7| } 2888| | 2889| 308| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_LOCAL_TIME_ZONE_PRESENT; ------------------ | | 983| 308|#define OGS_NAS_EPS_EMM_INFORMATION_LOCAL_TIME_ZONE_PRESENT ((uint64_t)1<<2) ------------------ 2890| 308| decoded += size; 2891| 308| break; 2892| 180| case OGS_NAS_EPS_EMM_INFORMATION_UNIVERSAL_TIME_AND_LOCAL_TIME_ZONE_TYPE: ------------------ | | 989| 180|#define OGS_NAS_EPS_EMM_INFORMATION_UNIVERSAL_TIME_AND_LOCAL_TIME_ZONE_TYPE 0x47 ------------------ | Branch (2892:9): [True: 180, False: 5.26k] ------------------ 2893| 180| size = ogs_nas_eps_decode_time_zone_and_time(&emm_information->universal_time_and_local_time_zone, pkbuf); 2894| 180| if (size < 0) { ------------------ | Branch (2894:17): [True: 10, False: 170] ------------------ 2895| 10| ogs_error("ogs_nas_eps_decode_time_zone_and_time() 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__) | | ------------------ ------------------ 2896| 10| return size; 2897| 10| } 2898| | 2899| 170| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_UNIVERSAL_TIME_AND_LOCAL_TIME_ZONE_PRESENT; ------------------ | | 984| 170|#define OGS_NAS_EPS_EMM_INFORMATION_UNIVERSAL_TIME_AND_LOCAL_TIME_ZONE_PRESENT ((uint64_t)1<<3) ------------------ 2900| 170| decoded += size; 2901| 170| break; 2902| 537| case OGS_NAS_EPS_EMM_INFORMATION_NETWORK_DAYLIGHT_SAVING_TIME_TYPE: ------------------ | | 990| 537|#define OGS_NAS_EPS_EMM_INFORMATION_NETWORK_DAYLIGHT_SAVING_TIME_TYPE 0x49 ------------------ | Branch (2902:9): [True: 537, False: 4.90k] ------------------ 2903| 537| size = ogs_nas_eps_decode_daylight_saving_time(&emm_information->network_daylight_saving_time, pkbuf); 2904| 537| if (size < 0) { ------------------ | Branch (2904:17): [True: 13, False: 524] ------------------ 2905| 13| ogs_error("ogs_nas_eps_decode_daylight_saving_time() 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__) | | ------------------ ------------------ 2906| 13| return size; 2907| 13| } 2908| | 2909| 524| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_NETWORK_DAYLIGHT_SAVING_TIME_PRESENT; ------------------ | | 985| 524|#define OGS_NAS_EPS_EMM_INFORMATION_NETWORK_DAYLIGHT_SAVING_TIME_PRESENT ((uint64_t)1<<4) ------------------ 2910| 524| decoded += size; 2911| 524| break; 2912| 3.95k| default: ------------------ | Branch (2912:9): [True: 3.95k, False: 1.49k] ------------------ 2913| 3.95k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 3.95k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.95k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.95k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.95k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.95k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.95k| 0, __VA_ARGS__) | | ------------------ ------------------ 2914| 3.95k| break; 2915| 5.44k| } 2916| 5.44k| } 2917| | 2918| 91| return decoded; 2919| 132|} 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: 3, False: 29] ------------------ 2931| 3| ogs_error("ogs_nas_eps_decode_eps_message_container() 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__) | | ------------------ ------------------ 2932| 3| return size; 2933| 3| } 2934| | 2935| 29| decoded += size; 2936| | 2937| 29| return decoded; 2938| 32|} ogs_nas_eps_decode_uplink_nas_transport: 2941| 30|{ 2942| 30| ogs_nas_eps_uplink_nas_transport_t *uplink_nas_transport = &message->emm.uplink_nas_transport; 2943| 30| int decoded = 0; 2944| 30| int size = 0; 2945| | 2946| 30| ogs_trace("[NAS] Decode UPLINK_NAS_TRANSPORT\n"); ------------------ | | 40| 30|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 2947| | 2948| 30| size = ogs_nas_eps_decode_eps_message_container(&uplink_nas_transport->nas_message_container, pkbuf); 2949| 30| if (size < 0) { ------------------ | Branch (2949:9): [True: 7, False: 23] ------------------ 2950| 7| ogs_error("ogs_nas_eps_decode_eps_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__) | | ------------------ ------------------ 2951| 7| return size; 2952| 7| } 2953| | 2954| 23| decoded += size; 2955| | 2956| 23| return decoded; 2957| 30|} ogs_nas_eps_decode_cs_service_notification: 2960| 112|{ 2961| 112| ogs_nas_eps_cs_service_notification_t *cs_service_notification = &message->emm.cs_service_notification; 2962| 112| int decoded = 0; 2963| 112| int size = 0; 2964| | 2965| 112| ogs_trace("[NAS] Decode CS_SERVICE_NOTIFICATION\n"); ------------------ | | 40| 112|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 112| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 112|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 112| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 112|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 112| 0, __VA_ARGS__) | | ------------------ ------------------ 2966| | 2967| 112| size = ogs_nas_eps_decode_paging_identity(&cs_service_notification->paging_identity, pkbuf); 2968| 112| if (size < 0) { ------------------ | Branch (2968:9): [True: 0, False: 112] ------------------ 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| 112| decoded += size; 2974| | 2975| 4.76k| while (pkbuf->len > 0) { ------------------ | Branch (2975:12): [True: 4.68k, False: 75] ------------------ 2976| 4.68k| uint8_t *buffer = pkbuf->data; 2977| 4.68k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2977:24): [True: 1.09k, False: 3.59k] ------------------ 2978| | 2979| 4.68k| size = sizeof(uint8_t); 2980| 4.68k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2980:13): [True: 0, False: 4.68k] ------------------ 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.68k| decoded += size; 2985| | 2986| 4.68k| switch (type) { 2987| 379| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_CLI_TYPE: ------------------ | | 1031| 379|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_CLI_TYPE 0x60 ------------------ | Branch (2987:9): [True: 379, False: 4.30k] ------------------ 2988| 379| size = ogs_nas_eps_decode_cli(&cs_service_notification->cli, pkbuf); 2989| 379| if (size < 0) { ------------------ | Branch (2989:17): [True: 10, False: 369] ------------------ 2990| 10| ogs_error("ogs_nas_eps_decode_cli() 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__) | | ------------------ ------------------ 2991| 10| return size; 2992| 10| } 2993| | 2994| 369| cs_service_notification->presencemask |= OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_CLI_PRESENT; ------------------ | | 1027| 369|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_CLI_PRESENT ((uint64_t)1<<0) ------------------ 2995| 369| decoded += size; 2996| 369| break; 2997| 283| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_SS_CODE_TYPE: ------------------ | | 1032| 283|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_SS_CODE_TYPE 0x61 ------------------ | Branch (2997:9): [True: 283, False: 4.40k] ------------------ 2998| 283| size = ogs_nas_eps_decode_ss_code(&cs_service_notification->ss_code, pkbuf); 2999| 283| if (size < 0) { ------------------ | Branch (2999:17): [True: 5, False: 278] ------------------ 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| 278| cs_service_notification->presencemask |= OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_SS_CODE_PRESENT; ------------------ | | 1028| 278|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_SS_CODE_PRESENT ((uint64_t)1<<1) ------------------ 3005| 278| decoded += size; 3006| 278| break; 3007| 401| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_INDICATOR_TYPE: ------------------ | | 1033| 401|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_INDICATOR_TYPE 0x62 ------------------ | Branch (3007:9): [True: 401, False: 4.28k] ------------------ 3008| 401| size = ogs_nas_eps_decode_lcs_indicator(&cs_service_notification->lcs_indicator, pkbuf); 3009| 401| if (size < 0) { ------------------ | Branch (3009:17): [True: 8, False: 393] ------------------ 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| 393| cs_service_notification->presencemask |= OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_INDICATOR_PRESENT; ------------------ | | 1029| 393|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_INDICATOR_PRESENT ((uint64_t)1<<2) ------------------ 3015| 393| decoded += size; 3016| 393| break; 3017| 495| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_CLIENT_IDENTITY_TYPE: ------------------ | | 1034| 495|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_CLIENT_IDENTITY_TYPE 0x63 ------------------ | Branch (3017:9): [True: 495, False: 4.19k] ------------------ 3018| 495| size = ogs_nas_eps_decode_lcs_client_identity(&cs_service_notification->lcs_client_identity, pkbuf); 3019| 495| if (size < 0) { ------------------ | Branch (3019:17): [True: 14, False: 481] ------------------ 3020| 14| ogs_error("ogs_nas_eps_decode_lcs_client_identity() 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__) | | ------------------ ------------------ 3021| 14| return size; 3022| 14| } 3023| | 3024| 481| cs_service_notification->presencemask |= OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_CLIENT_IDENTITY_PRESENT; ------------------ | | 1030| 481|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_CLIENT_IDENTITY_PRESENT ((uint64_t)1<<3) ------------------ 3025| 481| decoded += size; 3026| 481| break; 3027| 3.12k| default: ------------------ | Branch (3027:9): [True: 3.12k, False: 1.55k] ------------------ 3028| 3.12k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 3.12k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.12k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.12k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.12k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.12k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.12k| 0, __VA_ARGS__) | | ------------------ ------------------ 3029| 3.12k| break; 3030| 4.68k| } 3031| 4.68k| } 3032| | 3033| 75| return decoded; 3034| 112|} ogs_nas_eps_decode_uplink_generic_nas_transport: 3037| 88|{ 3038| 88| ogs_nas_eps_uplink_generic_nas_transport_t *uplink_generic_nas_transport = &message->emm.uplink_generic_nas_transport; 3039| 88| int decoded = 0; 3040| 88| int size = 0; 3041| | 3042| 88| ogs_trace("[NAS] Decode UPLINK_GENERIC_NAS_TRANSPORT\n"); ------------------ | | 40| 88|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 88| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 88|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 88| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 88|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 88| 0, __VA_ARGS__) | | ------------------ ------------------ 3043| | 3044| 88| size = ogs_nas_eps_decode_generic_message_container_type(&uplink_generic_nas_transport->generic_message_container_type, pkbuf); 3045| 88| if (size < 0) { ------------------ | Branch (3045:9): [True: 0, False: 88] ------------------ 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| 88| decoded += size; 3051| | 3052| 88| size = ogs_nas_eps_decode_generic_message_container(&uplink_generic_nas_transport->generic_message_container, pkbuf); 3053| 88| if (size < 0) { ------------------ | Branch (3053:9): [True: 16, False: 72] ------------------ 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| 72| decoded += size; 3059| | 3060| 3.27k| while (pkbuf->len > 0) { ------------------ | Branch (3060:12): [True: 3.20k, False: 68] ------------------ 3061| 3.20k| uint8_t *buffer = pkbuf->data; 3062| 3.20k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (3062:24): [True: 1.23k, False: 1.97k] ------------------ 3063| | 3064| 3.20k| size = sizeof(uint8_t); 3065| 3.20k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3065:13): [True: 0, False: 3.20k] ------------------ 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| 3.20k| decoded += size; 3070| | 3071| 3.20k| switch (type) { 3072| 367| case OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_TYPE: ------------------ | | 1053| 367|#define OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_TYPE 0x65 ------------------ | Branch (3072:9): [True: 367, False: 2.83k] ------------------ 3073| 367| size = ogs_nas_eps_decode_additional_information(&uplink_generic_nas_transport->additional_information, pkbuf); 3074| 367| if (size < 0) { ------------------ | Branch (3074:17): [True: 4, False: 363] ------------------ 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| 363| uplink_generic_nas_transport->presencemask |= OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_PRESENT; ------------------ | | 1052| 363|#define OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_PRESENT ((uint64_t)1<<0) ------------------ 3080| 363| decoded += size; 3081| 363| break; 3082| 2.83k| default: ------------------ | Branch (3082:9): [True: 2.83k, False: 367] ------------------ 3083| 2.83k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 2.83k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.83k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.83k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.83k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.83k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.83k| 0, __VA_ARGS__) | | ------------------ ------------------ 3084| 2.83k| break; 3085| 3.20k| } 3086| 3.20k| } 3087| | 3088| 68| return decoded; 3089| 72|} ogs_nas_eps_decode_downlink_generic_nas_transport: 3092| 84|{ 3093| 84| ogs_nas_eps_downlink_generic_nas_transport_t *downlink_generic_nas_transport = &message->emm.downlink_generic_nas_transport; 3094| 84| int decoded = 0; 3095| 84| int size = 0; 3096| | 3097| 84| ogs_trace("[NAS] Decode DOWNLINK_GENERIC_NAS_TRANSPORT\n"); ------------------ | | 40| 84|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 84| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 84|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 84| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 84|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 84| 0, __VA_ARGS__) | | ------------------ ------------------ 3098| | 3099| 84| size = ogs_nas_eps_decode_generic_message_container_type(&downlink_generic_nas_transport->generic_message_container_type, pkbuf); 3100| 84| if (size < 0) { ------------------ | Branch (3100:9): [True: 0, False: 84] ------------------ 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| 84| decoded += size; 3106| | 3107| 84| size = ogs_nas_eps_decode_generic_message_container(&downlink_generic_nas_transport->generic_message_container, pkbuf); 3108| 84| if (size < 0) { ------------------ | Branch (3108:9): [True: 10, False: 74] ------------------ 3109| 10| ogs_error("ogs_nas_eps_decode_generic_message_container() 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__) | | ------------------ ------------------ 3110| 10| return size; 3111| 10| } 3112| | 3113| 74| decoded += size; 3114| | 3115| 2.73k| while (pkbuf->len > 0) { ------------------ | Branch (3115:12): [True: 2.67k, False: 68] ------------------ 3116| 2.67k| uint8_t *buffer = pkbuf->data; 3117| 2.67k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (3117:24): [True: 1.15k, False: 1.51k] ------------------ 3118| | 3119| 2.67k| size = sizeof(uint8_t); 3120| 2.67k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3120:13): [True: 0, False: 2.67k] ------------------ 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| 2.67k| decoded += size; 3125| | 3126| 2.67k| switch (type) { 3127| 246| case OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_TYPE: ------------------ | | 1070| 246|#define OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_TYPE 0x65 ------------------ | Branch (3127:9): [True: 246, False: 2.42k] ------------------ 3128| 246| size = ogs_nas_eps_decode_additional_information(&downlink_generic_nas_transport->additional_information, pkbuf); 3129| 246| if (size < 0) { ------------------ | Branch (3129:17): [True: 6, False: 240] ------------------ 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| 240| downlink_generic_nas_transport->presencemask |= OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_PRESENT; ------------------ | | 1069| 240|#define OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_PRESENT ((uint64_t)1<<0) ------------------ 3135| 240| decoded += size; 3136| 240| break; 3137| 2.42k| default: ------------------ | Branch (3137:9): [True: 2.42k, False: 246] ------------------ 3138| 2.42k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 2.42k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.42k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.42k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.42k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.42k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.42k| 0, __VA_ARGS__) | | ------------------ ------------------ 3139| 2.42k| break; 3140| 2.67k| } 3141| 2.67k| } 3142| | 3143| 68| return decoded; 3144| 74|} ogs_nas_emm_decode: 4990| 3.94k|{ 4991| 3.94k| int size = 0; 4992| 3.94k| int decoded = 0; 4993| | 4994| 3.94k| ogs_assert(pkbuf); ------------------ | | 113| 3.94k| do { \ | | 114| 3.94k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.94k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.94k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.94k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.94k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.94k] | | ------------------ ------------------ 4995| 3.94k| ogs_assert(pkbuf->data); ------------------ | | 113| 3.94k| do { \ | | 114| 3.94k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.94k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.94k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.94k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.94k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.94k] | | ------------------ ------------------ 4996| | 4997| 3.94k| size = sizeof(ogs_nas_emm_header_t); 4998| 3.94k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (4998:9): [True: 0, False: 3.94k] ------------------ 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.94k| memset(message, 0, sizeof(ogs_nas_eps_message_t)); 5004| 3.94k| memcpy(&message->emm.h, pkbuf->data - size, size); 5005| 3.94k| decoded += size; 5006| | 5007| 3.94k| if (message->emm.h.security_header_type >= ------------------ | Branch (5007:9): [True: 13, False: 3.92k] ------------------ 5008| 3.94k| OGS_NAS_SECURITY_HEADER_FOR_SERVICE_REQUEST_MESSAGE) { ------------------ | | 43| 3.94k|#define OGS_NAS_SECURITY_HEADER_FOR_SERVICE_REQUEST_MESSAGE 12 ------------------ 5009| 13| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 13| do { \ | | 114| 13| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 13|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 13, False: 0] | | | | ------------------ | | ------------------ | | 115| 13| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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| 13| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 13] | | ------------------ ------------------ 5010| 13| decoded -= 1; 5011| 13| size = ogs_nas_eps_decode_service_request(message, pkbuf); 5012| 13| if (size < 0) { ------------------ | Branch (5012:13): [True: 0, False: 13] ------------------ 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| 13| decoded += size; 5017| | 5018| 13| goto out; 5019| 13| } 5020| | 5021| 3.92k| switch (message->emm.h.message_type) { 5022| 348| case OGS_NAS_EPS_ATTACH_REQUEST: ------------------ | | 71| 348|#define OGS_NAS_EPS_ATTACH_REQUEST 65 ------------------ | Branch (5022:5): [True: 348, False: 3.57k] ------------------ 5023| 348| size = ogs_nas_eps_decode_attach_request(message, pkbuf); 5024| 348| if (size < 0) { ------------------ | Branch (5024:13): [True: 45, False: 303] ------------------ 5025| 45| ogs_error("ogs_nas_eps_decode_attach_request() failed"); ------------------ | | 36| 45|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 45| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 45|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 45| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 45|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 45| 0, __VA_ARGS__) | | ------------------ ------------------ 5026| 45| return OGS_ERROR; ------------------ | | 78| 45|#define OGS_ERROR -1 ------------------ 5027| 45| } 5028| | 5029| 303| decoded += size; 5030| 303| break; 5031| 435| case OGS_NAS_EPS_ATTACH_ACCEPT: ------------------ | | 72| 435|#define OGS_NAS_EPS_ATTACH_ACCEPT 66 ------------------ | Branch (5031:5): [True: 435, False: 3.49k] ------------------ 5032| 435| size = ogs_nas_eps_decode_attach_accept(message, pkbuf); 5033| 435| if (size < 0) { ------------------ | Branch (5033:13): [True: 44, False: 391] ------------------ 5034| 44| ogs_error("ogs_nas_eps_decode_attach_accept() failed"); ------------------ | | 36| 44|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 44| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 44|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 44| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 44|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 44| 0, __VA_ARGS__) | | ------------------ ------------------ 5035| 44| return OGS_ERROR; ------------------ | | 78| 44|#define OGS_ERROR -1 ------------------ 5036| 44| } 5037| | 5038| 391| decoded += size; 5039| 391| break; 5040| 39| case OGS_NAS_EPS_ATTACH_COMPLETE: ------------------ | | 73| 39|#define OGS_NAS_EPS_ATTACH_COMPLETE 67 ------------------ | Branch (5040:5): [True: 39, False: 3.88k] ------------------ 5041| 39| size = ogs_nas_eps_decode_attach_complete(message, pkbuf); 5042| 39| if (size < 0) { ------------------ | Branch (5042:13): [True: 19, False: 20] ------------------ 5043| 19| ogs_error("ogs_nas_eps_decode_attach_complete() failed"); ------------------ | | 36| 19|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 19| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 19|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 19| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 19|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 19| 0, __VA_ARGS__) | | ------------------ ------------------ 5044| 19| return OGS_ERROR; ------------------ | | 78| 19|#define OGS_ERROR -1 ------------------ 5045| 19| } 5046| | 5047| 20| decoded += size; 5048| 20| break; 5049| 164| case OGS_NAS_EPS_ATTACH_REJECT: ------------------ | | 74| 164|#define OGS_NAS_EPS_ATTACH_REJECT 68 ------------------ | Branch (5049:5): [True: 164, False: 3.76k] ------------------ 5050| 164| size = ogs_nas_eps_decode_attach_reject(message, pkbuf); 5051| 164| if (size < 0) { ------------------ | Branch (5051:13): [True: 29, False: 135] ------------------ 5052| 29| ogs_error("ogs_nas_eps_decode_attach_reject() 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__) | | ------------------ ------------------ 5053| 29| return OGS_ERROR; ------------------ | | 78| 29|#define OGS_ERROR -1 ------------------ 5054| 29| } 5055| | 5056| 135| decoded += size; 5057| 135| break; 5058| 8| case OGS_NAS_EPS_DETACH_REQUEST: ------------------ | | 75| 8|#define OGS_NAS_EPS_DETACH_REQUEST 69 ------------------ | Branch (5058:5): [True: 8, False: 3.91k] ------------------ 5059| 8| size = ogs_nas_eps_decode_detach_request_from_ue(message, pkbuf); 5060| 8| if (size < 0) { ------------------ | Branch (5060:13): [True: 2, False: 6] ------------------ 5061| 2| ogs_error("ogs_nas_eps_decode_detach_request_from_ue() 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__) | | ------------------ ------------------ 5062| 2| return OGS_ERROR; ------------------ | | 78| 2|#define OGS_ERROR -1 ------------------ 5063| 2| } 5064| | 5065| 6| decoded += size; 5066| 6| 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.92k] ------------------ 5068| 1| break; 5069| 689| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST: ------------------ | | 77| 689|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST 72 ------------------ | Branch (5069:5): [True: 689, False: 3.23k] ------------------ 5070| 689| size = ogs_nas_eps_decode_tracking_area_update_request(message, pkbuf); 5071| 689| if (size < 0) { ------------------ | Branch (5071:13): [True: 199, False: 490] ------------------ 5072| 199| ogs_error("ogs_nas_eps_decode_tracking_area_update_request() failed"); ------------------ | | 36| 199|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 199| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 199|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 199| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 199|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 199| 0, __VA_ARGS__) | | ------------------ ------------------ 5073| 199| return OGS_ERROR; ------------------ | | 78| 199|#define OGS_ERROR -1 ------------------ 5074| 199| } 5075| | 5076| 490| decoded += size; 5077| 490| break; 5078| 810| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT: ------------------ | | 78| 810|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT 73 ------------------ | Branch (5078:5): [True: 810, False: 3.11k] ------------------ 5079| 810| size = ogs_nas_eps_decode_tracking_area_update_accept(message, pkbuf); 5080| 810| if (size < 0) { ------------------ | Branch (5080:13): [True: 275, False: 535] ------------------ 5081| 275| ogs_error("ogs_nas_eps_decode_tracking_area_update_accept() failed"); ------------------ | | 36| 275|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 275| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 275|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 275| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 275|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 275| 0, __VA_ARGS__) | | ------------------ ------------------ 5082| 275| return OGS_ERROR; ------------------ | | 78| 275|#define OGS_ERROR -1 ------------------ 5083| 275| } 5084| | 5085| 535| decoded += size; 5086| 535| 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.92k] ------------------ 5088| 1| break; 5089| 145| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT: ------------------ | | 80| 145|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT 75 ------------------ | Branch (5089:5): [True: 145, False: 3.78k] ------------------ 5090| 145| size = ogs_nas_eps_decode_tracking_area_update_reject(message, pkbuf); 5091| 145| if (size < 0) { ------------------ | Branch (5091:13): [True: 24, False: 121] ------------------ 5092| 24| ogs_error("ogs_nas_eps_decode_tracking_area_update_reject() failed"); ------------------ | | 36| 24|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 24| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 24|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 24| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 24|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 24| 0, __VA_ARGS__) | | ------------------ ------------------ 5093| 24| return OGS_ERROR; ------------------ | | 78| 24|#define OGS_ERROR -1 ------------------ 5094| 24| } 5095| | 5096| 121| decoded += size; 5097| 121| break; 5098| 122| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST: ------------------ | | 81| 122|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST 76 ------------------ | Branch (5098:5): [True: 122, False: 3.80k] ------------------ 5099| 122| size = ogs_nas_eps_decode_extended_service_request(message, pkbuf); 5100| 122| if (size < 0) { ------------------ | Branch (5100:13): [True: 19, False: 103] ------------------ 5101| 19| ogs_error("ogs_nas_eps_decode_extended_service_request() failed"); ------------------ | | 36| 19|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 19| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 19|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 19| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 19|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 19| 0, __VA_ARGS__) | | ------------------ ------------------ 5102| 19| return OGS_ERROR; ------------------ | | 78| 19|#define OGS_ERROR -1 ------------------ 5103| 19| } 5104| | 5105| 103| decoded += size; 5106| 103| break; 5107| 134| case OGS_NAS_EPS_SERVICE_REJECT: ------------------ | | 82| 134|#define OGS_NAS_EPS_SERVICE_REJECT 78 ------------------ | Branch (5107:5): [True: 134, False: 3.79k] ------------------ 5108| 134| size = ogs_nas_eps_decode_service_reject(message, pkbuf); 5109| 134| if (size < 0) { ------------------ | Branch (5109:13): [True: 20, False: 114] ------------------ 5110| 20| ogs_error("ogs_nas_eps_decode_service_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__) | | ------------------ ------------------ 5111| 20| return OGS_ERROR; ------------------ | | 78| 20|#define OGS_ERROR -1 ------------------ 5112| 20| } 5113| | 5114| 114| decoded += size; 5115| 114| break; 5116| 110| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND: ------------------ | | 83| 110|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND 80 ------------------ | Branch (5116:5): [True: 110, False: 3.81k] ------------------ 5117| 110| size = ogs_nas_eps_decode_guti_reallocation_command(message, pkbuf); 5118| 110| if (size < 0) { ------------------ | Branch (5118:13): [True: 16, False: 94] ------------------ 5119| 16| ogs_error("ogs_nas_eps_decode_guti_reallocation_command() 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__) | | ------------------ ------------------ 5120| 16| return OGS_ERROR; ------------------ | | 78| 16|#define OGS_ERROR -1 ------------------ 5121| 16| } 5122| | 5123| 94| decoded += size; 5124| 94| 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.92k] ------------------ 5126| 1| break; 5127| 26| case OGS_NAS_EPS_AUTHENTICATION_REQUEST: ------------------ | | 85| 26|#define OGS_NAS_EPS_AUTHENTICATION_REQUEST 82 ------------------ | Branch (5127:5): [True: 26, False: 3.90k] ------------------ 5128| 26| size = ogs_nas_eps_decode_authentication_request(message, pkbuf); 5129| 26| if (size < 0) { ------------------ | Branch (5129:13): [True: 14, False: 12] ------------------ 5130| 14| ogs_error("ogs_nas_eps_decode_authentication_request() 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__) | | ------------------ ------------------ 5131| 14| return OGS_ERROR; ------------------ | | 78| 14|#define OGS_ERROR -1 ------------------ 5132| 14| } 5133| | 5134| 12| decoded += size; 5135| 12| break; 5136| 26| case OGS_NAS_EPS_AUTHENTICATION_RESPONSE: ------------------ | | 86| 26|#define OGS_NAS_EPS_AUTHENTICATION_RESPONSE 83 ------------------ | Branch (5136:5): [True: 26, False: 3.90k] ------------------ 5137| 26| size = ogs_nas_eps_decode_authentication_response(message, pkbuf); 5138| 26| if (size < 0) { ------------------ | Branch (5138:13): [True: 4, False: 22] ------------------ 5139| 4| ogs_error("ogs_nas_eps_decode_authentication_response() 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__) | | ------------------ ------------------ 5140| 4| return OGS_ERROR; ------------------ | | 78| 4|#define OGS_ERROR -1 ------------------ 5141| 4| } 5142| | 5143| 22| decoded += size; 5144| 22| 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.92k] ------------------ 5146| 1| break; 5147| 10| case OGS_NAS_EPS_IDENTITY_REQUEST: ------------------ | | 88| 10|#define OGS_NAS_EPS_IDENTITY_REQUEST 85 ------------------ | Branch (5147:5): [True: 10, False: 3.91k] ------------------ 5148| 10| size = ogs_nas_eps_decode_identity_request(message, pkbuf); 5149| 10| if (size < 0) { ------------------ | Branch (5149:13): [True: 0, False: 10] ------------------ 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| 10| decoded += size; 5155| 10| break; 5156| 23| case OGS_NAS_EPS_IDENTITY_RESPONSE: ------------------ | | 89| 23|#define OGS_NAS_EPS_IDENTITY_RESPONSE 86 ------------------ | Branch (5156:5): [True: 23, False: 3.90k] ------------------ 5157| 23| size = ogs_nas_eps_decode_identity_response(message, pkbuf); 5158| 23| if (size < 0) { ------------------ | Branch (5158:13): [True: 4, False: 19] ------------------ 5159| 4| ogs_error("ogs_nas_eps_decode_identity_response() 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__) | | ------------------ ------------------ 5160| 4| return OGS_ERROR; ------------------ | | 78| 4|#define OGS_ERROR -1 ------------------ 5161| 4| } 5162| | 5163| 19| decoded += size; 5164| 19| break; 5165| 69| case OGS_NAS_EPS_AUTHENTICATION_FAILURE: ------------------ | | 90| 69|#define OGS_NAS_EPS_AUTHENTICATION_FAILURE 92 ------------------ | Branch (5165:5): [True: 69, False: 3.85k] ------------------ 5166| 69| size = ogs_nas_eps_decode_authentication_failure(message, pkbuf); 5167| 69| if (size < 0) { ------------------ | Branch (5167:13): [True: 19, False: 50] ------------------ 5168| 19| ogs_error("ogs_nas_eps_decode_authentication_failure() failed"); ------------------ | | 36| 19|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 19| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 19|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 19| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 19|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 19| 0, __VA_ARGS__) | | ------------------ ------------------ 5169| 19| return OGS_ERROR; ------------------ | | 78| 19|#define OGS_ERROR -1 ------------------ 5170| 19| } 5171| | 5172| 50| decoded += size; 5173| 50| break; 5174| 120| case OGS_NAS_EPS_SECURITY_MODE_COMMAND: ------------------ | | 91| 120|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND 93 ------------------ | Branch (5174:5): [True: 120, False: 3.80k] ------------------ 5175| 120| size = ogs_nas_eps_decode_security_mode_command(message, pkbuf); 5176| 120| if (size < 0) { ------------------ | Branch (5176:13): [True: 25, False: 95] ------------------ 5177| 25| ogs_error("ogs_nas_eps_decode_security_mode_command() failed"); ------------------ | | 36| 25|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 25| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 25|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 25| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 25|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 25| 0, __VA_ARGS__) | | ------------------ ------------------ 5178| 25| return OGS_ERROR; ------------------ | | 78| 25|#define OGS_ERROR -1 ------------------ 5179| 25| } 5180| | 5181| 95| decoded += size; 5182| 95| break; 5183| 164| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE: ------------------ | | 92| 164|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE 94 ------------------ | Branch (5183:5): [True: 164, False: 3.76k] ------------------ 5184| 164| size = ogs_nas_eps_decode_security_mode_complete(message, pkbuf); 5185| 164| if (size < 0) { ------------------ | Branch (5185:13): [True: 61, False: 103] ------------------ 5186| 61| ogs_error("ogs_nas_eps_decode_security_mode_complete() failed"); ------------------ | | 36| 61|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 61| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 61|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 61| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 61|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 61| 0, __VA_ARGS__) | | ------------------ ------------------ 5187| 61| return OGS_ERROR; ------------------ | | 78| 61|#define OGS_ERROR -1 ------------------ 5188| 61| } 5189| | 5190| 103| decoded += size; 5191| 103| 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.92k] ------------------ 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.92k] ------------------ 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| 132| case OGS_NAS_EPS_EMM_INFORMATION: ------------------ | | 95| 132|#define OGS_NAS_EPS_EMM_INFORMATION 97 ------------------ | Branch (5210:5): [True: 132, False: 3.79k] ------------------ 5211| 132| size = ogs_nas_eps_decode_emm_information(message, pkbuf); 5212| 132| if (size < 0) { ------------------ | Branch (5212:13): [True: 41, False: 91] ------------------ 5213| 41| ogs_error("ogs_nas_eps_decode_emm_information() failed"); ------------------ | | 36| 41|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 41| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 41|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 41| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 41|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 41| 0, __VA_ARGS__) | | ------------------ ------------------ 5214| 41| return OGS_ERROR; ------------------ | | 78| 41|#define OGS_ERROR -1 ------------------ 5215| 41| } 5216| | 5217| 91| decoded += size; 5218| 91| 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.89k] ------------------ 5220| 32| size = ogs_nas_eps_decode_downlink_nas_transport(message, pkbuf); 5221| 32| if (size < 0) { ------------------ | Branch (5221:13): [True: 3, False: 29] ------------------ 5222| 3| ogs_error("ogs_nas_eps_decode_downlink_nas_transport() 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__) | | ------------------ ------------------ 5223| 3| return OGS_ERROR; ------------------ | | 78| 3|#define OGS_ERROR -1 ------------------ 5224| 3| } 5225| | 5226| 29| decoded += size; 5227| 29| break; 5228| 30| case OGS_NAS_EPS_UPLINK_NAS_TRANSPORT: ------------------ | | 97| 30|#define OGS_NAS_EPS_UPLINK_NAS_TRANSPORT 99 ------------------ | Branch (5228:5): [True: 30, False: 3.89k] ------------------ 5229| 30| size = ogs_nas_eps_decode_uplink_nas_transport(message, pkbuf); 5230| 30| if (size < 0) { ------------------ | Branch (5230:13): [True: 7, False: 23] ------------------ 5231| 7| ogs_error("ogs_nas_eps_decode_uplink_nas_transport() 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__) | | ------------------ ------------------ 5232| 7| return OGS_ERROR; ------------------ | | 78| 7|#define OGS_ERROR -1 ------------------ 5233| 7| } 5234| | 5235| 23| decoded += size; 5236| 23| break; 5237| 112| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION: ------------------ | | 98| 112|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION 100 ------------------ | Branch (5237:5): [True: 112, False: 3.81k] ------------------ 5238| 112| size = ogs_nas_eps_decode_cs_service_notification(message, pkbuf); 5239| 112| if (size < 0) { ------------------ | Branch (5239:13): [True: 37, False: 75] ------------------ 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| 75| decoded += size; 5245| 75| break; 5246| 88| case OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT: ------------------ | | 99| 88|#define OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT 101 ------------------ | Branch (5246:5): [True: 88, False: 3.83k] ------------------ 5247| 88| size = ogs_nas_eps_decode_uplink_generic_nas_transport(message, pkbuf); 5248| 88| if (size < 0) { ------------------ | Branch (5248:13): [True: 20, False: 68] ------------------ 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| 68| decoded += size; 5254| 68| break; 5255| 84| case OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT: ------------------ | | 100| 84|#define OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT 104 ------------------ | Branch (5255:5): [True: 84, False: 3.84k] ------------------ 5256| 84| size = ogs_nas_eps_decode_downlink_generic_nas_transport(message, pkbuf); 5257| 84| if (size < 0) { ------------------ | Branch (5257:13): [True: 16, False: 68] ------------------ 5258| 16| ogs_error("ogs_nas_eps_decode_downlink_generic_nas_transport() 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__) | | ------------------ ------------------ 5259| 16| return OGS_ERROR; ------------------ | | 78| 16|#define OGS_ERROR -1 ------------------ 5260| 16| } 5261| | 5262| 68| decoded += size; 5263| 68| break; 5264| 1| default: ------------------ | Branch (5264:5): [True: 1, False: 3.92k] ------------------ 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.92k| } 5269| | 5270| 2.99k|out: 5271| 2.99k| ogs_assert(ogs_pkbuf_push(pkbuf, decoded)); ------------------ | | 113| 2.99k| do { \ | | 114| 2.99k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.99k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.99k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.99k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.99k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.99k] | | ------------------ ------------------ 5272| | 5273| 2.99k| return OGS_OK; ------------------ | | 77| 2.99k|#define OGS_OK 0 ------------------ 5274| 2.99k|} ogs_nas_eps_decode_list_of_plmns_to_be_used_in_disaster_condition: 49| 564|{ 50| 564| int size = 0; 51| 564| ogs_nas_list_of_plmns_to_be_used_in_disaster_condition_t *source = NULL; 52| | 53| 564| if (pkbuf->len < 1) { ------------------ | Branch (53:9): [True: 5, False: 559] ------------------ 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| 559| source = (ogs_nas_list_of_plmns_to_be_used_in_disaster_condition_t *)pkbuf->data; 59| | 60| 559| list_of_plmns_to_be_used_in_disaster_condition->length = source->length; 61| 559| size = list_of_plmns_to_be_used_in_disaster_condition->length + sizeof(list_of_plmns_to_be_used_in_disaster_condition->length); 62| | 63| 559| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (63:9): [True: 2, False: 557] ------------------ 64| 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__) | | ------------------ ------------------ 65| 2| return -1; 66| 2| } 67| | 68| 557| if (sizeof(*list_of_plmns_to_be_used_in_disaster_condition) < size) return -1; ------------------ | Branch (68:9): [True: 3, False: 554] ------------------ 69| 554| memcpy(list_of_plmns_to_be_used_in_disaster_condition, pkbuf->data - size, size); 70| | 71| 554| ogs_trace(" LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION - "); ------------------ | | 40| 554|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 554| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 554|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 554| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 554|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 554| 0, __VA_ARGS__) | | ------------------ ------------------ 72| 554| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 554| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 554|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 73| | 74| 554| return size; 75| 557|} ogs_nas_eps_decode_additional_information: 95| 613|{ 96| 613| int size = 0; 97| 613| ogs_nas_additional_information_t *source = NULL; 98| | 99| 613| if (pkbuf->len < 1) { ------------------ | Branch (99:9): [True: 7, False: 606] ------------------ 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| 606| source = (ogs_nas_additional_information_t *)pkbuf->data; 105| | 106| 606| additional_information->length = source->length; 107| 606| size = additional_information->length + sizeof(additional_information->length); 108| | 109| 606| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (109:9): [True: 3, False: 603] ------------------ 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| 603| if (sizeof(*additional_information) < size) return -1; ------------------ | Branch (114:9): [True: 0, False: 603] ------------------ 115| 603| memcpy(additional_information, pkbuf->data - size, size); 116| | 117| 603| ogs_trace(" ADDITIONAL_INFORMATION - "); ------------------ | | 40| 603|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 603| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 603|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 603| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 603|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 603| 0, __VA_ARGS__) | | ------------------ ------------------ 118| 603| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 603| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 603|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 119| | 120| 603| return size; 121| 603|} ogs_nas_eps_decode_device_properties: 141| 3.38k|{ 142| 3.38k| int size = sizeof(ogs_nas_device_properties_t); 143| | 144| 3.38k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (144:9): [True: 0, False: 3.38k] ------------------ 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| 3.38k| memcpy(device_properties, pkbuf->data - size, size); 150| | 151| 3.38k| ogs_trace(" DEVICE_PROPERTIES - "); ------------------ | | 40| 3.38k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.38k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.38k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.38k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.38k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.38k| 0, __VA_ARGS__) | | ------------------ ------------------ 152| 3.38k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 3.38k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 3.38k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 153| | 154| 3.38k| return size; 155| 3.38k|} ogs_nas_eps_decode_eps_bearer_context_status: 173| 1.11k|{ 174| 1.11k| int size = 0; 175| 1.11k| ogs_nas_eps_bearer_context_status_t *source = NULL; 176| | 177| 1.11k| if (pkbuf->len < 1) { ------------------ | Branch (177:9): [True: 10, False: 1.10k] ------------------ 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| 1.10k| source = (ogs_nas_eps_bearer_context_status_t *)pkbuf->data; 183| | 184| 1.10k| eps_bearer_context_status->length = source->length; 185| 1.10k| size = eps_bearer_context_status->length + sizeof(eps_bearer_context_status->length); 186| | 187| 1.10k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (187:9): [True: 8, False: 1.09k] ------------------ 188| 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__) | | ------------------ ------------------ 189| 8| return -1; 190| 8| } 191| | 192| 1.09k| if (sizeof(*eps_bearer_context_status) < size) return -1; ------------------ | Branch (192:9): [True: 3, False: 1.09k] ------------------ 193| 1.09k| memcpy(eps_bearer_context_status, pkbuf->data - size, size); 194| | 195| 1.09k| ogs_trace(" EPS_BEARER_CONTEXT_STATUS - "); ------------------ | | 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__) | | ------------------ ------------------ 196| 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 | | ------------------ ------------------ 197| | 198| 1.09k| return size; 199| 1.09k|} ogs_nas_eps_decode_supported_codec_list: 219| 513|{ 220| 513| int size = 0; 221| 513| ogs_nas_supported_codec_list_t *source = NULL; 222| | 223| 513| if (pkbuf->len < 1) { ------------------ | Branch (223:9): [True: 4, False: 509] ------------------ 224| 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__) | | ------------------ ------------------ 225| 4| return -1; 226| 4| } 227| | 228| 509| source = (ogs_nas_supported_codec_list_t *)pkbuf->data; 229| | 230| 509| supported_codec_list->length = source->length; 231| 509| size = supported_codec_list->length + sizeof(supported_codec_list->length); 232| | 233| 509| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (233:9): [True: 1, False: 508] ------------------ 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| 508| if (sizeof(*supported_codec_list) < size) return -1; ------------------ | Branch (238:9): [True: 1, False: 507] ------------------ 239| 507| memcpy(supported_codec_list, pkbuf->data - size, size); 240| | 241| 507| ogs_trace(" SUPPORTED_CODEC_LIST - "); ------------------ | | 40| 507|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 507| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 507|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 507| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 507|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 507| 0, __VA_ARGS__) | | ------------------ ------------------ 242| 507| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 507| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 507|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 243| | 244| 507| return size; 245| 508|} ogs_nas_eps_decode_location_area_identification: 265| 1.36k|{ 266| 1.36k| int size = sizeof(ogs_nas_location_area_identification_t); 267| | 268| 1.36k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (268:9): [True: 12, False: 1.34k] ------------------ 269| 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__) | | ------------------ ------------------ 270| 12| return -1; 271| 12| } 272| | 273| 1.34k| memcpy(location_area_identification, pkbuf->data - size, size); 274| | 275| 1.34k| location_area_identification->lac = be16toh(location_area_identification->lac); 276| | 277| 1.34k| ogs_trace(" LOCATION_AREA_IDENTIFICATION - "); ------------------ | | 40| 1.34k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.34k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.34k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.34k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.34k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.34k| 0, __VA_ARGS__) | | ------------------ ------------------ 278| 1.34k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.34k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.34k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 279| | 280| 1.34k| return size; 281| 1.36k|} ogs_nas_eps_decode_mobile_identity: 303| 1.43k|{ 304| 1.43k| int size = 0; 305| 1.43k| ogs_nas_mobile_identity_t *source = NULL; 306| | 307| 1.43k| if (pkbuf->len < 1) { ------------------ | Branch (307:9): [True: 9, False: 1.42k] ------------------ 308| 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__) | | ------------------ ------------------ 309| 9| return -1; 310| 9| } 311| | 312| 1.42k| source = (ogs_nas_mobile_identity_t *)pkbuf->data; 313| | 314| 1.42k| mobile_identity->length = source->length; 315| 1.42k| size = mobile_identity->length + sizeof(mobile_identity->length); 316| | 317| 1.42k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (317:9): [True: 10, False: 1.41k] ------------------ 318| 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__) | | ------------------ ------------------ 319| 10| return -1; 320| 10| } 321| | 322| 1.41k| if (sizeof(*mobile_identity) < size) return -1; ------------------ | Branch (322:9): [True: 1, False: 1.41k] ------------------ 323| 1.41k| memcpy(mobile_identity, pkbuf->data - size, size); 324| | 325| 1.41k| if (mobile_identity->tmsi.type == OGS_NAS_MOBILE_IDENTITY_TMSI) { ------------------ | | 74| 1.41k|#define OGS_NAS_MOBILE_IDENTITY_TMSI 4 ------------------ | Branch (325:9): [True: 200, False: 1.21k] ------------------ 326| 200| mobile_identity->tmsi.tmsi = be32toh(mobile_identity->tmsi.tmsi); 327| 200| } 328| | 329| 1.41k| ogs_trace(" MOBILE_IDENTITY - "); ------------------ | | 40| 1.41k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.41k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.41k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.41k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.41k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.41k| 0, __VA_ARGS__) | | ------------------ ------------------ 330| 1.41k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.41k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.41k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 331| | 332| 1.41k| return size; 333| 1.41k|} ogs_nas_eps_decode_mobile_station_classmark_2: 358| 425|{ 359| 425| int size = 0; 360| 425| ogs_nas_mobile_station_classmark_2_t *source = NULL; 361| | 362| 425| if (pkbuf->len < 1) { ------------------ | Branch (362:9): [True: 3, False: 422] ------------------ 363| 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__) | | ------------------ ------------------ 364| 3| return -1; 365| 3| } 366| | 367| 422| source = (ogs_nas_mobile_station_classmark_2_t *)pkbuf->data; 368| | 369| 422| mobile_station_classmark_2->length = source->length; 370| 422| size = mobile_station_classmark_2->length + sizeof(mobile_station_classmark_2->length); 371| | 372| 422| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (372:9): [True: 1, False: 421] ------------------ 373| 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__) | | ------------------ ------------------ 374| 1| return -1; 375| 1| } 376| | 377| 421| if (sizeof(*mobile_station_classmark_2) < size) return -1; ------------------ | Branch (377:9): [True: 1, False: 420] ------------------ 378| 420| memcpy(mobile_station_classmark_2, pkbuf->data - size, size); 379| | 380| 420| ogs_trace(" MOBILE_STATION_CLASSMARK_2 - "); ------------------ | | 40| 420|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 420| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 420|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 420| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 420|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 420| 0, __VA_ARGS__) | | ------------------ ------------------ 381| 420| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 420| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 420|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 382| | 383| 420| return size; 384| 421|} ogs_nas_eps_decode_mobile_station_classmark_3: 404| 521|{ 405| 521| int size = 0; 406| 521| ogs_nas_mobile_station_classmark_3_t *source = NULL; 407| | 408| 521| if (pkbuf->len < 1) { ------------------ | Branch (408:9): [True: 6, False: 515] ------------------ 409| 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__) | | ------------------ ------------------ 410| 6| return -1; 411| 6| } 412| | 413| 515| source = (ogs_nas_mobile_station_classmark_3_t *)pkbuf->data; 414| | 415| 515| mobile_station_classmark_3->length = source->length; 416| 515| size = mobile_station_classmark_3->length + sizeof(mobile_station_classmark_3->length); 417| | 418| 515| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (418:9): [True: 2, False: 513] ------------------ 419| 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__) | | ------------------ ------------------ 420| 2| return -1; 421| 2| } 422| | 423| 513| if (sizeof(*mobile_station_classmark_3) < size) return -1; ------------------ | Branch (423:9): [True: 1, False: 512] ------------------ 424| 512| memcpy(mobile_station_classmark_3, pkbuf->data - size, size); 425| | 426| 512| ogs_trace(" MOBILE_STATION_CLASSMARK_3 - "); ------------------ | | 40| 512|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 512| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 512|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 512| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 512|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 512| 0, __VA_ARGS__) | | ------------------ ------------------ 427| 512| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 512| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 512|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 428| | 429| 512| return size; 430| 513|} ogs_nas_eps_decode_plmn_list: 450| 709|{ 451| 709| int size = 0; 452| 709| ogs_nas_plmn_list_t *source = NULL; 453| | 454| 709| if (pkbuf->len < 1) { ------------------ | Branch (454:9): [True: 8, False: 701] ------------------ 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| 701| source = (ogs_nas_plmn_list_t *)pkbuf->data; 460| | 461| 701| plmn_list->length = source->length; 462| 701| size = plmn_list->length + sizeof(plmn_list->length); 463| | 464| 701| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (464:9): [True: 6, False: 695] ------------------ 465| 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__) | | ------------------ ------------------ 466| 6| return -1; 467| 6| } 468| | 469| 695| if (sizeof(*plmn_list) < size) return -1; ------------------ | Branch (469:9): [True: 3, False: 692] ------------------ 470| 692| memcpy(plmn_list, pkbuf->data - size, size); 471| | 472| 692| ogs_trace(" PLMN_LIST - "); ------------------ | | 40| 692|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 692| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 692|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 692| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 692|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 692| 0, __VA_ARGS__) | | ------------------ ------------------ 473| 692| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 692| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 692|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 474| | 475| 692| return size; 476| 695|} ogs_nas_eps_decode_additional_update_result: 496| 8.70k|{ 497| 8.70k| int size = sizeof(ogs_nas_additional_update_result_t); 498| | 499| 8.70k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (499:9): [True: 0, False: 8.70k] ------------------ 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| 8.70k| memcpy(additional_update_result, pkbuf->data - size, size); 505| | 506| 8.70k| ogs_trace(" ADDITIONAL_UPDATE_RESULT - "); ------------------ | | 40| 8.70k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8.70k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8.70k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8.70k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8.70k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8.70k| 0, __VA_ARGS__) | | ------------------ ------------------ 507| 8.70k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 8.70k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 8.70k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 508| | 509| 8.70k| return size; 510| 8.70k|} ogs_nas_eps_decode_additional_update_type: 528| 8.23k|{ 529| 8.23k| int size = sizeof(ogs_nas_additional_update_type_t); 530| | 531| 8.23k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (531:9): [True: 0, False: 8.23k] ------------------ 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| 8.23k| memcpy(additional_update_type, pkbuf->data - size, size); 537| | 538| 8.23k| ogs_trace(" ADDITIONAL_UPDATE_TYPE - "); ------------------ | | 40| 8.23k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8.23k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8.23k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8.23k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8.23k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8.23k| 0, __VA_ARGS__) | | ------------------ ------------------ 539| 8.23k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 8.23k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 8.23k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 540| | 541| 8.23k| return size; 542| 8.23k|} ogs_nas_eps_decode_authentication_failure_parameter: 560| 455|{ 561| 455| int size = 0; 562| 455| ogs_nas_authentication_failure_parameter_t *source = NULL; 563| | 564| 455| if (pkbuf->len < 1) { ------------------ | Branch (564:9): [True: 8, False: 447] ------------------ 565| 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__) | | ------------------ ------------------ 566| 8| return -1; 567| 8| } 568| | 569| 447| source = (ogs_nas_authentication_failure_parameter_t *)pkbuf->data; 570| | 571| 447| authentication_failure_parameter->length = source->length; 572| 447| size = authentication_failure_parameter->length + sizeof(authentication_failure_parameter->length); 573| | 574| 447| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (574:9): [True: 8, False: 439] ------------------ 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| 439| if (sizeof(*authentication_failure_parameter) < size) return -1; ------------------ | Branch (579:9): [True: 3, False: 436] ------------------ 580| 436| memcpy(authentication_failure_parameter, pkbuf->data - size, size); 581| | 582| 436| ogs_trace(" AUTHENTICATION_FAILURE_PARAMETER - "); ------------------ | | 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__) | | ------------------ ------------------ 583| 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 | | ------------------ ------------------ 584| | 585| 436| return size; 586| 439|} ogs_nas_eps_decode_eps_attach_result: 606| 435|{ 607| 435| int size = sizeof(ogs_nas_eps_attach_result_t); 608| | 609| 435| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (609:9): [True: 0, False: 435] ------------------ 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| 435| memcpy(eps_attach_result, pkbuf->data - size, size); 615| | 616| 435| ogs_trace(" EPS_ATTACH_RESULT - "); ------------------ | | 40| 435|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 435| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 435|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 435| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 435|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 435| 0, __VA_ARGS__) | | ------------------ ------------------ 617| 435| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 435| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 435|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 618| | 619| 435| return size; 620| 435|} ogs_nas_eps_decode_eps_attach_type: 640| 348|{ 641| 348| int size = sizeof(ogs_nas_eps_attach_type_t); 642| | 643| 348| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (643:9): [True: 0, False: 348] ------------------ 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| 348| memcpy(eps_attach_type, pkbuf->data - size, size); 649| | 650| 348| ogs_trace(" EPS_ATTACH_TYPE - "); ------------------ | | 40| 348|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 348| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 348|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 348| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 348|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 348| 0, __VA_ARGS__) | | ------------------ ------------------ 651| 348| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 348| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 348|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 652| | 653| 348| return size; 654| 348|} ogs_nas_eps_decode_eps_mobile_identity: 674| 2.62k|{ 675| 2.62k| int size = 0; 676| 2.62k| ogs_nas_eps_mobile_identity_t *source = NULL; 677| | 678| 2.62k| if (pkbuf->len < 1) { ------------------ | Branch (678:9): [True: 8, False: 2.61k] ------------------ 679| 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__) | | ------------------ ------------------ 680| 8| return -1; 681| 8| } 682| | 683| 2.61k| source = (ogs_nas_eps_mobile_identity_t *)pkbuf->data; 684| | 685| 2.61k| eps_mobile_identity->length = source->length; 686| 2.61k| size = eps_mobile_identity->length + sizeof(eps_mobile_identity->length); 687| | 688| 2.61k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (688:9): [True: 10, False: 2.60k] ------------------ 689| 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__) | | ------------------ ------------------ 690| 10| return -1; 691| 10| } 692| | 693| 2.60k| if (sizeof(*eps_mobile_identity) < size) return -1; ------------------ | Branch (693:9): [True: 6, False: 2.60k] ------------------ 694| 2.60k| memcpy(eps_mobile_identity, pkbuf->data - size, size); 695| | 696| 2.60k| if (eps_mobile_identity->guti.type == OGS_NAS_EPS_MOBILE_IDENTITY_GUTI) { ------------------ | | 317| 2.60k|#define OGS_NAS_EPS_MOBILE_IDENTITY_GUTI 6 ------------------ | Branch (696:9): [True: 200, False: 2.40k] ------------------ 697| 200| eps_mobile_identity->guti.mme_gid = be16toh(eps_mobile_identity->guti.mme_gid); 698| 200| eps_mobile_identity->guti.m_tmsi = be32toh(eps_mobile_identity->guti.m_tmsi); 699| 200| } 700| | 701| 2.60k| ogs_trace(" EPS_MOBILE_IDENTITY - "); ------------------ | | 40| 2.60k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.60k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.60k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.60k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.60k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.60k| 0, __VA_ARGS__) | | ------------------ ------------------ 702| 2.60k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.60k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.60k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 703| | 704| 2.60k| return size; 705| 2.60k|} ogs_nas_eps_decode_eps_network_feature_support: 731| 609|{ 732| 609| int size = 0; 733| 609| ogs_nas_eps_network_feature_support_t *source = NULL; 734| | 735| 609| if (pkbuf->len < 1) { ------------------ | Branch (735:9): [True: 9, False: 600] ------------------ 736| 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__) | | ------------------ ------------------ 737| 9| return -1; 738| 9| } 739| | 740| 600| source = (ogs_nas_eps_network_feature_support_t *)pkbuf->data; 741| | 742| 600| eps_network_feature_support->length = source->length; 743| 600| size = eps_network_feature_support->length + sizeof(eps_network_feature_support->length); 744| | 745| 600| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (745:9): [True: 7, False: 593] ------------------ 746| 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__) | | ------------------ ------------------ 747| 7| return -1; 748| 7| } 749| | 750| 593| if (sizeof(*eps_network_feature_support) < size) return -1; ------------------ | Branch (750:9): [True: 1, False: 592] ------------------ 751| 592| memcpy(eps_network_feature_support, pkbuf->data - size, size); 752| | 753| 592| ogs_trace(" EPS_NETWORK_FEATURE_SUPPORT - "); ------------------ | | 40| 592|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 592| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 592|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 592| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 592|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 592| 0, __VA_ARGS__) | | ------------------ ------------------ 754| 592| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 592| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 592|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 755| | 756| 592| return size; 757| 593|} ogs_nas_eps_decode_eps_update_result: 777| 810|{ 778| 810| int size = sizeof(ogs_nas_eps_update_result_t); 779| | 780| 810| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (780:9): [True: 0, False: 810] ------------------ 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| 810| memcpy(eps_update_result, pkbuf->data - size, size); 786| | 787| 810| ogs_trace(" EPS_UPDATE_RESULT - "); ------------------ | | 40| 810|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 810| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 810|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 810| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 810|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 810| 0, __VA_ARGS__) | | ------------------ ------------------ 788| 810| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 810| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 810|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 789| | 790| 810| return size; 791| 810|} ogs_nas_eps_decode_eps_update_type: 811| 689|{ 812| 689| int size = sizeof(ogs_nas_eps_update_type_t); 813| | 814| 689| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (814:9): [True: 0, False: 689] ------------------ 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| 689| memcpy(eps_update_type, pkbuf->data - size, size); 820| | 821| 689| ogs_trace(" EPS_UPDATE_TYPE - "); ------------------ | | 40| 689|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 689| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 689|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 689| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 689|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 689| 0, __VA_ARGS__) | | ------------------ ------------------ 822| 689| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 689| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 689|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 823| | 824| 689| return size; 825| 689|} ogs_nas_eps_decode_esm_message_container: 845| 1.09k|{ 846| 1.09k| int size = 0; 847| 1.09k| ogs_nas_esm_message_container_t *source = NULL; 848| | 849| 1.09k| if (pkbuf->len < 2) { ------------------ | Branch (849:9): [True: 16, False: 1.07k] ------------------ 850| 16| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 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__) | | ------------------ ------------------ 851| 16| return -1; 852| 16| } 853| | 854| 1.07k| source = (ogs_nas_esm_message_container_t *)pkbuf->data; 855| | 856| 1.07k| esm_message_container->length = be16toh(source->length); 857| 1.07k| size = esm_message_container->length + sizeof(esm_message_container->length); 858| | 859| 1.07k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (859:9): [True: 24, False: 1.05k] ------------------ 860| 24| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 24|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 24| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 24|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 24| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 24|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 24| 0, __VA_ARGS__) | | ------------------ ------------------ 861| 24| return -1; 862| 24| } 863| | 864| 1.05k| esm_message_container->buffer = pkbuf->data - size + sizeof(esm_message_container->length); 865| | 866| 1.05k| ogs_trace(" ESM_MESSAGE_CONTAINER - "); ------------------ | | 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__) | | ------------------ ------------------ 867| 1.05k| ogs_log_hexdump(OGS_LOG_TRACE, (void*)esm_message_container->buffer, esm_message_container->length); ------------------ | | 53| 1.05k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.05k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 868| | 869| 1.05k| return size; 870| 1.07k|} ogs_nas_eps_decode_gprs_timer: 898| 1.86k|{ 899| 1.86k| int size = sizeof(ogs_nas_gprs_timer_t); 900| | 901| 1.86k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (901:9): [True: 11, False: 1.85k] ------------------ 902| 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__) | | ------------------ ------------------ 903| 11| return -1; 904| 11| } 905| | 906| 1.85k| memcpy(gprs_timer, pkbuf->data - size, size); 907| | 908| 1.85k| ogs_trace(" GPRS_TIMER - "); ------------------ | | 40| 1.85k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.85k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.85k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.85k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.85k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.85k| 0, __VA_ARGS__) | | ------------------ ------------------ 909| 1.85k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.85k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.85k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 910| | 911| 1.85k| return size; 912| 1.86k|} ogs_nas_eps_decode_gprs_timer_2: 932| 2.40k|{ 933| 2.40k| int size = 0; 934| 2.40k| ogs_nas_gprs_timer_2_t *source = NULL; 935| | 936| 2.40k| if (pkbuf->len < 1) { ------------------ | Branch (936:9): [True: 11, False: 2.38k] ------------------ 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.38k| source = (ogs_nas_gprs_timer_2_t *)pkbuf->data; 942| | 943| 2.38k| gprs_timer_2->length = source->length; 944| 2.38k| size = gprs_timer_2->length + sizeof(gprs_timer_2->length); 945| | 946| 2.38k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (946:9): [True: 10, False: 2.37k] ------------------ 947| 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__) | | ------------------ ------------------ 948| 10| return -1; 949| 10| } 950| | 951| 2.37k| if (sizeof(*gprs_timer_2) < size) return -1; ------------------ | Branch (951:9): [True: 9, False: 2.37k] ------------------ 952| 2.37k| memcpy(gprs_timer_2, pkbuf->data - size, size); 953| | 954| 2.37k| ogs_trace(" GPRS_TIMER_2 - "); ------------------ | | 40| 2.37k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.37k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.37k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.37k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.37k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.37k| 0, __VA_ARGS__) | | ------------------ ------------------ 955| 2.37k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.37k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.37k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 956| | 957| 2.37k| return size; 958| 2.37k|} ogs_nas_eps_decode_gprs_timer_3: 978| 2.55k|{ 979| 2.55k| int size = 0; 980| 2.55k| ogs_nas_gprs_timer_3_t *source = NULL; 981| | 982| 2.55k| if (pkbuf->len < 1) { ------------------ | Branch (982:9): [True: 12, False: 2.53k] ------------------ 983| 12| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 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__) | | ------------------ ------------------ 984| 12| return -1; 985| 12| } 986| | 987| 2.53k| source = (ogs_nas_gprs_timer_3_t *)pkbuf->data; 988| | 989| 2.53k| gprs_timer_3->length = source->length; 990| 2.53k| size = gprs_timer_3->length + sizeof(gprs_timer_3->length); 991| | 992| 2.53k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (992:9): [True: 10, False: 2.52k] ------------------ 993| 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__) | | ------------------ ------------------ 994| 10| return -1; 995| 10| } 996| | 997| 2.52k| if (sizeof(*gprs_timer_3) < size) return -1; ------------------ | Branch (997:9): [True: 4, False: 2.52k] ------------------ 998| 2.52k| memcpy(gprs_timer_3, pkbuf->data - size, size); 999| | 1000| 2.52k| ogs_trace(" GPRS_TIMER_3 - "); ------------------ | | 40| 2.52k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.52k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.52k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.52k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.52k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.52k| 0, __VA_ARGS__) | | ------------------ ------------------ 1001| 2.52k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.52k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.52k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1002| | 1003| 2.52k| return size; 1004| 2.52k|} ogs_nas_eps_decode_identity_type_2: 1024| 10|{ 1025| 10| int size = sizeof(ogs_nas_identity_type_2_t); 1026| | 1027| 10| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1027:9): [True: 0, False: 10] ------------------ 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| 10| memcpy(identity_type_2, pkbuf->data - size, size); 1033| | 1034| 10| ogs_trace(" IDENTITY_TYPE_2 - "); ------------------ | | 40| 10|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 1035| 10| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 10| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1036| | 1037| 10| return size; 1038| 10|} ogs_nas_eps_decode_imeisv_request: 1058| 722|{ 1059| 722| int size = sizeof(ogs_nas_imeisv_request_t); 1060| | 1061| 722| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1061:9): [True: 0, False: 722] ------------------ 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| 722| memcpy(imeisv_request, pkbuf->data - size, size); 1067| | 1068| 722| ogs_trace(" IMEISV_REQUEST - "); ------------------ | | 40| 722|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 722| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 722|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 722| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 722|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 722| 0, __VA_ARGS__) | | ------------------ ------------------ 1069| 722| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 722| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 722|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1070| | 1071| 722| return size; 1072| 722|} ogs_nas_eps_decode_ksi_and_sequence_number: 1090| 13|{ 1091| 13| int size = sizeof(ogs_nas_ksi_and_sequence_number_t); 1092| | 1093| 13| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1093:9): [True: 0, False: 13] ------------------ 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| 13| memcpy(ksi_and_sequence_number, pkbuf->data - size, size); 1099| | 1100| 13| ogs_trace(" KSI_AND_SEQUENCE_NUMBER - "); ------------------ | | 40| 13|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 1101| 13| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 13| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 13|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1102| | 1103| 13| return size; 1104| 13|} ogs_nas_eps_decode_authentication_parameter_autn: 1124| 18|{ 1125| 18| int size = 0; 1126| 18| ogs_nas_authentication_parameter_autn_t *source = NULL; 1127| | 1128| 18| if (pkbuf->len < 1) { ------------------ | Branch (1128:9): [True: 2, False: 16] ------------------ 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| 16| source = (ogs_nas_authentication_parameter_autn_t *)pkbuf->data; 1134| | 1135| 16| authentication_parameter_autn->length = source->length; 1136| 16| size = authentication_parameter_autn->length + sizeof(authentication_parameter_autn->length); 1137| | 1138| 16| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1138:9): [True: 1, False: 15] ------------------ 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| 15| if (sizeof(*authentication_parameter_autn) < size) return -1; ------------------ | Branch (1143:9): [True: 3, False: 12] ------------------ 1144| 12| memcpy(authentication_parameter_autn, pkbuf->data - size, size); 1145| | 1146| 12| ogs_trace(" AUTHENTICATION_PARAMETER_AUTN - "); ------------------ | | 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__) | | ------------------ ------------------ 1147| 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 | | ------------------ ------------------ 1148| | 1149| 12| return size; 1150| 15|} ogs_nas_eps_decode_ms_network_capability: 1170| 427|{ 1171| 427| int size = 0; 1172| 427| ogs_nas_ms_network_capability_t *source = NULL; 1173| | 1174| 427| if (pkbuf->len < 1) { ------------------ | Branch (1174:9): [True: 5, False: 422] ------------------ 1175| 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__) | | ------------------ ------------------ 1176| 5| return -1; 1177| 5| } 1178| | 1179| 422| source = (ogs_nas_ms_network_capability_t *)pkbuf->data; 1180| | 1181| 422| ms_network_capability->length = source->length; 1182| 422| size = ms_network_capability->length + sizeof(ms_network_capability->length); 1183| | 1184| 422| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1184:9): [True: 1, False: 421] ------------------ 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| 421| if (sizeof(*ms_network_capability) < size) return -1; ------------------ | Branch (1189:9): [True: 2, False: 419] ------------------ 1190| 419| memcpy(ms_network_capability, pkbuf->data - size, size); 1191| | 1192| 419| ogs_trace(" MS_NETWORK_CAPABILITY - "); ------------------ | | 40| 419|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 419| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 419|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 419| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 419|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 419| 0, __VA_ARGS__) | | ------------------ ------------------ 1193| 419| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 419| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 419|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1194| | 1195| 419| return size; 1196| 421|} ogs_nas_eps_decode_ms_network_feature_support: 1216| 2.44k|{ 1217| 2.44k| int size = sizeof(ogs_nas_ms_network_feature_support_t); 1218| | 1219| 2.44k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1219:9): [True: 0, False: 2.44k] ------------------ 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| 2.44k| memcpy(ms_network_feature_support, pkbuf->data - size, size); 1225| | 1226| 2.44k| ogs_trace(" MS_NETWORK_FEATURE_SUPPORT - "); ------------------ | | 40| 2.44k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.44k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.44k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.44k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.44k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.44k| 0, __VA_ARGS__) | | ------------------ ------------------ 1227| 2.44k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.44k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.44k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1228| | 1229| 2.44k| return size; 1230| 2.44k|} ogs_nas_eps_decode_key_set_identifier: 1248| 926|{ 1249| 926| int size = sizeof(ogs_nas_key_set_identifier_t); 1250| | 1251| 926| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1251:9): [True: 0, False: 926] ------------------ 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| 926| memcpy(key_set_identifier, pkbuf->data - size, size); 1257| | 1258| 926| ogs_trace(" KEY_SET_IDENTIFIER - "); ------------------ | | 40| 926|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 926| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 926|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 926| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 926|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 926| 0, __VA_ARGS__) | | ------------------ ------------------ 1259| 926| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 926| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 926|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1260| | 1261| 926| return size; 1262| 926|} ogs_nas_eps_decode_eps_message_container: 1280| 62|{ 1281| 62| int size = 0; 1282| 62| ogs_nas_eps_message_container_t *source = NULL; 1283| | 1284| 62| if (pkbuf->len < 1) { ------------------ | Branch (1284:9): [True: 0, False: 62] ------------------ 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| 62| source = (ogs_nas_eps_message_container_t *)pkbuf->data; 1290| | 1291| 62| eps_message_container->length = source->length; 1292| 62| size = eps_message_container->length + sizeof(eps_message_container->length); 1293| | 1294| 62| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1294:9): [True: 8, False: 54] ------------------ 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| 54| if (sizeof(*eps_message_container) < size) return -1; ------------------ | Branch (1299:9): [True: 2, False: 52] ------------------ 1300| 52| memcpy(eps_message_container, pkbuf->data - size, size); 1301| | 1302| 52| ogs_trace(" EPS_MESSAGE_CONTAINER - "); ------------------ | | 40| 52|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 52| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 52|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 52| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 52|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 52| 0, __VA_ARGS__) | | ------------------ ------------------ 1303| 52| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 52| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 52|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1304| | 1305| 52| return size; 1306| 54|} ogs_nas_eps_decode_security_algorithms: 1326| 120|{ 1327| 120| int size = sizeof(ogs_nas_security_algorithms_t); 1328| | 1329| 120| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1329:9): [True: 0, False: 120] ------------------ 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| 120| memcpy(security_algorithms, pkbuf->data - size, size); 1335| | 1336| 120| ogs_trace(" SECURITY_ALGORITHMS - "); ------------------ | | 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__) | | ------------------ ------------------ 1337| 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 | | ------------------ ------------------ 1338| | 1339| 120| return size; 1340| 120|} ogs_nas_eps_decode_network_name: 1360| 458|{ 1361| 458| int size = 0; 1362| 458| ogs_nas_network_name_t *source = NULL; 1363| | 1364| 458| if (pkbuf->len < 1) { ------------------ | Branch (1364:9): [True: 4, False: 454] ------------------ 1365| 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__) | | ------------------ ------------------ 1366| 4| return -1; 1367| 4| } 1368| | 1369| 454| source = (ogs_nas_network_name_t *)pkbuf->data; 1370| | 1371| 454| network_name->length = source->length; 1372| 454| size = network_name->length + sizeof(network_name->length); 1373| | 1374| 454| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1374:9): [True: 7, False: 447] ------------------ 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| 447| if (sizeof(*network_name) < size) return -1; ------------------ | Branch (1379:9): [True: 0, False: 447] ------------------ 1380| 447| memcpy(network_name, pkbuf->data - size, size); 1381| | 1382| 447| ogs_trace(" NETWORK_NAME - "); ------------------ | | 40| 447|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 447| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 447|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 447| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 447|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 447| 0, __VA_ARGS__) | | ------------------ ------------------ 1383| 447| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 447| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 447|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1384| | 1385| 447| return size; 1386| 447|} ogs_nas_eps_decode_network_resource_identifier_container: 1406| 536|{ 1407| 536| int size = 0; 1408| 536| ogs_nas_network_resource_identifier_container_t *source = NULL; 1409| | 1410| 536| if (pkbuf->len < 1) { ------------------ | Branch (1410:9): [True: 7, False: 529] ------------------ 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| 529| source = (ogs_nas_network_resource_identifier_container_t *)pkbuf->data; 1416| | 1417| 529| network_resource_identifier_container->length = source->length; 1418| 529| size = network_resource_identifier_container->length + sizeof(network_resource_identifier_container->length); 1419| | 1420| 529| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1420:9): [True: 7, False: 522] ------------------ 1421| 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__) | | ------------------ ------------------ 1422| 7| return -1; 1423| 7| } 1424| | 1425| 522| if (sizeof(*network_resource_identifier_container) < size) return -1; ------------------ | Branch (1425:9): [True: 3, False: 519] ------------------ 1426| 519| memcpy(network_resource_identifier_container, pkbuf->data - size, size); 1427| | 1428| 519| ogs_trace(" NETWORK_RESOURCE_IDENTIFIER_CONTAINER - "); ------------------ | | 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__) | | ------------------ ------------------ 1429| 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 | | ------------------ ------------------ 1430| | 1431| 519| return size; 1432| 522|} ogs_nas_eps_decode_nonce: 1452| 948|{ 1453| 948| int size = sizeof(ogs_nas_nonce_t); 1454| | 1455| 948| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1455:9): [True: 12, False: 936] ------------------ 1456| 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__) | | ------------------ ------------------ 1457| 12| return -1; 1458| 12| } 1459| | 1460| 936| memcpy(nonce, pkbuf->data - size, size); 1461| | 1462| 936| *nonce = be32toh(*nonce); 1463| | 1464| 936| ogs_trace(" NONCE - "); ------------------ | | 40| 936|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 936| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 936|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 936| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 936|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 936| 0, __VA_ARGS__) | | ------------------ ------------------ 1465| 936| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 936| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 936|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1466| | 1467| 936| return size; 1468| 948|} ogs_nas_eps_decode_paging_identity: 1490| 112|{ 1491| 112| int size = sizeof(ogs_nas_paging_identity_t); 1492| | 1493| 112| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1493:9): [True: 0, False: 112] ------------------ 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| 112| memcpy(paging_identity, pkbuf->data - size, size); 1499| | 1500| 112| ogs_trace(" PAGING_IDENTITY - "); ------------------ | | 40| 112|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 112| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 112|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 112| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 112|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 112| 0, __VA_ARGS__) | | ------------------ ------------------ 1501| 112| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 112| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 112|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1502| | 1503| 112| return size; 1504| 112|} ogs_nas_eps_decode_p_tmsi_signature: 1524| 512|{ 1525| 512| int size = 3; 1526| | 1527| 512| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1527:9): [True: 9, False: 503] ------------------ 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| 503| memcpy(p_tmsi_signature, pkbuf->data - size, size); 1533| | 1534| 503| *p_tmsi_signature = htobe32(*p_tmsi_signature); 1535| | 1536| 503| ogs_trace(" P_TMSI_SIGNATURE - "); ------------------ | | 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__) | | ------------------ ------------------ 1537| 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 | | ------------------ ------------------ 1538| | 1539| 503| return size; 1540| 512|} ogs_nas_eps_decode_extended_emm_cause: 1562| 1.58k|{ 1563| 1.58k| int size = sizeof(ogs_nas_extended_emm_cause_t); 1564| | 1565| 1.58k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1565:9): [True: 0, False: 1.58k] ------------------ 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.58k| memcpy(extended_emm_cause, pkbuf->data - size, size); 1571| | 1572| 1.58k| ogs_trace(" EXTENDED_EMM_CAUSE - "); ------------------ | | 40| 1.58k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.58k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.58k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.58k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.58k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.58k| 0, __VA_ARGS__) | | ------------------ ------------------ 1573| 1.58k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.58k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.58k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1574| | 1575| 1.58k| return size; 1576| 1.58k|} ogs_nas_eps_decode_service_type: 1594| 122|{ 1595| 122| int size = sizeof(ogs_nas_service_type_t); 1596| | 1597| 122| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1597:9): [True: 0, False: 122] ------------------ 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| 122| memcpy(service_type, pkbuf->data - size, size); 1603| | 1604| 122| ogs_trace(" SERVICE_TYPE - "); ------------------ | | 40| 122|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 122| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 122|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 122| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 122|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 122| 0, __VA_ARGS__) | | ------------------ ------------------ 1605| 122| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 122| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 122|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1606| | 1607| 122| return size; 1608| 122|} ogs_nas_eps_decode_short_mac: 1628| 13|{ 1629| 13| int size = sizeof(ogs_nas_short_mac_t); 1630| | 1631| 13| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1631:9): [True: 0, False: 13] ------------------ 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| 13| memcpy(short_mac, pkbuf->data - size, size); 1637| | 1638| 13| *short_mac = be16toh(*short_mac); 1639| | 1640| 13| ogs_trace(" SHORT_MAC - "); ------------------ | | 40| 13|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 1641| 13| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 13| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 13|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1642| | 1643| 13| return size; 1644| 13|} ogs_nas_eps_decode_time_zone: 1666| 315|{ 1667| 315| int size = sizeof(ogs_nas_time_zone_t); 1668| | 1669| 315| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1669:9): [True: 7, False: 308] ------------------ 1670| 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__) | | ------------------ ------------------ 1671| 7| return -1; 1672| 7| } 1673| | 1674| 308| memcpy(time_zone, pkbuf->data - size, size); 1675| | 1676| 308| ogs_trace(" TIME_ZONE - "); ------------------ | | 40| 308|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 308| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 308|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 308| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 308|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 308| 0, __VA_ARGS__) | | ------------------ ------------------ 1677| 308| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 308| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 308|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1678| | 1679| 308| return size; 1680| 315|} ogs_nas_eps_decode_authentication_parameter_rand: 1700| 26|{ 1701| 26| int size = sizeof(ogs_nas_authentication_parameter_rand_t); 1702| | 1703| 26| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1703:9): [True: 8, False: 18] ------------------ 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| 18| memcpy(authentication_parameter_rand, pkbuf->data - size, size); 1709| | 1710| 18| ogs_trace(" AUTHENTICATION_PARAMETER_RAND - "); ------------------ | | 40| 18|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 18| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 18|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 18| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 18|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 18| 0, __VA_ARGS__) | | ------------------ ------------------ 1711| 18| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 18| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 18|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1712| | 1713| 18| return size; 1714| 26|} ogs_nas_eps_decode_time_zone_and_time: 1734| 180|{ 1735| 180| int size = sizeof(ogs_nas_time_zone_and_time_t); 1736| | 1737| 180| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1737:9): [True: 10, False: 170] ------------------ 1738| 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__) | | ------------------ ------------------ 1739| 10| return -1; 1740| 10| } 1741| | 1742| 170| memcpy(time_zone_and_time, pkbuf->data - size, size); 1743| | 1744| 170| ogs_trace(" TIME_ZONE_AND_TIME - "); ------------------ | | 40| 170|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 170| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 170|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 170| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 170|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 170| 0, __VA_ARGS__) | | ------------------ ------------------ 1745| 170| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 170| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 170|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1746| | 1747| 170| return size; 1748| 180|} ogs_nas_eps_decode_tmsi_status: 1768| 1.57k|{ 1769| 1.57k| int size = sizeof(ogs_nas_tmsi_status_t); 1770| | 1771| 1.57k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1771:9): [True: 0, False: 1.57k] ------------------ 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| 1.57k| memcpy(tmsi_status, pkbuf->data - size, size); 1777| | 1778| 1.57k| ogs_trace(" TMSI_STATUS - "); ------------------ | | 40| 1.57k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.57k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.57k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.57k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.57k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.57k| 0, __VA_ARGS__) | | ------------------ ------------------ 1779| 1.57k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.57k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.57k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1780| | 1781| 1.57k| return size; 1782| 1.57k|} ogs_nas_eps_decode_tracking_area_identity: 1800| 627|{ 1801| 627| int size = sizeof(ogs_nas_tracking_area_identity_t); 1802| | 1803| 627| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1803:9): [True: 11, False: 616] ------------------ 1804| 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__) | | ------------------ ------------------ 1805| 11| return -1; 1806| 11| } 1807| | 1808| 616| memcpy(tracking_area_identity, pkbuf->data - size, size); 1809| | 1810| 616| tracking_area_identity->tac = be16toh(tracking_area_identity->tac); 1811| | 1812| 616| ogs_trace(" TRACKING_AREA_IDENTITY - "); ------------------ | | 40| 616|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 616| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 616|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 616| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 616|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 616| 0, __VA_ARGS__) | | ------------------ ------------------ 1813| 616| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 616| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 616|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1814| | 1815| 616| return size; 1816| 627|} ogs_nas_eps_decode_tracking_area_identity_list: 1838| 3.27k|{ 1839| 3.27k| int size = 0; 1840| 3.27k| ogs_nas_tracking_area_identity_list_t *source = NULL; 1841| | 1842| 3.27k| if (pkbuf->len < 1) { ------------------ | Branch (1842:9): [True: 11, False: 3.26k] ------------------ 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.26k| source = (ogs_nas_tracking_area_identity_list_t *)pkbuf->data; 1848| | 1849| 3.26k| tracking_area_identity_list->length = source->length; 1850| 3.26k| size = tracking_area_identity_list->length + sizeof(tracking_area_identity_list->length); 1851| | 1852| 3.26k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1852:9): [True: 10, False: 3.25k] ------------------ 1853| 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__) | | ------------------ ------------------ 1854| 10| return -1; 1855| 10| } 1856| | 1857| 3.25k| if (sizeof(*tracking_area_identity_list) < size) return -1; ------------------ | Branch (1857:9): [True: 3, False: 3.25k] ------------------ 1858| 3.25k| memcpy(tracking_area_identity_list, pkbuf->data - size, size); 1859| | 1860| 3.25k| ogs_trace(" TRACKING_AREA_IDENTITY_LIST - "); ------------------ | | 40| 3.25k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.25k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.25k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.25k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.25k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.25k| 0, __VA_ARGS__) | | ------------------ ------------------ 1861| 3.25k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 3.25k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 3.25k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1862| | 1863| 3.25k| return size; 1864| 3.25k|} ogs_nas_eps_decode_ue_network_capability: 1884| 767|{ 1885| 767| int size = 0; 1886| 767| ogs_nas_ue_network_capability_t *source = NULL; 1887| | 1888| 767| if (pkbuf->len < 1) { ------------------ | Branch (1888:9): [True: 9, False: 758] ------------------ 1889| 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__) | | ------------------ ------------------ 1890| 9| return -1; 1891| 9| } 1892| | 1893| 758| source = (ogs_nas_ue_network_capability_t *)pkbuf->data; 1894| | 1895| 758| ue_network_capability->length = source->length; 1896| 758| size = ue_network_capability->length + sizeof(ue_network_capability->length); 1897| | 1898| 758| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1898:9): [True: 6, False: 752] ------------------ 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| 752| if (sizeof(*ue_network_capability) < size) return -1; ------------------ | Branch (1903:9): [True: 1, False: 751] ------------------ 1904| 751| memcpy(ue_network_capability, pkbuf->data - size, size); 1905| | 1906| 751| ogs_trace(" UE_NETWORK_CAPABILITY - "); ------------------ | | 40| 751|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 751| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 751|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 751| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 751|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 751| 0, __VA_ARGS__) | | ------------------ ------------------ 1907| 751| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 751| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 751|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1908| | 1909| 751| return size; 1910| 752|} ogs_nas_eps_decode_ue_radio_capability_information_update_needed: 1930| 1.11k|{ 1931| 1.11k| int size = sizeof(ogs_nas_ue_radio_capability_information_update_needed_t); 1932| | 1933| 1.11k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1933:9): [True: 0, False: 1.11k] ------------------ 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| 1.11k| memcpy(ue_radio_capability_information_update_needed, pkbuf->data - size, size); 1939| | 1940| 1.11k| ogs_trace(" UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED - "); ------------------ | | 40| 1.11k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.11k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.11k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.11k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.11k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.11k| 0, __VA_ARGS__) | | ------------------ ------------------ 1941| 1.11k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.11k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.11k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1942| | 1943| 1.11k| return size; 1944| 1.11k|} ogs_nas_eps_decode_ue_security_capability: 1962| 120|{ 1963| 120| int size = 0; 1964| 120| ogs_nas_ue_security_capability_t *source = NULL; 1965| | 1966| 120| if (pkbuf->len < 1) { ------------------ | Branch (1966:9): [True: 0, False: 120] ------------------ 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| 120| source = (ogs_nas_ue_security_capability_t *)pkbuf->data; 1972| | 1973| 120| ue_security_capability->length = source->length; 1974| 120| size = ue_security_capability->length + sizeof(ue_security_capability->length); 1975| | 1976| 120| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1976:9): [True: 3, False: 117] ------------------ 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| 117| if (sizeof(*ue_security_capability) < size) return -1; ------------------ | Branch (1981:9): [True: 1, False: 116] ------------------ 1982| 116| memcpy(ue_security_capability, pkbuf->data - size, size); 1983| | 1984| 116| ogs_trace(" UE_SECURITY_CAPABILITY - "); ------------------ | | 40| 116|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 116| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 116|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 116| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 116|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 116| 0, __VA_ARGS__) | | ------------------ ------------------ 1985| 116| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 116| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 116|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1986| | 1987| 116| return size; 1988| 117|} ogs_nas_eps_decode_emergency_number_list: 2008| 569|{ 2009| 569| int size = 0; 2010| 569| ogs_nas_emergency_number_list_t *source = NULL; 2011| | 2012| 569| if (pkbuf->len < 1) { ------------------ | Branch (2012:9): [True: 5, False: 564] ------------------ 2013| 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__) | | ------------------ ------------------ 2014| 5| return -1; 2015| 5| } 2016| | 2017| 564| source = (ogs_nas_emergency_number_list_t *)pkbuf->data; 2018| | 2019| 564| emergency_number_list->length = source->length; 2020| 564| size = emergency_number_list->length + sizeof(emergency_number_list->length); 2021| | 2022| 564| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2022:9): [True: 7, False: 557] ------------------ 2023| 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__) | | ------------------ ------------------ 2024| 7| return -1; 2025| 7| } 2026| | 2027| 557| if (sizeof(*emergency_number_list) < size) return -1; ------------------ | Branch (2027:9): [True: 2, False: 555] ------------------ 2028| 555| memcpy(emergency_number_list, pkbuf->data - size, size); 2029| | 2030| 555| ogs_trace(" EMERGENCY_NUMBER_LIST - "); ------------------ | | 40| 555|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 555| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 555|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 555| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 555|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 555| 0, __VA_ARGS__) | | ------------------ ------------------ 2031| 555| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 555| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 555|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2032| | 2033| 555| return size; 2034| 557|} ogs_nas_eps_decode_extended_emergency_number_list: 2054| 526|{ 2055| 526| int size = 0; 2056| 526| ogs_nas_extended_emergency_number_list_t *source = NULL; 2057| | 2058| 526| if (pkbuf->len < 2) { ------------------ | Branch (2058:9): [True: 8, False: 518] ------------------ 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| 518| source = (ogs_nas_extended_emergency_number_list_t *)pkbuf->data; 2064| | 2065| 518| extended_emergency_number_list->length = be16toh(source->length); 2066| 518| size = extended_emergency_number_list->length + sizeof(extended_emergency_number_list->length); 2067| | 2068| 518| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2068:9): [True: 23, False: 495] ------------------ 2069| 23| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 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__) | | ------------------ ------------------ 2070| 23| return -1; 2071| 23| } 2072| | 2073| 495| extended_emergency_number_list->buffer = pkbuf->data - size + sizeof(extended_emergency_number_list->length); 2074| | 2075| 495| ogs_trace(" EXTENDED_EMERGENCY_NUMBER_LIST - "); ------------------ | | 40| 495|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 495| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 495|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 495| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 495|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 495| 0, __VA_ARGS__) | | ------------------ ------------------ 2076| 495| ogs_log_hexdump(OGS_LOG_TRACE, (void*)extended_emergency_number_list->buffer, extended_emergency_number_list->length); ------------------ | | 53| 495| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 495|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2077| | 2078| 495| return size; 2079| 518|} ogs_nas_eps_decode_cli: 2107| 379|{ 2108| 379| int size = 0; 2109| 379| ogs_nas_cli_t *source = NULL; 2110| | 2111| 379| if (pkbuf->len < 1) { ------------------ | Branch (2111:9): [True: 7, False: 372] ------------------ 2112| 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__) | | ------------------ ------------------ 2113| 7| return -1; 2114| 7| } 2115| | 2116| 372| source = (ogs_nas_cli_t *)pkbuf->data; 2117| | 2118| 372| cli->length = source->length; 2119| 372| size = cli->length + sizeof(cli->length); 2120| | 2121| 372| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2121:9): [True: 2, False: 370] ------------------ 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| 370| if (sizeof(*cli) < size) return -1; ------------------ | Branch (2126:9): [True: 1, False: 369] ------------------ 2127| 369| memcpy(cli, pkbuf->data - size, size); 2128| | 2129| 369| ogs_trace(" CLI - "); ------------------ | | 40| 369|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 369| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 369|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 369| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 369|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 369| 0, __VA_ARGS__) | | ------------------ ------------------ 2130| 369| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 369| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 369|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2131| | 2132| 369| return size; 2133| 370|} ogs_nas_eps_decode_ss_code: 2153| 283|{ 2154| 283| int size = sizeof(ogs_nas_ss_code_t); 2155| | 2156| 283| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2156:9): [True: 5, False: 278] ------------------ 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| 278| memcpy(ss_code, pkbuf->data - size, size); 2162| | 2163| 278| ogs_trace(" SS_CODE - "); ------------------ | | 40| 278|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 278| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 278|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 278| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 278|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 278| 0, __VA_ARGS__) | | ------------------ ------------------ 2164| 278| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 278| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 278|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2165| | 2166| 278| return size; 2167| 283|} ogs_nas_eps_decode_access_technology_utilization_control: 2187| 1.39k|{ 2188| 1.39k| int size = 0; 2189| 1.39k| ogs_nas_access_technology_utilization_control_t *source = NULL; 2190| | 2191| 1.39k| if (pkbuf->len < 1) { ------------------ | Branch (2191:9): [True: 7, False: 1.39k] ------------------ 2192| 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__) | | ------------------ ------------------ 2193| 7| return -1; 2194| 7| } 2195| | 2196| 1.39k| source = (ogs_nas_access_technology_utilization_control_t *)pkbuf->data; 2197| | 2198| 1.39k| access_technology_utilization_control->length = source->length; 2199| 1.39k| size = access_technology_utilization_control->length + sizeof(access_technology_utilization_control->length); 2200| | 2201| 1.39k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2201:9): [True: 5, False: 1.38k] ------------------ 2202| 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__) | | ------------------ ------------------ 2203| 5| return -1; 2204| 5| } 2205| | 2206| 1.38k| if (sizeof(*access_technology_utilization_control) < size) return -1; ------------------ | Branch (2206:9): [True: 1, False: 1.38k] ------------------ 2207| 1.38k| memcpy(access_technology_utilization_control, pkbuf->data - size, size); 2208| | 2209| 1.38k| ogs_trace(" ACCESS_TECHNOLOGY_UTILIZATION_CONTROL - "); ------------------ | | 40| 1.38k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.38k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.38k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.38k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.38k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.38k| 0, __VA_ARGS__) | | ------------------ ------------------ 2210| 1.38k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.38k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.38k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2211| | 2212| 1.38k| return size; 2213| 1.38k|} ogs_nas_eps_decode_authentication_response_parameter: 2233| 26|{ 2234| 26| int size = 0; 2235| 26| ogs_nas_authentication_response_parameter_t *source = NULL; 2236| | 2237| 26| if (pkbuf->len < 1) { ------------------ | Branch (2237:9): [True: 0, False: 26] ------------------ 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| 26| source = (ogs_nas_authentication_response_parameter_t *)pkbuf->data; 2243| | 2244| 26| authentication_response_parameter->length = source->length; 2245| 26| size = authentication_response_parameter->length + sizeof(authentication_response_parameter->length); 2246| | 2247| 26| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2247:9): [True: 2, False: 24] ------------------ 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| 24| if (sizeof(*authentication_response_parameter) < size) return -1; ------------------ | Branch (2252:9): [True: 2, False: 22] ------------------ 2253| 22| memcpy(authentication_response_parameter, pkbuf->data - size, size); 2254| | 2255| 22| ogs_trace(" AUTHENTICATION_RESPONSE_PARAMETER - "); ------------------ | | 40| 22|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 2256| 22| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 22| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 22|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2257| | 2258| 22| return size; 2259| 24|} ogs_nas_eps_decode_lcs_indicator: 2279| 401|{ 2280| 401| int size = sizeof(ogs_nas_lcs_indicator_t); 2281| | 2282| 401| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2282:9): [True: 8, False: 393] ------------------ 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| 393| memcpy(lcs_indicator, pkbuf->data - size, size); 2288| | 2289| 393| ogs_trace(" LCS_INDICATOR - "); ------------------ | | 40| 393|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 393| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 393|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 393| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 393|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 393| 0, __VA_ARGS__) | | ------------------ ------------------ 2290| 393| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 393| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 393|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2291| | 2292| 393| return size; 2293| 401|} ogs_nas_eps_decode_lcs_client_identity: 2313| 495|{ 2314| 495| int size = 0; 2315| 495| ogs_nas_lcs_client_identity_t *source = NULL; 2316| | 2317| 495| if (pkbuf->len < 1) { ------------------ | Branch (2317:9): [True: 6, False: 489] ------------------ 2318| 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__) | | ------------------ ------------------ 2319| 6| return -1; 2320| 6| } 2321| | 2322| 489| source = (ogs_nas_lcs_client_identity_t *)pkbuf->data; 2323| | 2324| 489| lcs_client_identity->length = source->length; 2325| 489| size = lcs_client_identity->length + sizeof(lcs_client_identity->length); 2326| | 2327| 489| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2327:9): [True: 8, False: 481] ------------------ 2328| 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__) | | ------------------ ------------------ 2329| 8| return -1; 2330| 8| } 2331| | 2332| 481| if (sizeof(*lcs_client_identity) < size) return -1; ------------------ | Branch (2332:9): [True: 0, False: 481] ------------------ 2333| 481| memcpy(lcs_client_identity, pkbuf->data - size, size); 2334| | 2335| 481| ogs_trace(" LCS_CLIENT_IDENTITY - "); ------------------ | | 40| 481|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 481| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 481|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 481| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 481|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 481| 0, __VA_ARGS__) | | ------------------ ------------------ 2336| 481| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 481| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 481|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2337| | 2338| 481| return size; 2339| 481|} ogs_nas_eps_decode_generic_message_container_type: 2359| 172|{ 2360| 172| int size = sizeof(ogs_nas_generic_message_container_type_t); 2361| | 2362| 172| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2362:9): [True: 0, False: 172] ------------------ 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| 172| memcpy(generic_message_container_type, pkbuf->data - size, size); 2368| | 2369| 172| ogs_trace(" GENERIC_MESSAGE_CONTAINER_TYPE - "); ------------------ | | 40| 172|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 172| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 172|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 172| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 172|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 172| 0, __VA_ARGS__) | | ------------------ ------------------ 2370| 172| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 172| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 172|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2371| | 2372| 172| return size; 2373| 172|} ogs_nas_eps_decode_generic_message_container: 2393| 172|{ 2394| 172| int size = 0; 2395| 172| ogs_nas_generic_message_container_t *source = NULL; 2396| | 2397| 172| if (pkbuf->len < 2) { ------------------ | Branch (2397:9): [True: 0, False: 172] ------------------ 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| 172| source = (ogs_nas_generic_message_container_t *)pkbuf->data; 2403| | 2404| 172| generic_message_container->length = be16toh(source->length); 2405| 172| size = generic_message_container->length + sizeof(generic_message_container->length); 2406| | 2407| 172| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2407:9): [True: 26, False: 146] ------------------ 2408| 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__) | | ------------------ ------------------ 2409| 26| return -1; 2410| 26| } 2411| | 2412| 146| generic_message_container->buffer = pkbuf->data - size + sizeof(generic_message_container->length); 2413| | 2414| 146| ogs_trace(" GENERIC_MESSAGE_CONTAINER - "); ------------------ | | 40| 146|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 146| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 146|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 146| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 146|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 146| 0, __VA_ARGS__) | | ------------------ ------------------ 2415| 146| ogs_log_hexdump(OGS_LOG_TRACE, (void*)generic_message_container->buffer, generic_message_container->length); ------------------ | | 53| 146| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 146|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2416| | 2417| 146| return size; 2418| 172|} ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting: 2446| 443|{ 2447| 443| int size = 0; 2448| 443| ogs_nas_voice_domain_preference_and_ue_usage_setting_t *source = NULL; 2449| | 2450| 443| if (pkbuf->len < 1) { ------------------ | Branch (2450:9): [True: 6, False: 437] ------------------ 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| 437| source = (ogs_nas_voice_domain_preference_and_ue_usage_setting_t *)pkbuf->data; 2456| | 2457| 437| voice_domain_preference_and_ue_usage_setting->length = source->length; 2458| 437| size = voice_domain_preference_and_ue_usage_setting->length + sizeof(voice_domain_preference_and_ue_usage_setting->length); 2459| | 2460| 437| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2460:9): [True: 1, False: 436] ------------------ 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| 436| if (sizeof(*voice_domain_preference_and_ue_usage_setting) < size) return -1; ------------------ | Branch (2465:9): [True: 1, False: 435] ------------------ 2466| 435| memcpy(voice_domain_preference_and_ue_usage_setting, pkbuf->data - size, size); 2467| | 2468| 435| ogs_trace(" VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING - "); ------------------ | | 40| 435|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 435| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 435|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 435| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 435|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 435| 0, __VA_ARGS__) | | ------------------ ------------------ 2469| 435| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 435| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 435|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2470| | 2471| 435| return size; 2472| 436|} ogs_nas_eps_decode_guti_type: 2492| 1.81k|{ 2493| 1.81k| int size = sizeof(ogs_nas_guti_type_t); 2494| | 2495| 1.81k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2495:9): [True: 0, False: 1.81k] ------------------ 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| 1.81k| memcpy(guti_type, pkbuf->data - size, size); 2501| | 2502| 1.81k| ogs_trace(" GUTI_TYPE - "); ------------------ | | 40| 1.81k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.81k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.81k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.81k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.81k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.81k| 0, __VA_ARGS__) | | ------------------ ------------------ 2503| 1.81k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.81k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.81k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2504| | 2505| 1.81k| return size; 2506| 1.81k|} ogs_nas_eps_decode_extended_drx_parameters: 2524| 1.06k|{ 2525| 1.06k| int size = 0; 2526| 1.06k| ogs_nas_extended_drx_parameters_t *source = NULL; 2527| | 2528| 1.06k| if (pkbuf->len < 1) { ------------------ | Branch (2528:9): [True: 8, False: 1.05k] ------------------ 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.05k| source = (ogs_nas_extended_drx_parameters_t *)pkbuf->data; 2534| | 2535| 1.05k| extended_drx_parameters->length = source->length; 2536| 1.05k| size = extended_drx_parameters->length + sizeof(extended_drx_parameters->length); 2537| | 2538| 1.05k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2538:9): [True: 5, False: 1.04k] ------------------ 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.04k| if (sizeof(*extended_drx_parameters) < size) return -1; ------------------ | Branch (2543:9): [True: 1, False: 1.04k] ------------------ 2544| 1.04k| memcpy(extended_drx_parameters, pkbuf->data - size, size); 2545| | 2546| 1.04k| ogs_trace(" EXTENDED_DRX_PARAMETERS - "); ------------------ | | 40| 1.04k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.04k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.04k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.04k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.04k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.04k| 0, __VA_ARGS__) | | ------------------ ------------------ 2547| 1.04k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.04k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.04k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2548| | 2549| 1.04k| return size; 2550| 1.04k|} ogs_nas_eps_decode_dcn_id: 2570| 774|{ 2571| 774| int size = 0; 2572| 774| ogs_nas_dcn_id_t *source = NULL; 2573| | 2574| 774| if (pkbuf->len < 1) { ------------------ | Branch (2574:9): [True: 8, False: 766] ------------------ 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| 766| source = (ogs_nas_dcn_id_t *)pkbuf->data; 2580| | 2581| 766| dcn_id->length = source->length; 2582| 766| size = dcn_id->length + sizeof(dcn_id->length); 2583| | 2584| 766| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2584:9): [True: 8, False: 758] ------------------ 2585| 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__) | | ------------------ ------------------ 2586| 8| return -1; 2587| 8| } 2588| | 2589| 758| if (sizeof(*dcn_id) < size) return -1; ------------------ | Branch (2589:9): [True: 3, False: 755] ------------------ 2590| 755| memcpy(dcn_id, pkbuf->data - size, size); 2591| | 2592| 755| ogs_trace(" DCN_ID - "); ------------------ | | 40| 755|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 755| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 755|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 755| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 755|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 755| 0, __VA_ARGS__) | | ------------------ ------------------ 2593| 755| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 755| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 755|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2594| | 2595| 755| return size; 2596| 758|} ogs_nas_eps_decode_non_nw_provided_policies: 2616| 1.78k|{ 2617| 1.78k| int size = sizeof(ogs_nas_non_nw_provided_policies_t); 2618| | 2619| 1.78k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2619:9): [True: 0, False: 1.78k] ------------------ 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.78k| memcpy(non_nw_provided_policies, pkbuf->data - size, size); 2625| | 2626| 1.78k| ogs_trace(" NON__NW_PROVIDED_POLICIES - "); ------------------ | | 40| 1.78k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.78k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.78k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.78k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.78k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.78k| 0, __VA_ARGS__) | | ------------------ ------------------ 2627| 1.78k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.78k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.78k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2628| | 2629| 1.78k| return size; 2630| 1.78k|} ogs_nas_eps_decode_sms_services_status: 2648| 2.18k|{ 2649| 2.18k| int size = sizeof(ogs_nas_sms_services_status_t); 2650| | 2651| 2.18k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2651:9): [True: 0, False: 2.18k] ------------------ 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.18k| memcpy(sms_services_status, pkbuf->data - size, size); 2657| | 2658| 2.18k| ogs_trace(" SMS_SERVICES_STATUS - "); ------------------ | | 40| 2.18k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.18k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.18k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.18k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.18k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.18k| 0, __VA_ARGS__) | | ------------------ ------------------ 2659| 2.18k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.18k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.18k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2660| | 2661| 2.18k| return size; 2662| 2.18k|} ogs_nas_eps_decode_ciphering_key_sequence_number: 2680| 1.00k|{ 2681| 1.00k| int size = sizeof(ogs_nas_ciphering_key_sequence_number_t); 2682| | 2683| 1.00k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2683:9): [True: 0, False: 1.00k] ------------------ 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.00k| memcpy(ciphering_key_sequence_number, pkbuf->data - size, size); 2689| | 2690| 1.00k| ogs_trace(" CIPHERING_KEY_SEQUENCE_NUMBER - "); ------------------ | | 40| 1.00k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.00k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.00k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.00k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.00k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.00k| 0, __VA_ARGS__) | | ------------------ ------------------ 2691| 1.00k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.00k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.00k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2692| | 2693| 1.00k| return size; 2694| 1.00k|} ogs_nas_eps_decode_csfb_response: 2712| 746|{ 2713| 746| int size = sizeof(ogs_nas_csfb_response_t); 2714| | 2715| 746| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2715:9): [True: 0, False: 746] ------------------ 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| 746| memcpy(csfb_response, pkbuf->data - size, size); 2721| | 2722| 746| ogs_trace(" CSFB_RESPONSE - "); ------------------ | | 40| 746|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 746| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 746|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 746| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 746|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 746| 0, __VA_ARGS__) | | ------------------ ------------------ 2723| 746| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 746| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 746|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2724| | 2725| 746| return size; 2726| 746|} ogs_nas_eps_decode_hashmme: 2744| 369|{ 2745| 369| int size = 0; 2746| 369| ogs_nas_hashmme_t *source = NULL; 2747| | 2748| 369| if (pkbuf->len < 1) { ------------------ | Branch (2748:9): [True: 7, False: 362] ------------------ 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| 362| source = (ogs_nas_hashmme_t *)pkbuf->data; 2754| | 2755| 362| hashmme->length = source->length; 2756| 362| size = hashmme->length + sizeof(hashmme->length); 2757| | 2758| 362| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2758:9): [True: 1, False: 361] ------------------ 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| 361| if (sizeof(*hashmme) < size) return -1; ------------------ | Branch (2763:9): [True: 1, False: 360] ------------------ 2764| 360| memcpy(hashmme, pkbuf->data - size, size); 2765| | 2766| 360| ogs_trace(" HASHMME - "); ------------------ | | 40| 360|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 360| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 360|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 360| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 360|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 360| 0, __VA_ARGS__) | | ------------------ ------------------ 2767| 360| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 360| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 360|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2768| | 2769| 360| return size; 2770| 361|} ogs_nas_eps_decode_replayed_nas_message_container: 2790| 330|{ 2791| 330| int size = 0; 2792| 330| ogs_nas_replayed_nas_message_container_t *source = NULL; 2793| | 2794| 330| if (pkbuf->len < 2) { ------------------ | Branch (2794:9): [True: 8, False: 322] ------------------ 2795| 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__) | | ------------------ ------------------ 2796| 8| return -1; 2797| 8| } 2798| | 2799| 322| source = (ogs_nas_replayed_nas_message_container_t *)pkbuf->data; 2800| | 2801| 322| replayed_nas_message_container->length = be16toh(source->length); 2802| 322| size = replayed_nas_message_container->length + sizeof(replayed_nas_message_container->length); 2803| | 2804| 322| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2804:9): [True: 26, False: 296] ------------------ 2805| 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__) | | ------------------ ------------------ 2806| 26| return -1; 2807| 26| } 2808| | 2809| 296| replayed_nas_message_container->buffer = pkbuf->data - size + sizeof(replayed_nas_message_container->length); 2810| | 2811| 296| ogs_trace(" REPLAYED_NAS_MESSAGE_CONTAINER - "); ------------------ | | 40| 296|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 296| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 296|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 296| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 296|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 296| 0, __VA_ARGS__) | | ------------------ ------------------ 2812| 296| ogs_log_hexdump(OGS_LOG_TRACE, (void*)replayed_nas_message_container->buffer, replayed_nas_message_container->length); ------------------ | | 53| 296| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 296|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2813| | 2814| 296| return size; 2815| 322|} ogs_nas_eps_decode_network_policy: 2843| 1.82k|{ 2844| 1.82k| int size = sizeof(ogs_nas_network_policy_t); 2845| | 2846| 1.82k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2846:9): [True: 0, False: 1.82k] ------------------ 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.82k| memcpy(network_policy, pkbuf->data - size, size); 2852| | 2853| 1.82k| ogs_trace(" NETWORK_POLICY - "); ------------------ | | 40| 1.82k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.82k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.82k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.82k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.82k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.82k| 0, __VA_ARGS__) | | ------------------ ------------------ 2854| 1.82k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.82k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.82k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2855| | 2856| 1.82k| return size; 2857| 1.82k|} ogs_nas_eps_decode_ue_additional_security_capability: 2875| 785|{ 2876| 785| int size = 0; 2877| 785| ogs_nas_ue_additional_security_capability_t *source = NULL; 2878| | 2879| 785| if (pkbuf->len < 1) { ------------------ | Branch (2879:9): [True: 10, False: 775] ------------------ 2880| 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__) | | ------------------ ------------------ 2881| 10| return -1; 2882| 10| } 2883| | 2884| 775| source = (ogs_nas_ue_additional_security_capability_t *)pkbuf->data; 2885| | 2886| 775| ue_additional_security_capability->length = source->length; 2887| 775| size = ue_additional_security_capability->length + sizeof(ue_additional_security_capability->length); 2888| | 2889| 775| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2889:9): [True: 1, False: 774] ------------------ 2890| 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__) | | ------------------ ------------------ 2891| 1| return -1; 2892| 1| } 2893| | 2894| 774| if (sizeof(*ue_additional_security_capability) < size) return -1; ------------------ | Branch (2894:9): [True: 1, False: 773] ------------------ 2895| 773| memcpy(ue_additional_security_capability, pkbuf->data - size, size); 2896| | 2897| 773| ogs_trace(" UE_ADDITIONAL_SECURITY_CAPABILITY - "); ------------------ | | 40| 773|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 773| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 773|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 773| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 773|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 773| 0, __VA_ARGS__) | | ------------------ ------------------ 2898| 773| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 773| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 773|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2899| | 2900| 773| return size; 2901| 774|} ogs_nas_eps_decode_ue_status: 2921| 498|{ 2922| 498| int size = 0; 2923| 498| ogs_nas_ue_status_t *source = NULL; 2924| | 2925| 498| if (pkbuf->len < 1) { ------------------ | Branch (2925:9): [True: 7, False: 491] ------------------ 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| 491| source = (ogs_nas_ue_status_t *)pkbuf->data; 2931| | 2932| 491| ue_status->length = source->length; 2933| 491| size = ue_status->length + sizeof(ue_status->length); 2934| | 2935| 491| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2935:9): [True: 1, False: 490] ------------------ 2936| 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__) | | ------------------ ------------------ 2937| 1| return -1; 2938| 1| } 2939| | 2940| 490| if (sizeof(*ue_status) < size) return -1; ------------------ | Branch (2940:9): [True: 1, False: 489] ------------------ 2941| 489| memcpy(ue_status, pkbuf->data - size, size); 2942| | 2943| 489| ogs_trace(" UE_STATUS - "); ------------------ | | 40| 489|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 489| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 489|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 489| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 489|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 489| 0, __VA_ARGS__) | | ------------------ ------------------ 2944| 489| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 489| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 489|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2945| | 2946| 489| return size; 2947| 490|} 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| 535|{ 3002| 535| int size = 0; 3003| 535| ogs_nas_ciphering_key_data_t *source = NULL; 3004| | 3005| 535| if (pkbuf->len < 2) { ------------------ | Branch (3005:9): [True: 8, False: 527] ------------------ 3006| 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__) | | ------------------ ------------------ 3007| 8| return -1; 3008| 8| } 3009| | 3010| 527| source = (ogs_nas_ciphering_key_data_t *)pkbuf->data; 3011| | 3012| 527| ciphering_key_data->length = be16toh(source->length); 3013| 527| size = ciphering_key_data->length + sizeof(ciphering_key_data->length); 3014| | 3015| 527| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3015:9): [True: 26, False: 501] ------------------ 3016| 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__) | | ------------------ ------------------ 3017| 26| return -1; 3018| 26| } 3019| | 3020| 501| ciphering_key_data->buffer = pkbuf->data - size + sizeof(ciphering_key_data->length); 3021| | 3022| 501| ogs_trace(" CIPHERING_KEY_DATA - "); ------------------ | | 40| 501|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 501| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 501|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 501| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 501|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 501| 0, __VA_ARGS__) | | ------------------ ------------------ 3023| 501| ogs_log_hexdump(OGS_LOG_TRACE, (void*)ciphering_key_data->buffer, ciphering_key_data->length); ------------------ | | 53| 501| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 501|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3024| | 3025| 501| return size; 3026| 527|} ogs_nas_eps_decode_n1_ue_network_capability: 3054| 706|{ 3055| 706| int size = 0; 3056| 706| ogs_nas_n1_ue_network_capability_t *source = NULL; 3057| | 3058| 706| if (pkbuf->len < 1) { ------------------ | Branch (3058:9): [True: 9, False: 697] ------------------ 3059| 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__) | | ------------------ ------------------ 3060| 9| return -1; 3061| 9| } 3062| | 3063| 697| source = (ogs_nas_n1_ue_network_capability_t *)pkbuf->data; 3064| | 3065| 697| n1_ue_network_capability->length = source->length; 3066| 697| size = n1_ue_network_capability->length + sizeof(n1_ue_network_capability->length); 3067| | 3068| 697| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3068:9): [True: 6, False: 691] ------------------ 3069| 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__) | | ------------------ ------------------ 3070| 6| return -1; 3071| 6| } 3072| | 3073| 691| if (sizeof(*n1_ue_network_capability) < size) return -1; ------------------ | Branch (3073:9): [True: 2, False: 689] ------------------ 3074| 689| memcpy(n1_ue_network_capability, pkbuf->data - size, size); 3075| | 3076| 689| ogs_trace(" N1_UE_NETWORK_CAPABILITY - "); ------------------ | | 40| 689|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 689| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 689|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 689| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 689|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 689| 0, __VA_ARGS__) | | ------------------ ------------------ 3077| 689| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 689| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 689|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3078| | 3079| 689| return size; 3080| 691|} ogs_nas_eps_decode_ue_radio_capability_id_availability: 3100| 582|{ 3101| 582| int size = 0; 3102| 582| ogs_nas_ue_radio_capability_id_availability_t *source = NULL; 3103| | 3104| 582| if (pkbuf->len < 1) { ------------------ | Branch (3104:9): [True: 8, False: 574] ------------------ 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| 574| source = (ogs_nas_ue_radio_capability_id_availability_t *)pkbuf->data; 3110| | 3111| 574| ue_radio_capability_id_availability->length = source->length; 3112| 574| size = ue_radio_capability_id_availability->length + sizeof(ue_radio_capability_id_availability->length); 3113| | 3114| 574| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3114:9): [True: 5, False: 569] ------------------ 3115| 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__) | | ------------------ ------------------ 3116| 5| return -1; 3117| 5| } 3118| | 3119| 569| if (sizeof(*ue_radio_capability_id_availability) < size) return -1; ------------------ | Branch (3119:9): [True: 4, False: 565] ------------------ 3120| 565| memcpy(ue_radio_capability_id_availability, pkbuf->data - size, size); 3121| | 3122| 565| ogs_trace(" UE_RADIO_CAPABILITY_ID_AVAILABILITY - "); ------------------ | | 40| 565|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 565| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 565|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 565| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 565|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 565| 0, __VA_ARGS__) | | ------------------ ------------------ 3123| 565| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 565| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 565|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3124| | 3125| 565| return size; 3126| 569|} ogs_nas_eps_decode_ue_radio_capability_id_request: 3146| 352|{ 3147| 352| int size = 0; 3148| 352| ogs_nas_ue_radio_capability_id_request_t *source = NULL; 3149| | 3150| 352| if (pkbuf->len < 1) { ------------------ | Branch (3150:9): [True: 6, False: 346] ------------------ 3151| 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__) | | ------------------ ------------------ 3152| 6| return -1; 3153| 6| } 3154| | 3155| 346| source = (ogs_nas_ue_radio_capability_id_request_t *)pkbuf->data; 3156| | 3157| 346| ue_radio_capability_id_request->length = source->length; 3158| 346| size = ue_radio_capability_id_request->length + sizeof(ue_radio_capability_id_request->length); 3159| | 3160| 346| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3160:9): [True: 1, False: 345] ------------------ 3161| 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__) | | ------------------ ------------------ 3162| 1| return -1; 3163| 1| } 3164| | 3165| 345| if (sizeof(*ue_radio_capability_id_request) < size) return -1; ------------------ | Branch (3165:9): [True: 1, False: 344] ------------------ 3166| 344| memcpy(ue_radio_capability_id_request, pkbuf->data - size, size); 3167| | 3168| 344| ogs_trace(" UE_RADIO_CAPABILITY_ID_REQUEST - "); ------------------ | | 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__) | | ------------------ ------------------ 3169| 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 | | ------------------ ------------------ 3170| | 3171| 344| return size; 3172| 345|} ogs_nas_eps_decode_daylight_saving_time: 3192| 537|{ 3193| 537| int size = 0; 3194| 537| ogs_nas_daylight_saving_time_t *source = NULL; 3195| | 3196| 537| if (pkbuf->len < 1) { ------------------ | Branch (3196:9): [True: 8, False: 529] ------------------ 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| 529| source = (ogs_nas_daylight_saving_time_t *)pkbuf->data; 3202| | 3203| 529| daylight_saving_time->length = source->length; 3204| 529| size = daylight_saving_time->length + sizeof(daylight_saving_time->length); 3205| | 3206| 529| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3206:9): [True: 4, False: 525] ------------------ 3207| 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__) | | ------------------ ------------------ 3208| 4| return -1; 3209| 4| } 3210| | 3211| 525| if (sizeof(*daylight_saving_time) < size) return -1; ------------------ | Branch (3211:9): [True: 1, False: 524] ------------------ 3212| 524| memcpy(daylight_saving_time, pkbuf->data - size, size); 3213| | 3214| 524| ogs_trace(" DAYLIGHT_SAVING_TIME - "); ------------------ | | 40| 524|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 524| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 524|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 524| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 524|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 524| 0, __VA_ARGS__) | | ------------------ ------------------ 3215| 524| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 524| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 524|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3216| | 3217| 524| return size; 3218| 525|} ogs_nas_eps_decode_ue_radio_capability_id: 3238| 1.18k|{ 3239| 1.18k| int size = 0; 3240| 1.18k| ogs_nas_ue_radio_capability_id_t *source = NULL; 3241| | 3242| 1.18k| if (pkbuf->len < 1) { ------------------ | Branch (3242:9): [True: 6, False: 1.17k] ------------------ 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.17k| source = (ogs_nas_ue_radio_capability_id_t *)pkbuf->data; 3248| | 3249| 1.17k| ue_radio_capability_id->length = source->length; 3250| 1.17k| size = ue_radio_capability_id->length + sizeof(ue_radio_capability_id->length); 3251| | 3252| 1.17k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3252:9): [True: 10, False: 1.16k] ------------------ 3253| 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__) | | ------------------ ------------------ 3254| 10| return -1; 3255| 10| } 3256| | 3257| 1.16k| if (sizeof(*ue_radio_capability_id) < size) return -1; ------------------ | Branch (3257:9): [True: 0, False: 1.16k] ------------------ 3258| 1.16k| memcpy(ue_radio_capability_id, pkbuf->data - size, size); 3259| | 3260| 1.16k| ogs_trace(" UE_RADIO_CAPABILITY_ID - "); ------------------ | | 40| 1.16k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.16k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.16k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.16k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.16k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.16k| 0, __VA_ARGS__) | | ------------------ ------------------ 3261| 1.16k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.16k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.16k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3262| | 3263| 1.16k| return size; 3264| 1.16k|} ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication: 3284| 2.87k|{ 3285| 2.87k| int size = sizeof(ogs_nas_ue_radio_capability_id_deletion_indication_t); 3286| | 3287| 2.87k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3287:9): [True: 0, False: 2.87k] ------------------ 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.87k| memcpy(ue_radio_capability_id_deletion_indication, pkbuf->data - size, size); 3293| | 3294| 2.87k| ogs_trace(" UE_RADIO_CAPABILITY_ID_DELETION_INDICATION - "); ------------------ | | 40| 2.87k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.87k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.87k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.87k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.87k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.87k| 0, __VA_ARGS__) | | ------------------ ------------------ 3295| 2.87k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.87k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.87k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3296| | 3297| 2.87k| return size; 3298| 2.87k|} ogs_nas_eps_decode_wus_assistance_information: 3316| 935|{ 3317| 935| int size = 0; 3318| 935| ogs_nas_wus_assistance_information_t *source = NULL; 3319| | 3320| 935| if (pkbuf->len < 1) { ------------------ | Branch (3320:9): [True: 6, False: 929] ------------------ 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| 929| source = (ogs_nas_wus_assistance_information_t *)pkbuf->data; 3326| | 3327| 929| wus_assistance_information->length = source->length; 3328| 929| size = wus_assistance_information->length + sizeof(wus_assistance_information->length); 3329| | 3330| 929| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3330:9): [True: 3, False: 926] ------------------ 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| 926| if (sizeof(*wus_assistance_information) < size) return -1; ------------------ | Branch (3335:9): [True: 0, False: 926] ------------------ 3336| 926| memcpy(wus_assistance_information, pkbuf->data - size, size); 3337| | 3338| 926| ogs_trace(" WUS_ASSISTANCE_INFORMATION - "); ------------------ | | 40| 926|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 926| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 926|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 926| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 926|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 926| 0, __VA_ARGS__) | | ------------------ ------------------ 3339| 926| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 926| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 926|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3340| | 3341| 926| return size; 3342| 926|} ogs_nas_eps_decode_nb_s1_drx_parameter: 3362| 1.00k|{ 3363| 1.00k| int size = 0; 3364| 1.00k| ogs_nas_nb_s1_drx_parameter_t *source = NULL; 3365| | 3366| 1.00k| if (pkbuf->len < 1) { ------------------ | Branch (3366:9): [True: 8, False: 995] ------------------ 3367| 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__) | | ------------------ ------------------ 3368| 8| return -1; 3369| 8| } 3370| | 3371| 995| source = (ogs_nas_nb_s1_drx_parameter_t *)pkbuf->data; 3372| | 3373| 995| nb_s1_drx_parameter->length = source->length; 3374| 995| size = nb_s1_drx_parameter->length + sizeof(nb_s1_drx_parameter->length); 3375| | 3376| 995| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3376:9): [True: 2, False: 993] ------------------ 3377| 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__) | | ------------------ ------------------ 3378| 2| return -1; 3379| 2| } 3380| | 3381| 993| if (sizeof(*nb_s1_drx_parameter) < size) return -1; ------------------ | Branch (3381:9): [True: 1, False: 992] ------------------ 3382| 992| memcpy(nb_s1_drx_parameter, pkbuf->data - size, size); 3383| | 3384| 992| ogs_trace(" NB_S1_DRX_PARAMETER - "); ------------------ | | 40| 992|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 992| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 992|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 992| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 992|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 992| 0, __VA_ARGS__) | | ------------------ ------------------ 3385| 992| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 992| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 992|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3386| | 3387| 992| return size; 3388| 993|} ogs_nas_eps_decode_imsi_offset: 3408| 909|{ 3409| 909| int size = 0; 3410| 909| ogs_nas_imsi_offset_t *source = NULL; 3411| | 3412| 909| if (pkbuf->len < 1) { ------------------ | Branch (3412:9): [True: 9, False: 900] ------------------ 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| 900| source = (ogs_nas_imsi_offset_t *)pkbuf->data; 3418| | 3419| 900| imsi_offset->length = source->length; 3420| 900| size = imsi_offset->length + sizeof(imsi_offset->length); 3421| | 3422| 900| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3422:9): [True: 1, False: 899] ------------------ 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| 899| if (sizeof(*imsi_offset) < size) return -1; ------------------ | Branch (3427:9): [True: 1, False: 898] ------------------ 3428| 898| memcpy(imsi_offset, pkbuf->data - size, size); 3429| | 3430| 898| ogs_trace(" IMSI_OFFSET - "); ------------------ | | 40| 898|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 898| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 898|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 898| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 898|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 898| 0, __VA_ARGS__) | | ------------------ ------------------ 3431| 898| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 898| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 898|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3432| | 3433| 898| return size; 3434| 899|} ogs_nas_eps_decode_ue_request_type: 3454| 644|{ 3455| 644| int size = 0; 3456| 644| ogs_nas_ue_request_type_t *source = NULL; 3457| | 3458| 644| if (pkbuf->len < 1) { ------------------ | Branch (3458:9): [True: 6, False: 638] ------------------ 3459| 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__) | | ------------------ ------------------ 3460| 6| return -1; 3461| 6| } 3462| | 3463| 638| source = (ogs_nas_ue_request_type_t *)pkbuf->data; 3464| | 3465| 638| ue_request_type->length = source->length; 3466| 638| size = ue_request_type->length + sizeof(ue_request_type->length); 3467| | 3468| 638| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3468:9): [True: 3, False: 635] ------------------ 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| 635| if (sizeof(*ue_request_type) < size) return -1; ------------------ | Branch (3473:9): [True: 6, False: 629] ------------------ 3474| 629| memcpy(ue_request_type, pkbuf->data - size, size); 3475| | 3476| 629| ogs_trace(" UE_REQUEST_TYPE - "); ------------------ | | 40| 629|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 629| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 629|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 629| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 629|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 629| 0, __VA_ARGS__) | | ------------------ ------------------ 3477| 629| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 629| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 629|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3478| | 3479| 629| return size; 3480| 635|} ogs_nas_eps_decode_paging_restriction: 3500| 633|{ 3501| 633| int size = 0; 3502| 633| ogs_nas_paging_restriction_t *source = NULL; 3503| | 3504| 633| if (pkbuf->len < 1) { ------------------ | Branch (3504:9): [True: 8, False: 625] ------------------ 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| 625| source = (ogs_nas_paging_restriction_t *)pkbuf->data; 3510| | 3511| 625| paging_restriction->length = source->length; 3512| 625| size = paging_restriction->length + sizeof(paging_restriction->length); 3513| | 3514| 625| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3514:9): [True: 6, False: 619] ------------------ 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| 619| if (sizeof(*paging_restriction) < size) return -1; ------------------ | Branch (3519:9): [True: 2, False: 617] ------------------ 3520| 617| memcpy(paging_restriction, pkbuf->data - size, size); 3521| | 3522| 617| ogs_trace(" PAGING_RESTRICTION - "); ------------------ | | 40| 617|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 617| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 617|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 617| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 617|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 617| 0, __VA_ARGS__) | | ------------------ ------------------ 3523| 617| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 617| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 617|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3524| | 3525| 617| return size; 3526| 619|} ogs_nas_eps_decode_eps_additional_request_result: 3546| 390|{ 3547| 390| int size = 0; 3548| 390| ogs_nas_eps_additional_request_result_t *source = NULL; 3549| | 3550| 390| if (pkbuf->len < 1) { ------------------ | Branch (3550:9): [True: 7, False: 383] ------------------ 3551| 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__) | | ------------------ ------------------ 3552| 7| return -1; 3553| 7| } 3554| | 3555| 383| source = (ogs_nas_eps_additional_request_result_t *)pkbuf->data; 3556| | 3557| 383| eps_additional_request_result->length = source->length; 3558| 383| size = eps_additional_request_result->length + sizeof(eps_additional_request_result->length); 3559| | 3560| 383| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3560:9): [True: 1, False: 382] ------------------ 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| 382| if (sizeof(*eps_additional_request_result) < size) return -1; ------------------ | Branch (3565:9): [True: 4, False: 378] ------------------ 3566| 378| memcpy(eps_additional_request_result, pkbuf->data - size, size); 3567| | 3568| 378| ogs_trace(" EPS_ADDITIONAL_REQUEST_RESULT - "); ------------------ | | 40| 378|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 378| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 378|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 378| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 378|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 378| 0, __VA_ARGS__) | | ------------------ ------------------ 3569| 378| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 378| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 378|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3570| | 3571| 378| return size; 3572| 382|} ogs_nas_eps_decode_unavailability_information: 3592| 389|{ 3593| 389| int size = 0; 3594| 389| ogs_nas_unavailability_information_t *source = NULL; 3595| | 3596| 389| if (pkbuf->len < 1) { ------------------ | Branch (3596:9): [True: 4, False: 385] ------------------ 3597| 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__) | | ------------------ ------------------ 3598| 4| return -1; 3599| 4| } 3600| | 3601| 385| source = (ogs_nas_unavailability_information_t *)pkbuf->data; 3602| | 3603| 385| unavailability_information->length = source->length; 3604| 385| size = unavailability_information->length + sizeof(unavailability_information->length); 3605| | 3606| 385| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3606:9): [True: 2, False: 383] ------------------ 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| 383| if (sizeof(*unavailability_information) < size) return -1; ------------------ | Branch (3611:9): [True: 2, False: 381] ------------------ 3612| 381| memcpy(unavailability_information, pkbuf->data - size, size); 3613| | 3614| 381| ogs_trace(" UNAVAILABILITY_INFORMATION - "); ------------------ | | 40| 381|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 381| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 381|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 381| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 381|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 381| 0, __VA_ARGS__) | | ------------------ ------------------ 3615| 381| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 381| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 381|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3616| | 3617| 381| return size; 3618| 383|} ogs_nas_eps_decode_detach_type: 3638| 8|{ 3639| 8| int size = sizeof(ogs_nas_detach_type_t); 3640| | 3641| 8| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3641:9): [True: 0, False: 8] ------------------ 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| 8| memcpy(detach_type, pkbuf->data - size, size); 3647| | 3648| 8| ogs_trace(" DETACH_TYPE - "); ------------------ | | 40| 8|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 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__) | | ------------------ ------------------ 3649| 8| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 8| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3650| | 3651| 8| return size; 3652| 8|} ogs_nas_eps_decode_unavailability_configuration: 3672| 487|{ 3673| 487| int size = 0; 3674| 487| ogs_nas_unavailability_configuration_t *source = NULL; 3675| | 3676| 487| if (pkbuf->len < 1) { ------------------ | Branch (3676:9): [True: 6, False: 481] ------------------ 3677| 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__) | | ------------------ ------------------ 3678| 6| return -1; 3679| 6| } 3680| | 3681| 481| source = (ogs_nas_unavailability_configuration_t *)pkbuf->data; 3682| | 3683| 481| unavailability_configuration->length = source->length; 3684| 481| size = unavailability_configuration->length + sizeof(unavailability_configuration->length); 3685| | 3686| 481| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3686:9): [True: 3, False: 478] ------------------ 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| 478| if (sizeof(*unavailability_configuration) < size) return -1; ------------------ | Branch (3691:9): [True: 3, False: 475] ------------------ 3692| 475| memcpy(unavailability_configuration, pkbuf->data - size, size); 3693| | 3694| 475| ogs_trace(" UNAVAILABILITY_CONFIGURATION - "); ------------------ | | 40| 475|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 475| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 475|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 475| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 475|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 475| 0, __VA_ARGS__) | | ------------------ ------------------ 3695| 475| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 475| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 475|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3696| | 3697| 475| return size; 3698| 478|} ogs_nas_eps_decode_ue_information_request: 3718| 453|{ 3719| 453| int size = sizeof(ogs_nas_ue_information_request_t); 3720| | 3721| 453| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3721:9): [True: 0, False: 453] ------------------ 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| 453| memcpy(ue_information_request, pkbuf->data - size, size); 3727| | 3728| 453| ogs_trace(" UE_INFORMATION_REQUEST - "); ------------------ | | 40| 453|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 453| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 453|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 453| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 453|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 453| 0, __VA_ARGS__) | | ------------------ ------------------ 3729| 453| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 453| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 453|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3730| | 3731| 453| return size; 3732| 453|} ogs_nas_eps_decode_ue_coarse_location_information: 3750| 273|{ 3751| 273| int size = 0; 3752| 273| ogs_nas_ue_coarse_location_information_t *source = NULL; 3753| | 3754| 273| if (pkbuf->len < 1) { ------------------ | Branch (3754:9): [True: 5, False: 268] ------------------ 3755| 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__) | | ------------------ ------------------ 3756| 5| return -1; 3757| 5| } 3758| | 3759| 268| source = (ogs_nas_ue_coarse_location_information_t *)pkbuf->data; 3760| | 3761| 268| ue_coarse_location_information->length = source->length; 3762| 268| size = ue_coarse_location_information->length + sizeof(ue_coarse_location_information->length); 3763| | 3764| 268| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3764:9): [True: 2, False: 266] ------------------ 3765| 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__) | | ------------------ ------------------ 3766| 2| return -1; 3767| 2| } 3768| | 3769| 266| if (sizeof(*ue_coarse_location_information) < size) return -1; ------------------ | Branch (3769:9): [True: 1, False: 265] ------------------ 3770| 265| memcpy(ue_coarse_location_information, pkbuf->data - size, size); 3771| | 3772| 265| ogs_trace(" UE_COARSE_LOCATION_INFORMATION - "); ------------------ | | 40| 265|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 265| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 265|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 265| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 265|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 265| 0, __VA_ARGS__) | | ------------------ ------------------ 3773| 265| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 265| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 265|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3774| | 3775| 265| return size; 3776| 266|} ogs_nas_eps_decode_registration_wait_range: 3796| 1.43k|{ 3797| 1.43k| int size = 0; 3798| 1.43k| ogs_nas_registration_wait_range_t *source = NULL; 3799| | 3800| 1.43k| if (pkbuf->len < 1) { ------------------ | Branch (3800:9): [True: 6, False: 1.42k] ------------------ 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.42k| source = (ogs_nas_registration_wait_range_t *)pkbuf->data; 3806| | 3807| 1.42k| registration_wait_range->length = source->length; 3808| 1.42k| size = registration_wait_range->length + sizeof(registration_wait_range->length); 3809| | 3810| 1.42k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3810:9): [True: 8, False: 1.41k] ------------------ 3811| 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__) | | ------------------ ------------------ 3812| 8| return -1; 3813| 8| } 3814| | 3815| 1.41k| if (sizeof(*registration_wait_range) < size) return -1; ------------------ | Branch (3815:9): [True: 2, False: 1.41k] ------------------ 3816| 1.41k| memcpy(registration_wait_range, pkbuf->data - size, size); 3817| | 3818| 1.41k| ogs_trace(" REGISTRATION_WAIT_RANGE - "); ------------------ | | 40| 1.41k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.41k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.41k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.41k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.41k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.41k| 0, __VA_ARGS__) | | ------------------ ------------------ 3819| 1.41k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.41k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.41k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3820| | 3821| 1.41k| return size; 3822| 1.41k|} ogs_nas_eps_decode_plmn_identity: 3842| 556|{ 3843| 556| int size = 0; 3844| 556| ogs_nas_plmn_identity_t *source = NULL; 3845| | 3846| 556| if (pkbuf->len < 1) { ------------------ | Branch (3846:9): [True: 4, False: 552] ------------------ 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| 552| source = (ogs_nas_plmn_identity_t *)pkbuf->data; 3852| | 3853| 552| plmn_identity->length = source->length; 3854| 552| size = plmn_identity->length + sizeof(plmn_identity->length); 3855| | 3856| 552| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3856:9): [True: 2, False: 550] ------------------ 3857| 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__) | | ------------------ ------------------ 3858| 2| return -1; 3859| 2| } 3860| | 3861| 550| if (sizeof(*plmn_identity) < size) return -1; ------------------ | Branch (3861:9): [True: 3, False: 547] ------------------ 3862| 547| memcpy(plmn_identity, pkbuf->data - size, size); 3863| | 3864| 547| ogs_trace(" PLMN_IDENTITY - "); ------------------ | | 40| 547|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 547| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 547|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 547| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 547|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 547| 0, __VA_ARGS__) | | ------------------ ------------------ 3865| 547| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 547| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 547|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3866| | 3867| 547| return size; 3868| 550|} ogs_nas_eps_decode_drx_parameter: 3888| 655|{ 3889| 655| int size = sizeof(ogs_nas_drx_parameter_t); 3890| | 3891| 655| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3891:9): [True: 8, False: 647] ------------------ 3892| 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__) | | ------------------ ------------------ 3893| 8| return -1; 3894| 8| } 3895| | 3896| 647| memcpy(drx_parameter, pkbuf->data - size, size); 3897| | 3898| 647| ogs_trace(" DRX_PARAMETER - "); ------------------ | | 40| 647|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 647| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 647|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 647| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 647|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 647| 0, __VA_ARGS__) | | ------------------ ------------------ 3899| 647| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 647| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 647|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3900| | 3901| 647| return size; 3902| 655|} ogs_nas_eps_decode_emm_cause: 3922| 1.49k|{ 3923| 1.49k| int size = sizeof(ogs_nas_emm_cause_t); 3924| | 3925| 1.49k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3925:9): [True: 8, False: 1.48k] ------------------ 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.48k| memcpy(emm_cause, pkbuf->data - size, size); 3931| | 3932| 1.48k| ogs_trace(" EMM_CAUSE - "); ------------------ | | 40| 1.48k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.48k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.48k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.48k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.48k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.48k| 0, __VA_ARGS__) | | ------------------ ------------------ 3933| 1.48k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.48k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.48k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3934| | 3935| 1.48k| return size; 3936| 1.49k|} ogs_nas_eps_decode_header_compression_configuration_status: 4617| 373|{ 4618| 373| int size = 0; 4619| 373| ogs_nas_header_compression_configuration_status_t *source = NULL; 4620| | 4621| 373| if (pkbuf->len < 1) { ------------------ | Branch (4621:9): [True: 7, False: 366] ------------------ 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| 366| source = (ogs_nas_header_compression_configuration_status_t *)pkbuf->data; 4627| | 4628| 366| header_compression_configuration_status->length = source->length; 4629| 366| size = header_compression_configuration_status->length + sizeof(header_compression_configuration_status->length); 4630| | 4631| 366| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (4631:9): [True: 1, False: 365] ------------------ 4632| 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__) | | ------------------ ------------------ 4633| 1| return -1; 4634| 1| } 4635| | 4636| 365| if (sizeof(*header_compression_configuration_status) < size) return -1; ------------------ | Branch (4636:9): [True: 1, False: 364] ------------------ 4637| 364| memcpy(header_compression_configuration_status, pkbuf->data - size, size); 4638| | 4639| 364| ogs_trace(" HEADER_COMPRESSION_CONFIGURATION_STATUS - "); ------------------ | | 40| 364|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 364| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 364|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 364| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 364|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 364| 0, __VA_ARGS__) | | ------------------ ------------------ 4640| 364| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 364| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 364|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 4641| | 4642| 364| return size; 4643| 365|} ogs_nas_eps_decode_s_f_satellite_operation_parameters: 5105| 1.24k|{ 5106| 1.24k| int size = 0; 5107| 1.24k| ogs_nas_s_f_satellite_operation_parameters_t *source = NULL; 5108| | 5109| 1.24k| if (pkbuf->len < 1) { ------------------ | Branch (5109:9): [True: 7, False: 1.24k] ------------------ 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.24k| source = (ogs_nas_s_f_satellite_operation_parameters_t *)pkbuf->data; 5115| | 5116| 1.24k| s_f_satellite_operation_parameters->length = source->length; 5117| 1.24k| size = s_f_satellite_operation_parameters->length + sizeof(s_f_satellite_operation_parameters->length); 5118| | 5119| 1.24k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (5119:9): [True: 8, False: 1.23k] ------------------ 5120| 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__) | | ------------------ ------------------ 5121| 8| return -1; 5122| 8| } 5123| | 5124| 1.23k| if (sizeof(*s_f_satellite_operation_parameters) < size) return -1; ------------------ | Branch (5124:9): [True: 1, False: 1.23k] ------------------ 5125| 1.23k| memcpy(s_f_satellite_operation_parameters, pkbuf->data - size, size); 5126| | 5127| 1.23k| ogs_trace(" S_F_SATELLITE_OPERATION_PARAMETERS - "); ------------------ | | 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__) | | ------------------ ------------------ 5128| 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 | | ------------------ ------------------ 5129| | 5130| 1.23k| return size; 5131| 1.23k|} 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.96k|{ /* open5gs/tests/unit/nas-message-test.c */ 31| | 32| 3.96k| if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 26| 7.93k|#define kMinInputLength 5 ------------------ if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 27| 3.96k|#define kMaxInputLength 1024 ------------------ | Branch (32:9): [True: 4, False: 3.96k] | Branch (32:35): [True: 21, False: 3.94k] ------------------ 33| 25| return 1; 34| 25| } 35| | 36| 3.94k| if (!initialized) { ------------------ | Branch (36:9): [True: 1, False: 3.93k] ------------------ 37| 1| initialize(); 38| 1| ogs_log_install_domain(&__ogs_nas_domain, "nas", OGS_LOG_NONE); 39| 1| } 40| | 41| 3.94k| int result; 42| 3.94k| ogs_pkbuf_t *pkbuf; 43| 3.94k| ogs_nas_eps_message_t message; 44| | 45| 3.94k| pkbuf = ogs_pkbuf_alloc(NULL, OGS_MAX_SDU_LEN); ------------------ | | 87| 3.94k| ogs_pkbuf_alloc_debug(pool, size, OGS_FILE_LINE) | | ------------------ | | | | 213| 3.94k|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 167| 3.94k|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 168| 3.94k|#define OGS_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 46| 3.94k| if (pkbuf == NULL) { ------------------ | Branch (46:9): [True: 0, False: 3.94k] ------------------ 47| 0| return 1; 48| 0| } 49| | 50| 3.94k| ogs_pkbuf_put_data(pkbuf, Data, Size); 51| | 52| 3.94k| result = ogs_nas_emm_decode(&message, pkbuf); 53| | 54| 3.94k| ogs_pkbuf_free(pkbuf); 55| | 56| 3.94k| return result; 57| 3.94k|}