/* * Copyright (C) 2019,2020 by Sukchan Lee * * This file is part of Open5GS. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "test-config-private.h" #include "test-common.h" static test_context_t self; static OGS_POOL(test_ue_pool, test_ue_t); static OGS_POOL(test_sess_pool, test_sess_t); static OGS_POOL(test_bearer_pool, test_bearer_t); static int context_initialized = 0; void test_context_init(void) { int rv; ogs_assert(context_initialized == 0); /* Initialize AMF context */ memset(&self, 0, sizeof(test_context_t)); ogs_pool_init(&test_ue_pool, ogs_app()->max.ue); ogs_pool_init(&test_sess_pool, ogs_app()->pool.sess); ogs_pool_init(&test_bearer_pool, ogs_app()->pool.bearer); rv = ogs_getaddrinfo(&test_self()->gnb1_addr, AF_UNSPEC, "127.0.0.2", OGS_GTPV1_U_UDP_PORT, 0); ogs_assert(rv == OGS_OK); rv = ogs_getaddrinfo(&test_self()->gnb2_addr, AF_UNSPEC, "127.0.0.3", OGS_GTPV1_U_UDP_PORT, 0); ogs_assert(rv == OGS_OK); context_initialized = 1; } void test_context_final(void) { ogs_assert(context_initialized == 1); ogs_socknode_remove_all(&self.ngap_list); ogs_socknode_remove_all(&self.ngap_list6); ogs_socknode_remove_all(&self.s1ap_list); ogs_socknode_remove_all(&self.s1ap_list6); ogs_freeaddrinfo(test_self()->gnb1_addr); ogs_freeaddrinfo(test_self()->gnb2_addr); ogs_pool_final(&test_ue_pool); ogs_pool_final(&test_bearer_pool); ogs_pool_final(&test_sess_pool); context_initialized = 0; } test_context_t *test_self(void) { return &self; } static int test_context_prepare(void) { self.s1ap_port = OGS_S1AP_SCTP_PORT; self.ngap_port = OGS_NGAP_SCTP_PORT; return OGS_OK; } static int test_context_validation(void) { ogs_socknode_t *snode = NULL; snode = ogs_list_first(&test_self()->s1ap_list); if (snode) test_self()->s1ap_addr = snode->addr; snode = ogs_list_first(&test_self()->s1ap_list6); if (snode) test_self()->s1ap_addr6 = snode->addr; snode = ogs_list_first(&test_self()->ngap_list); if (snode) test_self()->ngap_addr = snode->addr; snode = ogs_list_first(&test_self()->ngap_list6); if (snode) test_self()->ngap_addr6 = snode->addr; if (test_self()->e_served_tai[0].list2.num) { memcpy(&test_self()->e_tai, &test_self()->e_served_tai[0].list2.tai[0], sizeof(ogs_5gs_tai_t)); } else if (test_self()->e_served_tai[0].list0.tai[0].num) { test_self()->e_tai.tac = test_self()->e_served_tai[0].list0.tai[0].tac[0]; memcpy(&test_self()->e_tai.plmn_id, &test_self()->e_served_tai[0].list0.tai[0].plmn_id, OGS_PLMN_ID_LEN); } if (test_self()->nr_served_tai[0].list2.num) { memcpy(&test_self()->nr_tai, &test_self()->nr_served_tai[0].list2.tai[0], sizeof(ogs_5gs_tai_t)); } else if (test_self()->nr_served_tai[0].list0.tai[0].num) { test_self()->nr_tai.tac = test_self()->nr_served_tai[0].list0.tai[0].tac[0]; memcpy(&test_self()->nr_tai.plmn_id, &test_self()->nr_served_tai[0].list0.tai[0].plmn_id, OGS_PLMN_ID_LEN); } memcpy(&test_self()->nr_cgi.plmn_id, &test_self()->nr_tai.plmn_id, OGS_PLMN_ID_LEN); test_self()->nr_cgi.cell_id = 0x40001; return OGS_OK; } int test_context_parse_config(void) { int rv; yaml_document_t *document = NULL; ogs_yaml_iter_t root_iter; document = ogs_app()->document; ogs_assert(document); rv = test_context_prepare(); if (rv != OGS_OK) return rv; ogs_yaml_iter_init(&root_iter, document); while (ogs_yaml_iter_next(&root_iter)) { const char *root_key = ogs_yaml_iter_key(&root_iter); ogs_assert(root_key); if (!strcmp(root_key, "amf")) { ogs_yaml_iter_t amf_iter; ogs_yaml_iter_recurse(&root_iter, &amf_iter); while (ogs_yaml_iter_next(&amf_iter)) { const char *amf_key = ogs_yaml_iter_key(&amf_iter); ogs_assert(amf_key); if (!strcmp(amf_key, "ngap")) { ogs_yaml_iter_t ngap_array, ngap_iter; ogs_yaml_iter_recurse(&amf_iter, &ngap_array); do { int family = AF_UNSPEC; int i, num = 0; const char *hostname[OGS_MAX_NUM_OF_HOSTNAME]; uint16_t port = self.ngap_port; const char *dev = NULL; ogs_sockaddr_t *addr = NULL; if (ogs_yaml_iter_type(&ngap_array) == YAML_MAPPING_NODE) { memcpy(&ngap_iter, &ngap_array, sizeof(ogs_yaml_iter_t)); } else if (ogs_yaml_iter_type(&ngap_array) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&ngap_array)) break; ogs_yaml_iter_recurse(&ngap_array, &ngap_iter); } else if (ogs_yaml_iter_type(&ngap_array) == YAML_SCALAR_NODE) { break; } else ogs_assert_if_reached(); while (ogs_yaml_iter_next(&ngap_iter)) { const char *ngap_key = ogs_yaml_iter_key(&ngap_iter); ogs_assert(ngap_key); if (!strcmp(ngap_key, "family")) { const char *v = ogs_yaml_iter_value(&ngap_iter); if (v) family = atoi(v); if (family != AF_UNSPEC && family != AF_INET && family != AF_INET6) { ogs_warn("Ignore family(%d) : " "AF_UNSPEC(%d), " "AF_INET(%d), AF_INET6(%d) ", family, AF_UNSPEC, AF_INET, AF_INET6); family = AF_UNSPEC; } } else if (!strcmp(ngap_key, "addr") || !strcmp(ngap_key, "name")) { ogs_yaml_iter_t hostname_iter; ogs_yaml_iter_recurse( &ngap_iter, &hostname_iter); ogs_assert(ogs_yaml_iter_type(&hostname_iter) != YAML_MAPPING_NODE); do { if (ogs_yaml_iter_type(&hostname_iter) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&hostname_iter)) break; } ogs_assert(num <= OGS_MAX_NUM_OF_HOSTNAME); hostname[num++] = ogs_yaml_iter_value(&hostname_iter); } while ( ogs_yaml_iter_type(&hostname_iter) == YAML_SEQUENCE_NODE); } else if (!strcmp(ngap_key, "port")) { const char *v = ogs_yaml_iter_value(&ngap_iter); if (v) port = atoi(v); } else if (!strcmp(ngap_key, "dev")) { dev = ogs_yaml_iter_value(&ngap_iter); } else ogs_warn("unknown key `%s`", ngap_key); } addr = NULL; for (i = 0; i < num; i++) { rv = ogs_addaddrinfo(&addr, family, hostname[i], port, 0); ogs_assert(rv == OGS_OK); } if (addr) { if (ogs_app()->parameter.no_ipv4 == 0) ogs_socknode_add( &self.ngap_list, AF_INET, addr); if (ogs_app()->parameter.no_ipv6 == 0) ogs_socknode_add( &self.ngap_list6, AF_INET6, addr); ogs_freeaddrinfo(addr); } if (dev) { rv = ogs_socknode_probe( ogs_app()->parameter.no_ipv4 ? NULL : &self.ngap_list, ogs_app()->parameter.no_ipv6 ? NULL : &self.ngap_list6, dev, port); ogs_assert(rv == OGS_OK); } } while (ogs_yaml_iter_type(&ngap_array) == YAML_SEQUENCE_NODE); if (ogs_list_first(&self.ngap_list) == NULL && ogs_list_first(&self.ngap_list6) == NULL) { rv = ogs_socknode_probe( ogs_app()->parameter.no_ipv4 ? NULL : &self.ngap_list, ogs_app()->parameter.no_ipv6 ? NULL : &self.ngap_list6, NULL, self.ngap_port); ogs_assert(rv == OGS_OK); } } if (!strcmp(amf_key, "tai")) { int num_of_list0 = 0; ogs_5gs_tai0_list_t *list0 = NULL; ogs_5gs_tai2_list_t *list2 = NULL; ogs_assert(self.num_of_nr_served_tai <= OGS_MAX_NUM_OF_SERVED_TAI); list0 = &self.nr_served_tai[self.num_of_nr_served_tai].list0; ogs_assert(list0); list2 = &self.nr_served_tai[self.num_of_nr_served_tai].list2; ogs_assert(list2); ogs_yaml_iter_t tai_array, tai_iter; ogs_yaml_iter_recurse(&amf_iter, &tai_array); do { const char *mcc = NULL, *mnc = NULL; ogs_uint24_t tac[OGS_MAX_NUM_OF_TAI]; int num_of_tac = 0; if (ogs_yaml_iter_type(&tai_array) == YAML_MAPPING_NODE) { memcpy(&tai_iter, &tai_array, sizeof(ogs_yaml_iter_t)); } else if (ogs_yaml_iter_type(&tai_array) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&tai_array)) break; ogs_yaml_iter_recurse(&tai_array, &tai_iter); } else if (ogs_yaml_iter_type(&tai_array) == YAML_SCALAR_NODE) { break; } else ogs_assert_if_reached(); while (ogs_yaml_iter_next(&tai_iter)) { const char *tai_key = ogs_yaml_iter_key(&tai_iter); ogs_assert(tai_key); if (!strcmp(tai_key, "plmn_id")) { ogs_yaml_iter_t plmn_id_iter; ogs_yaml_iter_recurse(&tai_iter, &plmn_id_iter); while (ogs_yaml_iter_next(&plmn_id_iter)) { const char *plmn_id_key = ogs_yaml_iter_key(&plmn_id_iter); ogs_assert(plmn_id_key); if (!strcmp(plmn_id_key, "mcc")) { mcc = ogs_yaml_iter_value( &plmn_id_iter); } else if (!strcmp(plmn_id_key, "mnc")) { mnc = ogs_yaml_iter_value( &plmn_id_iter); } } } else if (!strcmp(tai_key, "tac")) { ogs_yaml_iter_t tac_iter; ogs_yaml_iter_recurse(&tai_iter, &tac_iter); ogs_assert(ogs_yaml_iter_type(&tac_iter) != YAML_MAPPING_NODE); do { const char *v = NULL; ogs_assert(num_of_tac <= OGS_MAX_NUM_OF_TAI); if (ogs_yaml_iter_type(&tac_iter) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&tac_iter)) break; } v = ogs_yaml_iter_value(&tac_iter); if (v) { tac[num_of_tac].v = atoi(v); num_of_tac++; } } while ( ogs_yaml_iter_type(&tac_iter) == YAML_SEQUENCE_NODE); } else ogs_warn("unknown key `%s`", tai_key); } if (mcc && mnc && num_of_tac) { if (num_of_tac == 1) { ogs_plmn_id_build( &list2->tai[list2->num].plmn_id, atoi(mcc), atoi(mnc), strlen(mnc)); list2->tai[list2->num].tac.v = tac[0].v; list2->num++; if (list2->num > 1) list2->type = OGS_TAI2_TYPE; else list2->type = OGS_TAI1_TYPE; } else if (num_of_tac > 1) { int i; ogs_plmn_id_build( &list0->tai[num_of_list0].plmn_id, atoi(mcc), atoi(mnc), strlen(mnc)); for (i = 0; i < num_of_tac; i++) { list0->tai[num_of_list0].tac[i].v = tac[i].v; } list0->tai[num_of_list0].num = num_of_tac; list0->tai[num_of_list0].type = OGS_TAI0_TYPE; num_of_list0++; } } else { ogs_warn("Ignore tai : mcc(%p), mnc(%p), " "num_of_tac(%d)", mcc, mnc, num_of_tac); } } while (ogs_yaml_iter_type(&tai_array) == YAML_SEQUENCE_NODE); if (list2->num || num_of_list0) { self.num_of_nr_served_tai++; } } else if (!strcmp(amf_key, "plmn_support")) { ogs_yaml_iter_t plmn_support_array, plmn_support_iter; ogs_yaml_iter_recurse(&amf_iter, &plmn_support_array); do { const char *mnc = NULL, *mcc = NULL; ogs_assert(self.num_of_plmn_support <= OGS_MAX_NUM_OF_PLMN); if (ogs_yaml_iter_type(&plmn_support_array) == YAML_MAPPING_NODE) { memcpy(&plmn_support_iter, &plmn_support_array, sizeof(ogs_yaml_iter_t)); } else if (ogs_yaml_iter_type(&plmn_support_array) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&plmn_support_array)) break; ogs_yaml_iter_recurse(&plmn_support_array, &plmn_support_iter); } else if (ogs_yaml_iter_type(&plmn_support_array) == YAML_SCALAR_NODE) { break; } else ogs_assert_if_reached(); while (ogs_yaml_iter_next(&plmn_support_iter)) { const char *plmn_support_key = ogs_yaml_iter_key(&plmn_support_iter); ogs_assert(plmn_support_key); if (!strcmp(plmn_support_key, "plmn_id")) { ogs_yaml_iter_t plmn_id_iter; ogs_yaml_iter_recurse(&plmn_support_iter, &plmn_id_iter); while (ogs_yaml_iter_next(&plmn_id_iter)) { const char *plmn_id_key = ogs_yaml_iter_key(&plmn_id_iter); ogs_assert(plmn_id_key); if (!strcmp(plmn_id_key, "mcc")) { mcc = ogs_yaml_iter_value( &plmn_id_iter); } else if (!strcmp(plmn_id_key, "mnc")) { mnc = ogs_yaml_iter_value( &plmn_id_iter); } } if (mcc && mnc) { ogs_plmn_id_build( &self.plmn_support[ self.num_of_plmn_support]. plmn_id, atoi(mcc), atoi(mnc), strlen(mnc)); } } else if (!strcmp(plmn_support_key, "s_nssai")) { ogs_yaml_iter_t s_nssai_array, s_nssai_iter; ogs_yaml_iter_recurse(&plmn_support_iter, &s_nssai_array); do { ogs_s_nssai_t *s_nssai = NULL; const char *sst = NULL, *sd = NULL; ogs_assert( self.plmn_support[ self.num_of_plmn_support]. num_of_s_nssai <= OGS_MAX_NUM_OF_SLICE); s_nssai = &self.plmn_support[ self.num_of_plmn_support].s_nssai[ self.plmn_support[ self.num_of_plmn_support]. num_of_s_nssai]; ogs_assert(s_nssai); if (ogs_yaml_iter_type(&s_nssai_array) == YAML_MAPPING_NODE) { memcpy(&s_nssai_iter, &s_nssai_array, sizeof(ogs_yaml_iter_t)); } else if (ogs_yaml_iter_type( &s_nssai_array) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&s_nssai_array)) break; ogs_yaml_iter_recurse(&s_nssai_array, &s_nssai_iter); } else if (ogs_yaml_iter_type( &s_nssai_array) == YAML_SCALAR_NODE) { break; } else ogs_assert_if_reached(); while (ogs_yaml_iter_next(&s_nssai_iter)) { const char *s_nssai_key = ogs_yaml_iter_key(&s_nssai_iter); ogs_assert(s_nssai_key); if (!strcmp(s_nssai_key, "sst")) { sst = ogs_yaml_iter_value( &s_nssai_iter); } else if (!strcmp( s_nssai_key, "sd")) { sd = ogs_yaml_iter_value( &s_nssai_iter); } } if (sst) { s_nssai->sst = atoi(sst); if (sd) s_nssai->sd = ogs_uint24_from_string( (char*)sd); else s_nssai->sd.v = OGS_S_NSSAI_NO_SD_VALUE; self.plmn_support[ self.num_of_plmn_support]. num_of_s_nssai++; } } while (ogs_yaml_iter_type(&s_nssai_array) == YAML_SEQUENCE_NODE); } else ogs_warn("unknown key `%s`", plmn_support_key); } if (self.plmn_support[ self.num_of_plmn_support].num_of_s_nssai && mcc && mnc) { self.num_of_plmn_support++; } else { ogs_warn("Ignore plmn : " "s_nssai(%d) mcc(%s), mnc(%s)", self.plmn_support[ self.num_of_plmn_support].num_of_s_nssai, mcc, mnc); self.plmn_support[ self.num_of_plmn_support].num_of_s_nssai = 0; } } while (ogs_yaml_iter_type(&plmn_support_array) == YAML_SEQUENCE_NODE); } else if (!strcmp(amf_key, "sbi")) { /* handle config in sbi library */ } else ogs_warn("unknown key `%s`", amf_key); } } else if (!strcmp(root_key, "mme")) { ogs_yaml_iter_t mme_iter; ogs_yaml_iter_recurse(&root_iter, &mme_iter); while (ogs_yaml_iter_next(&mme_iter)) { const char *mme_key = ogs_yaml_iter_key(&mme_iter); ogs_assert(mme_key); if (!strcmp(mme_key, "s1ap")) { ogs_yaml_iter_t s1ap_array, s1ap_iter; ogs_yaml_iter_recurse(&mme_iter, &s1ap_array); do { int family = AF_UNSPEC; int i, num = 0; const char *hostname[OGS_MAX_NUM_OF_HOSTNAME]; uint16_t port = self.s1ap_port; const char *dev = NULL; ogs_sockaddr_t *addr = NULL; if (ogs_yaml_iter_type(&s1ap_array) == YAML_MAPPING_NODE) { memcpy(&s1ap_iter, &s1ap_array, sizeof(ogs_yaml_iter_t)); } else if (ogs_yaml_iter_type(&s1ap_array) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&s1ap_array)) break; ogs_yaml_iter_recurse(&s1ap_array, &s1ap_iter); } else if (ogs_yaml_iter_type(&s1ap_array) == YAML_SCALAR_NODE) { break; } else ogs_assert_if_reached(); while (ogs_yaml_iter_next(&s1ap_iter)) { const char *s1ap_key = ogs_yaml_iter_key(&s1ap_iter); ogs_assert(s1ap_key); if (!strcmp(s1ap_key, "family")) { const char *v = ogs_yaml_iter_value(&s1ap_iter); if (v) family = atoi(v); if (family != AF_UNSPEC && family != AF_INET && family != AF_INET6) { ogs_warn("Ignore family(%d) : " "AF_UNSPEC(%d), " "AF_INET(%d), AF_INET6(%d) ", family, AF_UNSPEC, AF_INET, AF_INET6); family = AF_UNSPEC; } } else if (!strcmp(s1ap_key, "addr") || !strcmp(s1ap_key, "name")) { ogs_yaml_iter_t hostname_iter; ogs_yaml_iter_recurse( &s1ap_iter, &hostname_iter); ogs_assert(ogs_yaml_iter_type(&hostname_iter) != YAML_MAPPING_NODE); do { if (ogs_yaml_iter_type(&hostname_iter) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&hostname_iter)) break; } ogs_assert(num <= OGS_MAX_NUM_OF_HOSTNAME); hostname[num++] = ogs_yaml_iter_value(&hostname_iter); } while ( ogs_yaml_iter_type(&hostname_iter) == YAML_SEQUENCE_NODE); } else if (!strcmp(s1ap_key, "port")) { const char *v = ogs_yaml_iter_value(&s1ap_iter); if (v) port = atoi(v); } else if (!strcmp(s1ap_key, "dev")) { dev = ogs_yaml_iter_value(&s1ap_iter); } else ogs_warn("unknown key `%s`", s1ap_key); } addr = NULL; for (i = 0; i < num; i++) { rv = ogs_addaddrinfo(&addr, family, hostname[i], port, 0); ogs_assert(rv == OGS_OK); } if (addr) { if (ogs_app()->parameter.no_ipv4 == 0) ogs_socknode_add( &self.s1ap_list, AF_INET, addr); if (ogs_app()->parameter.no_ipv6 == 0) ogs_socknode_add( &self.s1ap_list6, AF_INET6, addr); ogs_freeaddrinfo(addr); } if (dev) { rv = ogs_socknode_probe( ogs_app()->parameter.no_ipv4 ? NULL : &self.s1ap_list, ogs_app()->parameter.no_ipv6 ? NULL : &self.s1ap_list6, dev, port); ogs_assert(rv == OGS_OK); } } while (ogs_yaml_iter_type(&s1ap_array) == YAML_SEQUENCE_NODE); if (ogs_list_first(&self.s1ap_list) == NULL && ogs_list_first(&self.s1ap_list6) == NULL) { rv = ogs_socknode_probe( ogs_app()->parameter.no_ipv4 ? NULL : &self.s1ap_list, ogs_app()->parameter.no_ipv6 ? NULL : &self.s1ap_list6, NULL, self.s1ap_port); ogs_assert(rv == OGS_OK); } } else if (!strcmp(mme_key, "tai")) { int num_of_list0 = 0; ogs_eps_tai0_list_t *list0 = NULL; ogs_eps_tai2_list_t *list2 = NULL; ogs_assert(self.num_of_e_served_tai <= OGS_MAX_NUM_OF_SERVED_TAI); list0 = &self.e_served_tai[self.num_of_e_served_tai].list0; ogs_assert(list0); list2 = &self.e_served_tai[self.num_of_e_served_tai].list2; ogs_assert(list2); ogs_yaml_iter_t tai_array, tai_iter; ogs_yaml_iter_recurse(&mme_iter, &tai_array); do { const char *mcc = NULL, *mnc = NULL; uint16_t tac[OGS_MAX_NUM_OF_TAI]; int num_of_tac = 0; if (ogs_yaml_iter_type(&tai_array) == YAML_MAPPING_NODE) { memcpy(&tai_iter, &tai_array, sizeof(ogs_yaml_iter_t)); } else if (ogs_yaml_iter_type(&tai_array) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&tai_array)) break; ogs_yaml_iter_recurse(&tai_array, &tai_iter); } else if (ogs_yaml_iter_type(&tai_array) == YAML_SCALAR_NODE) { break; } else ogs_assert_if_reached(); while (ogs_yaml_iter_next(&tai_iter)) { const char *tai_key = ogs_yaml_iter_key(&tai_iter); ogs_assert(tai_key); if (!strcmp(tai_key, "plmn_id")) { ogs_yaml_iter_t plmn_id_iter; ogs_yaml_iter_recurse(&tai_iter, &plmn_id_iter); while (ogs_yaml_iter_next(&plmn_id_iter)) { const char *plmn_id_key = ogs_yaml_iter_key(&plmn_id_iter); ogs_assert(plmn_id_key); if (!strcmp(plmn_id_key, "mcc")) { mcc = ogs_yaml_iter_value( &plmn_id_iter); } else if (!strcmp(plmn_id_key, "mnc")) { mnc = ogs_yaml_iter_value( &plmn_id_iter); } } } else if (!strcmp(tai_key, "tac")) { ogs_yaml_iter_t tac_iter; ogs_yaml_iter_recurse(&tai_iter, &tac_iter); ogs_assert(ogs_yaml_iter_type(&tac_iter) != YAML_MAPPING_NODE); do { const char *v = NULL; ogs_assert(num_of_tac <= OGS_MAX_NUM_OF_TAI); if (ogs_yaml_iter_type(&tac_iter) == YAML_SEQUENCE_NODE) { if (!ogs_yaml_iter_next(&tac_iter)) break; } v = ogs_yaml_iter_value(&tac_iter); if (v) { tac[num_of_tac] = atoi(v); num_of_tac++; } } while ( ogs_yaml_iter_type(&tac_iter) == YAML_SEQUENCE_NODE); } else ogs_warn("unknown key `%s`", tai_key); } if (mcc && mnc && num_of_tac) { if (num_of_tac == 1) { ogs_plmn_id_build( &list2->tai[list2->num].plmn_id, atoi(mcc), atoi(mnc), strlen(mnc)); list2->tai[list2->num].tac = tac[0]; list2->num++; if (list2->num > 1) list2->type = OGS_TAI2_TYPE; else list2->type = OGS_TAI1_TYPE; } else if (num_of_tac > 1) { int i; ogs_plmn_id_build( &list0->tai[num_of_list0].plmn_id, atoi(mcc), atoi(mnc), strlen(mnc)); for (i = 0; i < num_of_tac; i++) { list0->tai[num_of_list0].tac[i] = tac[i]; } list0->tai[num_of_list0].num = num_of_tac; list0->tai[num_of_list0].type = OGS_TAI0_TYPE; num_of_list0++; } } else { ogs_warn("Ignore tai : mcc(%p), mnc(%p), " "num_of_tac(%d)", mcc, mnc, num_of_tac); } } while (ogs_yaml_iter_type(&tai_array) == YAML_SEQUENCE_NODE); if (list2->num || num_of_list0) { self.num_of_e_served_tai++; } } } } } rv = test_context_validation(); if (rv != OGS_OK) return rv; return OGS_OK; } void test_ue_set_mobile_identity_suci(test_ue_t *test_ue, ogs_nas_5gs_mobile_identity_suci_t *mobile_identity_suci, uint16_t mobile_identity_suci_length) { ogs_nas_5gs_mobile_identity_t mobile_identity; ogs_assert(test_ue); ogs_assert(mobile_identity_suci); ogs_assert(mobile_identity_suci_length); test_ue->mobile_identity_suci_length = mobile_identity_suci_length; memcpy(&test_ue->mobile_identity_suci, mobile_identity_suci, mobile_identity_suci_length); mobile_identity.length = test_ue->mobile_identity_suci_length; mobile_identity.buffer = &test_ue->mobile_identity_suci; if (test_ue->suci) ogs_free(test_ue->suci); test_ue->suci = ogs_nas_5gs_suci_from_mobile_identity(&mobile_identity); if (test_ue->supi) ogs_free(test_ue->supi); test_ue->supi = ogs_supi_from_suci(test_ue->suci); ogs_assert(test_ue->supi); if (test_ue->imsi) ogs_free(test_ue->imsi); test_ue->imsi = ogs_id_get_value(test_ue->supi); ogs_assert(test_ue->imsi); ogs_bcd_to_buffer(test_ue->imsi, test_ue->imsi_buf, &test_ue->imsi_len); } static void test_ue_set_mobile_identity_imsi(test_ue_t *test_ue) { ogs_assert(test_ue); ogs_assert(test_ue->imsi); test_ue->mobile_identity_imsi.odd_even = OGS_NAS_MOBILE_IDENTITY_ODD; test_ue->mobile_identity_imsi.type = OGS_NAS_MOBILE_IDENTITY_IMSI; test_ue->mobile_identity_imsi.digit1 = test_ue->imsi[0] - '0'; test_ue->mobile_identity_imsi.digit2 = test_ue->imsi[1] - '0'; test_ue->mobile_identity_imsi.digit3 = test_ue->imsi[2] - '0'; test_ue->mobile_identity_imsi.digit4 = test_ue->imsi[3] - '0'; test_ue->mobile_identity_imsi.digit5 = test_ue->imsi[4] - '0'; test_ue->mobile_identity_imsi.digit6 = test_ue->imsi[5] - '0'; test_ue->mobile_identity_imsi.digit7 = test_ue->imsi[6] - '0'; test_ue->mobile_identity_imsi.digit8 = test_ue->imsi[7] - '0'; test_ue->mobile_identity_imsi.digit9 = test_ue->imsi[8] - '0'; test_ue->mobile_identity_imsi.digit10 = test_ue->imsi[9] - '0'; test_ue->mobile_identity_imsi.digit11 = test_ue->imsi[10] - '0'; test_ue->mobile_identity_imsi.digit12 = test_ue->imsi[11] - '0'; test_ue->mobile_identity_imsi.digit13 = test_ue->imsi[12] - '0'; test_ue->mobile_identity_imsi.digit14 = test_ue->imsi[13] - '0'; test_ue->mobile_identity_imsi.digit15 = test_ue->imsi[14] - '0'; } static void test_ue_set_mobile_identity_imsisv(test_ue_t *test_ue) { ogs_assert(test_ue); memset(&test_ue->mobile_identity_imeisv, 0, sizeof(ogs_nas_mobile_identity_imeisv_t)); test_ue->mobile_identity_imeisv.type = OGS_NAS_5GS_MOBILE_IDENTITY_IMEISV; test_ue->mobile_identity_imeisv.odd_even = OGS_NAS_MOBILE_IDENTITY_EVEN; test_ue->mobile_identity_imeisv.digit1 = 8; test_ue->mobile_identity_imeisv.digit2 = 6; test_ue->mobile_identity_imeisv.digit3 = 6; test_ue->mobile_identity_imeisv.digit4 = 5; test_ue->mobile_identity_imeisv.digit5 = 0; test_ue->mobile_identity_imeisv.digit6 = 7; test_ue->mobile_identity_imeisv.digit7 = 0; test_ue->mobile_identity_imeisv.digit8 = 4; test_ue->mobile_identity_imeisv.digit9 = 0; test_ue->mobile_identity_imeisv.digit10 = 0; test_ue->mobile_identity_imeisv.digit11 = 4; test_ue->mobile_identity_imeisv.digit12 = 0; test_ue->mobile_identity_imeisv.digit13 = 5; test_ue->mobile_identity_imeisv.digit14 = 3; test_ue->mobile_identity_imeisv.digit15 = 0; test_ue->mobile_identity_imeisv.digit16 = 1; test_ue->mobile_identity_imeisv.digit17 = 0xf; } test_ue_t *test_ue_add_by_suci( ogs_nas_5gs_mobile_identity_suci_t *mobile_identity_suci, uint16_t mobile_identity_suci_length) { int i, j; test_ue_t *test_ue = NULL; ogs_assert(mobile_identity_suci); ogs_assert(mobile_identity_suci_length); ogs_pool_alloc(&test_ue_pool, &test_ue); ogs_assert(test_ue); memset(test_ue, 0, sizeof *test_ue); test_ue->nas.access_type = OGS_ACCESS_TYPE_3GPP; test_ue->abba_len = 2; test_ue->ue_security_capability.nr_ea = 0xf0; test_ue->ue_security_capability.nr_ia = 0xf0; #if 0 test_ue->ue_security_capability.eutra_ea = 0xf0; test_ue->ue_security_capability.eutra_ia = 0xf0; #endif test_ue->ue_network_capability.eea = 0xf0; test_ue->ue_network_capability.eia = 0xf0; memcpy(&test_ue->e_tai, &test_self()->e_tai, sizeof(ogs_eps_tai_t)); memcpy(&test_ue->e_cgi.plmn_id, &test_ue->e_tai.plmn_id, OGS_PLMN_ID_LEN); memcpy(&test_ue->nr_tai, &test_self()->nr_tai, sizeof(ogs_5gs_tai_t)); memcpy(&test_ue->nr_cgi.plmn_id, &test_ue->nr_tai.plmn_id, OGS_PLMN_ID_LEN); if (test_self()->nr_tai.tac.v) ogs_nas_from_plmn_id( &mobile_identity_suci->nas_plmn_id, &test_ue->nr_tai.plmn_id); else ogs_nas_from_plmn_id( &mobile_identity_suci->nas_plmn_id, &test_ue->e_tai.plmn_id); for (i = 0; i < test_self()->num_of_plmn_support; i++) { for (j = 0; j < test_self()->plmn_support[i].num_of_s_nssai; j++) { ogs_nas_s_nssai_ie_t *s_nssai = &test_ue->requested_nssai. s_nssai[test_ue->requested_nssai.num_of_s_nssai]; s_nssai->sst = 0; s_nssai->sd.v = OGS_S_NSSAI_NO_SD_VALUE; s_nssai->mapped_hplmn_sst = 0; s_nssai->mapped_hplmn_sd.v = OGS_S_NSSAI_NO_SD_VALUE; memcpy(s_nssai, &test_self()->plmn_support[i].s_nssai[j], sizeof(ogs_s_nssai_t)); test_ue->requested_nssai.num_of_s_nssai++; } } test_ue_set_mobile_identity_suci( test_ue, mobile_identity_suci, mobile_identity_suci_length); test_ue_set_mobile_identity_imsi(test_ue); test_ue_set_mobile_identity_imsisv(test_ue); ogs_list_add(&self.test_ue_list, test_ue); return test_ue; } void test_ue_remove(test_ue_t *test_ue) { ogs_assert(test_ue); ogs_list_remove(&self.test_ue_list, test_ue); if (test_ue->suci) ogs_free(test_ue->suci); if (test_ue->supi) ogs_free(test_ue->supi); if (test_ue->imsi) ogs_free(test_ue->imsi); test_sess_remove_all(test_ue); ogs_pool_free(&test_ue_pool, test_ue); } void test_ue_remove_all(void) { test_ue_t *test_ue = NULL, *next = NULL;; ogs_list_for_each_safe(&self.test_ue_list, next, test_ue) test_ue_remove(test_ue); } test_sess_t *test_sess_add_by_apn( test_ue_t *test_ue, char *apn, uint8_t rat_type) { test_sess_t *sess = NULL; ogs_assert(test_ue); ogs_assert(apn); ogs_pool_alloc(&test_sess_pool, &sess); ogs_assert(sess); memset(sess, 0, sizeof *sess); sess->index = ogs_pool_index(&test_sess_pool, sess); sess->apn = ogs_strdup(apn); ogs_assert(sess->apn); sess->gtp_rat_type = rat_type; ogs_assert(sess->gtp_rat_type); sess->pti = 1; /* Default PTI : 1 */ sess->epdg_s2b_c_teid = sess->index; sess->test_ue = test_ue; ogs_list_add(&test_ue->sess_list, sess); return sess; } test_sess_t *test_sess_add_by_dnn_and_psi( test_ue_t *test_ue, char *dnn, uint8_t psi) { test_sess_t *sess = NULL; ogs_assert(test_ue); ogs_assert(dnn); ogs_pool_alloc(&test_sess_pool, &sess); ogs_assert(sess); memset(sess, 0, sizeof *sess); sess->index = ogs_pool_index(&test_sess_pool, sess); sess->dnn = ogs_strdup(dnn); ogs_assert(sess->dnn); sess->psi = psi; sess->pti = 1; /* Default PTI : 1 */ sess->gnb_n3_addr = test_self()->gnb1_addr; sess->gnb_n3_addr6 = test_self()->gnb1_addr6; sess->gnb_n3_teid = sess->index; sess->pdu_session_type = OGS_PDU_SESSION_TYPE_IPV4V6; sess->test_ue = test_ue; ogs_list_add(&test_ue->sess_list, sess); return sess; } void test_sess_remove(test_sess_t *sess) { test_ue_t *test_ue = NULL; ogs_assert(sess); test_ue = sess->test_ue; ogs_assert(test_ue); ogs_list_remove(&test_ue->sess_list, sess); if (sess->dnn) ogs_free(sess->dnn); test_bearer_remove_all(sess); ogs_pool_free(&test_sess_pool, sess); } void test_sess_remove_all(test_ue_t *test_ue) { test_sess_t *sess = NULL, *next = NULL;; ogs_assert(test_ue); ogs_list_for_each_safe(&test_ue->sess_list, next, sess) test_sess_remove(sess); } test_sess_t *test_sess_find_by_apn( test_ue_t *test_ue, char *apn, uint8_t rat_type) { test_sess_t *sess = NULL; ogs_assert(test_ue); ogs_assert(apn); ogs_list_for_each(&test_ue->sess_list, sess) if (ogs_strcasecmp(sess->apn, apn) == 0 && sess->gtp_rat_type == rat_type) return sess; return NULL; } test_sess_t *test_sess_find_by_psi(test_ue_t *test_ue, uint8_t psi) { test_sess_t *sess = NULL; ogs_assert(test_ue); ogs_list_for_each(&test_ue->sess_list, sess) if (sess->psi == psi) return sess; return NULL; } test_bearer_t *test_bearer_add(test_sess_t *sess, uint8_t ebi) { test_bearer_t *bearer = NULL; ogs_assert(sess); ogs_assert(ebi); ogs_pool_alloc(&test_bearer_pool, &bearer); ogs_assert(bearer); memset(bearer, 0, sizeof *bearer); bearer->index = ogs_pool_index(&test_bearer_pool, bearer); bearer->ebi = ebi; bearer->enb_s1u_addr = test_self()->gnb1_addr; bearer->enb_s1u_addr6 = test_self()->gnb1_addr6; bearer->enb_s1u_teid = bearer->index; bearer->sess = sess; ogs_list_add(&sess->bearer_list, bearer); return bearer; } test_bearer_t *test_qos_flow_add(test_sess_t *sess) { test_bearer_t *qos_flow = NULL; ogs_assert(sess); ogs_pool_alloc(&test_bearer_pool, &qos_flow); ogs_assert(qos_flow); memset(qos_flow, 0, sizeof *qos_flow); qos_flow->index = ogs_pool_index(&test_bearer_pool, qos_flow); qos_flow->sess = sess; ogs_list_add(&sess->bearer_list, qos_flow); return qos_flow; } void test_bearer_remove(test_bearer_t *bearer) { ogs_assert(bearer); ogs_assert(bearer->sess); ogs_list_remove(&bearer->sess->bearer_list, bearer); ogs_pool_free(&test_bearer_pool, bearer); } void test_bearer_remove_all(test_sess_t *sess) { test_bearer_t *bearer = NULL, *next_bearer = NULL; ogs_assert(sess); ogs_list_for_each_safe(&sess->bearer_list, next_bearer, bearer) test_bearer_remove(bearer); } test_bearer_t *test_bearer_find_by_sess_ebi(test_sess_t *sess, uint8_t ebi) { test_bearer_t *bearer = NULL; ogs_assert(sess); ogs_list_for_each(&sess->bearer_list, bearer) if (ebi == bearer->ebi) return bearer; return NULL; } test_bearer_t *test_bearer_find_by_ue_ebi(test_ue_t *test_ue, uint8_t ebi) { test_sess_t *sess = NULL; test_bearer_t *bearer = NULL; ogs_assert(test_ue); ogs_list_for_each(&test_ue->sess_list, sess) { if (sess->gtp_rat_type != OGS_GTP_RAT_TYPE_EUTRAN) continue; bearer = test_bearer_find_by_sess_ebi(sess, ebi); if (bearer) return bearer; } return NULL; } test_bearer_t *test_qos_flow_find_by_qfi(test_sess_t *sess, uint8_t qfi) { test_bearer_t *qos_flow = NULL; ogs_assert(sess); ogs_list_for_each(&sess->bearer_list, qos_flow) if (qfi == qos_flow->qfi) return qos_flow; return NULL; } int test_db_insert_ue(test_ue_t *test_ue, bson_t *doc) { mongoc_collection_t *collection = NULL; bson_t *key = NULL; int64_t count = 0; bson_error_t error; ogs_assert(test_ue); ogs_assert(doc); OGS_HEX(test_ue->k_string, strlen(test_ue->k_string), test_ue->k); OGS_HEX(test_ue->opc_string, strlen(test_ue->opc_string), test_ue->opc); collection = mongoc_client_get_collection( ogs_mongoc()->client, ogs_mongoc()->name, "subscribers"); if (!collection) { ogs_error("mongoc_client_get_collection() failed"); return OGS_ERROR; } key = BCON_NEW("imsi", BCON_UTF8(test_ue->imsi)); ogs_assert(key); count = mongoc_collection_count ( collection, MONGOC_QUERY_NONE, key, 0, 0, NULL, &error); if (count) { if (mongoc_collection_remove(collection, MONGOC_REMOVE_SINGLE_REMOVE, key, NULL, &error) != true) { ogs_error("mongoc_collection_remove() failed"); bson_destroy(key); return OGS_ERROR; } } bson_destroy(key); if (mongoc_collection_insert(collection, MONGOC_INSERT_NONE, doc, NULL, &error) != true) { ogs_error("mongoc_collection_insert() failed"); bson_destroy(doc); return OGS_ERROR; } bson_destroy(doc); key = BCON_NEW("imsi", BCON_UTF8(test_ue->imsi)); ogs_assert(key); do { count = mongoc_collection_count( collection, MONGOC_QUERY_NONE, key, 0, 0, NULL, &error); } while (count == 0); bson_destroy(key); mongoc_collection_destroy(collection); return OGS_OK; } int test_db_remove_ue(test_ue_t *test_ue) { mongoc_collection_t *collection = NULL; bson_t *key = NULL; bson_error_t error; ogs_assert(test_ue); collection = mongoc_client_get_collection( ogs_mongoc()->client, ogs_mongoc()->name, "subscribers"); if (!collection) { ogs_error("mongoc_client_get_collection() failed"); return OGS_ERROR; } key = BCON_NEW("imsi", BCON_UTF8(test_ue->imsi)); ogs_assert(key); if (mongoc_collection_remove(collection, MONGOC_REMOVE_SINGLE_REMOVE, key, NULL, &error) != true) { ogs_error("mongoc_collection_remove() failed"); bson_destroy(key); return OGS_ERROR; } bson_destroy(key); mongoc_collection_destroy(collection); return OGS_OK; } bson_t *test_db_new_simple(test_ue_t *test_ue) { bson_t *doc = NULL; ogs_assert(test_ue); doc = BCON_NEW( "imsi", BCON_UTF8(test_ue->imsi), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "slice", "[", "{", "sst", BCON_INT32(1), "default_indicator", BCON_BOOL(true), "session", "[", "{", "name", BCON_UTF8("internet"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(9), "arp", "{", "priority_level", BCON_INT32(8), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "}", "]", "}", "]", "security", "{", "k", BCON_UTF8(test_ue->k_string), "opc", BCON_UTF8(test_ue->opc_string), "amf", BCON_UTF8("8000"), "sqn", BCON_INT64(64), "}", "subscribed_rau_tau_timer", BCON_INT32(12), "network_access_mode", BCON_INT32(0), "subscriber_status", BCON_INT32(0), "access_restriction_data", BCON_INT32(32) ); ogs_assert(doc); return doc; } bson_t *test_db_new_qos_flow(test_ue_t *test_ue) { bson_t *doc = NULL; ogs_assert(test_ue); doc = BCON_NEW( "imsi", BCON_UTF8(test_ue->imsi), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "slice", "[", "{", "sst", BCON_INT32(1), "default_indicator", BCON_BOOL(true), "session", "[", "{", "name", BCON_UTF8("internet"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(9), "arp", "{", "priority_level", BCON_INT32(8), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "pcc_rule", "[", "{", "qos", "{", "index", BCON_INT32(1), "arp", "{", "priority_level", BCON_INT32(2), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(64), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(44), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(64), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(44), "unit", BCON_INT32(1), "}", "}", "}", "flow", "[", "{", "direction", BCON_INT32(2), "description", BCON_UTF8("permit out icmp from any to assigned"), "}", "{", "direction", BCON_INT32(1), "description", BCON_UTF8("permit out icmp from any to assigned"), "}", "{", "direction", BCON_INT32(2), "description", BCON_UTF8("permit out udp from 10.200.136.98/32 23455 to assigned 1-65535"), "}", "{", "direction", BCON_INT32(1), "description", BCON_UTF8("permit out udp from 10.200.136.98/32 1-65535 to assigned 50021"), "}", "]", "}", "]", "}", "]", "}", "]", "security", "{", "k", BCON_UTF8(test_ue->k_string), "opc", BCON_UTF8(test_ue->opc_string), "amf", BCON_UTF8("8000"), "sqn", BCON_INT64(64), "}", "subscribed_rau_tau_timer", BCON_INT32(12), "network_access_mode", BCON_INT32(0), "subscriber_status", BCON_INT32(0), "access_restriction_data", BCON_INT32(32) ); ogs_assert(doc); return doc; } bson_t *test_db_new_session(test_ue_t *test_ue) { bson_t *doc = NULL; ogs_assert(test_ue); doc = BCON_NEW( "imsi", BCON_UTF8(test_ue->imsi), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "slice", "[", "{", "sst", BCON_INT32(1), "default_indicator", BCON_BOOL(true), "session", "[", "{", "name", BCON_UTF8("internet"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(9), "arp", "{", "priority_level", BCON_INT32(8), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "}", "{", "name", BCON_UTF8("ims"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(6), "arp", "{", "priority_level", BCON_INT32(6), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "pcc_rule", "[", "{", "qos", "{", "index", BCON_INT32(1), "arp", "{", "priority_level", BCON_INT32(3), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(64), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(44), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(64), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(44), "unit", BCON_INT32(1), "}", "}", "}", "flow", "[", "{", "direction", BCON_INT32(2), "description", BCON_UTF8("permit out icmp from any to assigned"), "}", "{", "direction", BCON_INT32(1), "description", BCON_UTF8("permit out icmp from any to assigned"), "}", "{", "direction", BCON_INT32(2), "description", BCON_UTF8("permit out udp from 10.200.136.98/32 23455 to assigned 1-65535"), "}", "{", "direction", BCON_INT32(1), "description", BCON_UTF8("permit out udp from 10.200.136.98/32 1-65535 to assigned 50021"), "}", "]", "}", "]", "}", "]", "}", "]", "security", "{", "k", BCON_UTF8(test_ue->k_string), "opc", BCON_UTF8(test_ue->opc_string), "amf", BCON_UTF8("8000"), "sqn", BCON_INT64(64), "}", "subscribed_rau_tau_timer", BCON_INT32(12), "network_access_mode", BCON_INT32(0), "subscriber_status", BCON_INT32(0), "access_restriction_data", BCON_INT32(32) ); ogs_assert(doc); return doc; } bson_t *test_db_new_ims(test_ue_t *test_ue) { bson_t *doc = NULL; ogs_assert(test_ue); doc = BCON_NEW( "imsi", BCON_UTF8(test_ue->imsi), "msisdn", "[", BCON_UTF8(TEST_MSISDN), BCON_UTF8(TEST_ADDITIONAL_MSISDN), "]", "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "slice", "[", "{", "sst", BCON_INT32(1), "default_indicator", BCON_BOOL(true), "session", "[", "{", "name", BCON_UTF8("internet"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(9), "arp", "{", "priority_level", BCON_INT32(8), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "}", "{", "name", BCON_UTF8("ims"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(5), "arp", "{", "priority_level", BCON_INT32(1), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "pcc_rule", "[", "{", "qos", "{", "index", BCON_INT32(1), "arp", "{", "priority_level", BCON_INT32(3), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "}", "}", "{", "qos", "{", "index", BCON_INT32(2), "arp", "{", "priority_level", BCON_INT32(4), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "}", "}", "]", "}", "]", "}", "]", "security", "{", "k", BCON_UTF8(test_ue->k_string), "opc", BCON_UTF8(test_ue->opc_string), "amf", BCON_UTF8("8000"), "sqn", BCON_INT64(64), "}", "subscribed_rau_tau_timer", BCON_INT32(12), "network_access_mode", BCON_INT32(0), "subscriber_status", BCON_INT32(0), "access_restriction_data", BCON_INT32(32) ); ogs_assert(doc); return doc; } bson_t *test_db_new_slice(test_ue_t *test_ue) { bson_t *doc = NULL; ogs_assert(test_ue); doc = BCON_NEW( "imsi", BCON_UTF8(test_ue->imsi), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "slice", "[", "{", "sst", BCON_INT32(1), "default_indicator", BCON_BOOL(true), "session", "[", "{", "name", BCON_UTF8("internet"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(9), "arp", "{", "priority_level", BCON_INT32(8), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "}", "{", "name", BCON_UTF8("ims"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(5), "arp", "{", "priority_level", BCON_INT32(1), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "pcc_rule", "[", "{", "qos", "{", "index", BCON_INT32(1), "arp", "{", "priority_level", BCON_INT32(3), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "}", "}", "{", "qos", "{", "index", BCON_INT32(2), "arp", "{", "priority_level", BCON_INT32(4), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "}", "}", "]", "}", "]", "}", "{", "sst", BCON_INT32(1), "sd", BCON_UTF8("000080"), "session", "[", "{", "name", BCON_UTF8("internet"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(9), "arp", "{", "priority_level", BCON_INT32(8), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "}", "{", "name", BCON_UTF8("ims"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(5), "arp", "{", "priority_level", BCON_INT32(1), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "pcc_rule", "[", "{", "qos", "{", "index", BCON_INT32(1), "arp", "{", "priority_level", BCON_INT32(3), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "}", "}", "{", "qos", "{", "index", BCON_INT32(2), "arp", "{", "priority_level", BCON_INT32(4), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "}", "}", "]", "}", "]", "}", "{", "sst", BCON_INT32(1), "sd", BCON_UTF8("009000"), "default_indicator", BCON_BOOL(true), "session", "[", "{", "name", BCON_UTF8("internet"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(9), "arp", "{", "priority_level", BCON_INT32(8), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "}", "{", "name", BCON_UTF8("ims"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(5), "arp", "{", "priority_level", BCON_INT32(1), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "pcc_rule", "[", "{", "qos", "{", "index", BCON_INT32(1), "arp", "{", "priority_level", BCON_INT32(3), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "}", "}", "{", "qos", "{", "index", BCON_INT32(2), "arp", "{", "priority_level", BCON_INT32(4), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "}", "}", "]", "}", "]", "}", "]", "security", "{", "k", BCON_UTF8(test_ue->k_string), "opc", BCON_UTF8(test_ue->opc_string), "amf", BCON_UTF8("8000"), "sqn", BCON_INT64(64), "}", "subscribed_rau_tau_timer", BCON_INT32(12), "network_access_mode", BCON_INT32(0), "subscriber_status", BCON_INT32(0), "access_restriction_data", BCON_INT32(32) ); ogs_assert(doc); return doc; } bson_t *test_db_new_non3gpp(test_ue_t *test_ue) { bson_t *doc = NULL; ogs_assert(test_ue); doc = BCON_NEW( "imsi", BCON_UTF8(test_ue->imsi), "msisdn", "[", BCON_UTF8(TEST_MSISDN), BCON_UTF8(TEST_ADDITIONAL_MSISDN), "]", "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "slice", "[", "{", "sst", BCON_INT32(1), "default_indicator", BCON_BOOL(true), "session", "[", "{", "name", BCON_UTF8("internet"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(9), "arp", "{", "priority_level", BCON_INT32(8), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "smf", "{", "addr", BCON_UTF8("127.0.0.4"), "addr6", BCON_UTF8("::1"), "}", "}", "{", "name", BCON_UTF8("wlan"), "type", BCON_INT32(3), "ambr", "{", "downlink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "uplink", "{", "value", BCON_INT32(1), "unit", BCON_INT32(3), "}", "}", "qos", "{", "index", BCON_INT32(5), "arp", "{", "priority_level", BCON_INT32(1), "pre_emption_vulnerability", BCON_INT32(1), "pre_emption_capability", BCON_INT32(1), "}", "}", "pcc_rule", "[", "{", "qos", "{", "index", BCON_INT32(1), "arp", "{", "priority_level", BCON_INT32(3), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(82), "unit", BCON_INT32(1), "}", "}", "}", "}", "{", "qos", "{", "index", BCON_INT32(2), "arp", "{", "priority_level", BCON_INT32(4), "pre_emption_vulnerability", BCON_INT32(2), "pre_emption_capability", BCON_INT32(2), "}", "mbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "gbr", "{", "downlink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "uplink", "{", "value", BCON_INT32(802), "unit", BCON_INT32(1), "}", "}", "}", "}", "]", "}", "]", "}", "]", "security", "{", "k", BCON_UTF8(test_ue->k_string), "opc", BCON_UTF8(test_ue->opc_string), "amf", BCON_UTF8("8000"), "sqn", BCON_INT64(64), "}", "subscribed_rau_tau_timer", BCON_INT32(12), "network_access_mode", BCON_INT32(0), "subscriber_status", BCON_INT32(0), "access_restriction_data", BCON_INT32(32) ); ogs_assert(doc); return doc; }