sysmocom
/
open5gs
forked from acouzens/open5gs
11
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

TAI List encoding done in Attach Accept

This commit is contained in:
Sukchan Lee 2017-12-11 16:08:17 +09:00
parent 521d7877b4
commit 5551ecf6cd
5 changed files with 129 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
lib/nas/nas_types.c
View File

@ -225,63 +225,75 @@ void nas_tai_list_build(
nas_tracking_area_identity_list_t *target,
tai0_list_t *source0, tai2_list_t *source2)
{
int i = 0, j = 0, length = 0;
tai0_list_t *target0 = NULL;
tai2_list_t *target2 = NULL;
int i = 0, j = 0, size = 0;
tai0_list_t target0;
tai2_list_t target2;
d_assert(target, return,);
d_assert(source0, return,);
d_assert(source2, return,);
target0 = &target->list0;
memset(target0, 0, sizeof(tai0_list_t));
memset(target, 0, sizeof(nas_tracking_area_identity_list_t));
memset(&target0, 0, sizeof(tai0_list_t));
memset(&target2, 0, sizeof(tai2_list_t));
for (i = 0; source0->tai[i].num; i++)
{
d_assert(source0->tai[i].type == TAI0_TYPE,
return, "type = %d", source0->tai[i].type);
target0->tai[i].type = source0->tai[i].type;
target0.tai[i].type = source0->tai[i].type;
/* <Spec> target->num = source->num - 1 */
d_assert(source0->tai[i].num < MAX_NUM_OF_TAI,
return, "num = %d", source0->tai[i].num);
target0->tai[i].num = source0->tai[i].num - 1;
memcpy(&target0->tai[i].plmn_id,
target0.tai[i].num = source0->tai[i].num - 1;
memcpy(&target0.tai[i].plmn_id,
&source0->tai[i].plmn_id, PLMN_ID_LEN);
for (j = 0; j < source0->tai[i].num; j++)
{
target0->tai[i].tac[j] = htons(source0->tai[i].tac[j]);
target0.tai[i].tac[j] = htons(source0->tai[i].tac[j]);
}
length += (1 + 3 + 2 * source0->tai[i].num);
size = (1 + 3 + 2 * source0->tai[i].num);
if ((target->length + size) > NAS_MAX_TAI_LIST_LEN)
{
d_warn("Overflow: Ignore remained TAI LIST(length:%d, size:%d)",
target->length, size);
return;
}
memcpy(target->buffer + target->length, &target0.tai[i], size);
target->length += size;
}
if (source2->num)
{
if (source0->tai[0].num)
target2 = &target->both.list2;
else
target2 = &target->list2;
memset(target2, 0, sizeof(tai2_list_t));
memset(&target2, 0, sizeof(target2));
d_assert(source2->type == TAI1_TYPE || source2->type == TAI2_TYPE,
return, "type = %d", source2->type);
target2->type = source2->type;
target2.type = source2->type;
/* <Spec> target->num = source->num - 1 */
d_assert(source2->num < MAX_NUM_OF_TAI,
return, "num = %d", source2->num);
target2->num = source2->num - 1;
target2.num = source2->num - 1;
size = (1 + (3 + 2) * source2->num);
if ((target->length + size) > NAS_MAX_TAI_LIST_LEN)
{
d_warn("Overflow: Ignore remained TAI LIST(length:%d, size:%d)",
target->length, size);
return;
}
for (i = 0; i < source2->num; i++)
{
memcpy(&target2->tai[i].plmn_id,
memcpy(&target2.tai[i].plmn_id,
&source2->tai[i].plmn_id, PLMN_ID_LEN);
target2->tai[i].tac = htons(source2->tai[i].tac);
target2.tai[i].tac = htons(source2->tai[i].tac);
}
length += (1 + 3 + 2 * source2->num);
memcpy(target->buffer + target->length, &target2, size);
target->length += size;
}
target->length = length;
}

14
lib/nas/nas_types.h
View File

@ -33,7 +33,7 @@ extern "C" {
#define NAX_MAX_ADDITIONAL_INFORMATION_LEN 255
typedef struct _nas_additional_information_t {
c_uint8_t length;
c_uint32_t buffer[NAX_MAX_ADDITIONAL_INFORMATION_LEN];
c_uint8_t buffer[NAX_MAX_ADDITIONAL_INFORMATION_LEN];
} __attribute__ ((packed)) nas_additional_information_t;
/* 9.9.2.0A Device properties
@ -609,7 +609,7 @@ ED3(c_uint8_t type:4;,
#define NAS_MAX_MESSAGE_CONTAINER_LEN 250
typedef struct _nas_message_container_t {
c_uint8_t length;
c_uint16_t buffer[NAS_MAX_MESSAGE_CONTAINER_LEN];
c_uint8_t buffer[NAS_MAX_MESSAGE_CONTAINER_LEN];
} __attribute__ ((packed)) nas_message_container_t;
/* 9.9.3.23 NAS security algorithms
@ -733,6 +733,7 @@ typedef tai_t nas_tracking_area_identity_t;
/* 9.9.3.33 Tracking area identity list
* M LV 7-97 */
#define NAS_MAX_TAI_LIST_LEN 96
#define TAI0_TYPE 0
#define TAI1_TYPE 1
#define TAI2_TYPE 2
@ -755,14 +756,7 @@ ED3(c_uint8_t spare:1;,
typedef struct _nas_tracking_area_identity_list_t {
c_uint8_t length;
union {
tai0_list_t list0;
tai2_list_t list2;
struct {
tai0_list_t list0;
tai2_list_t list2;
} __attribute__ ((packed)) both;
};
c_uint8_t buffer[NAS_MAX_TAI_LIST_LEN];
} __attribute__ ((packed)) nas_tracking_area_identity_list_t;
CORE_DECLARE(void) nas_tai_list_build(

23
src/mme/emm_build.c
View File

@ -19,6 +19,7 @@ status_t emm_build_attach_accept(
nas_gprs_timer_t *t3412_value = &attach_accept->t3412_value;
tai0_list_t tai0_list;
tai2_list_t tai2_list;
int served_tai_index = 0;
nas_eps_mobile_identity_t *guti = &attach_accept->guti;
nas_gprs_timer_t *t3402_value = &attach_accept->t3402_value;
nas_gprs_timer_t *t3423_value = &attach_accept->t3423_value;
@ -41,12 +42,22 @@ status_t emm_build_attach_accept(
t3412_value->unit = NAS_GRPS_TIMER_UNIT_MULTIPLES_OF_DECI_HH;
t3412_value->value = 9;
memset(&tai0_list, 0, sizeof(tai0_list_t));
memset(&tai2_list, 0, sizeof(tai2_list_t));
tai2_list.type = TAI2_TYPE;
tai2_list.num = 1;
memcpy(&tai2_list.tai[0], &mme_ue->tai, sizeof(tai_t));
nas_tai_list_build(&attach_accept->tai_list, &tai0_list, &tai2_list);
served_tai_index = mme_find_served_tai(&mme_ue->tai);
if (served_tai_index < 0)
{
memset(&tai0_list, 0, sizeof(tai0_list_t));
memset(&tai2_list, 0, sizeof(tai2_list_t));
tai2_list.type = TAI2_TYPE;
tai2_list.num = 1;
memcpy(&tai2_list.tai[0], &mme_ue->tai, sizeof(tai_t));
nas_tai_list_build(&attach_accept->tai_list, &tai0_list, &tai2_list);
}
else
{
nas_tai_list_build(&attach_accept->tai_list,
&mme_self()->served_tai[served_tai_index].list0,
&mme_self()->served_tai[served_tai_index].list2);
}
attach_accept->esm_message_container.buffer = esmbuf->payload;
attach_accept->esm_message_container.length = esmbuf->len;

106
src/mme/mme_context.c
View File

@ -206,56 +206,13 @@ static status_t mme_context_validation()
return CORE_ERROR;
}
#if 0 /* For debuggin, will be removed */
if (self.served_tai[0].list0.tai[0].num == 0 &&
self.served_tai[0].list2.num == 0)
{
int i = 0, j = 0, k = 0;
for (k = 0; k < self.num_of_served_tai; k++)
{
tai0_list_t *list0 = &self.served_tai[k].list0;
d_assert(list0, return CORE_ERROR,);
tai2_list_t *list2 = &self.served_tai[k].list2;
d_assert(list2, return CORE_ERROR,);
for (i = 0; list0->tai[i].num; i++)
{
d_assert(list0->tai[i].type == TAI0_TYPE,
return CORE_ERROR, "type = %d", list0->tai[i].type);
printf("i:%d ", i);
printf("type: %d ", list0->tai[i].type);
d_assert(list0->tai[i].num < MAX_NUM_OF_TAI,
return CORE_ERROR, "num = %d", list0->tai[i].num);
printf("num: %d ", list0->tai[i].num);
printf("tac: ");
for (j = 0; j < list0->tai[i].num; j++)
{
printf("%d, ", list0->tai[i].tac[j]);
}
printf("\n");
}
if (list2->num)
{
d_assert(list2->type == TAI1_TYPE || list2->type == TAI2_TYPE,
return CORE_ERROR, "type = %d", list2->type);
printf("type: %d ", list2->type);
/* <Spec> target->num = source->num - 1 */
d_assert(list2->num < MAX_NUM_OF_TAI,
return CORE_ERROR, "num = %d", list2->num);
printf("num: %d ", list2->num);
printf("tac: ");
for (i = 0; i < list2->num; i++)
{
printf("%d, ", list2->tai[i].tac);
}
}
printf("\n\n\n");
}
d_error("No mme.tai.plmn_id|tac in '%s'",
context_self()->config.path);
return CORE_ERROR;
}
#endif
if (self.num_of_integrity_order == 0)
{
@ -2461,3 +2418,56 @@ pdn_t* mme_pdn_find_by_apn(mme_ue_t *mme_ue, c_int8_t *apn)
return NULL;
}
int mme_find_served_tai(tai_t *tai)
{
int i = 0, j = 0, k = 0;
d_assert(tai, return -1,);
for (i = 0; i < self.num_of_served_tai; i++)
{
tai0_list_t *list0 = &self.served_tai[i].list0;
d_assert(list0, return -1,);
tai2_list_t *list2 = &self.served_tai[i].list2;
d_assert(list2, return -1,);
for (j = 0; list0->tai[j].num; j++)
{
d_assert(list0->tai[j].type == TAI0_TYPE,
return -1, "type = %d", list0->tai[j].type);
d_assert(list0->tai[j].num < MAX_NUM_OF_TAI,
return -1, "num = %d", list0->tai[j].num);
for (k = 0; k < list0->tai[j].num; k++)
{
if (memcmp(&list0->tai[j].plmn_id,
&tai->plmn_id, PLMN_ID_LEN) == 0 &&
list0->tai[j].tac[k] == tai->tac)
{
return i;
}
}
}
if (list2->num)
{
d_assert(list2->type == TAI1_TYPE || list2->type == TAI2_TYPE,
return -1, "type = %d", list2->type);
d_assert(list2->num < MAX_NUM_OF_TAI,
return -1, "num = %d", list2->num);
for (j = 0; j < list2->num; j++)
{
if (memcmp(&list2->tai[j].plmn_id,
&tai->plmn_id, PLMN_ID_LEN) == 0 &&
list2->tai[j].tac == tai->tac)
{
return i;
}
}
}
}
return -1;
}

26
src/mme/mme_context.h
View File

@ -440,6 +440,19 @@ CORE_DECLARE(hash_index_t *) mme_enb_next(hash_index_t *hi);
CORE_DECLARE(mme_enb_t *) mme_enb_this(hash_index_t *hi);
CORE_DECLARE(int) mme_enb_sock_type(sock_id sock);
CORE_DECLARE(enb_ue_t*) enb_ue_add(mme_enb_t *enb);
CORE_DECLARE(unsigned int) enb_ue_count();
CORE_DECLARE(status_t) enb_ue_remove(enb_ue_t *enb_ue);
CORE_DECLARE(status_t) enb_ue_remove_in_enb(mme_enb_t *enb);
CORE_DECLARE(status_t) enb_ue_switch_to_enb(enb_ue_t *enb_ue,
mme_enb_t *new_enb);
CORE_DECLARE(enb_ue_t*) enb_ue_find(index_t index);
CORE_DECLARE(enb_ue_t*) enb_ue_find_by_enb_ue_s1ap_id(mme_enb_t *enb,
c_uint32_t enb_ue_s1ap_id);
CORE_DECLARE(enb_ue_t*) enb_ue_find_by_mme_ue_s1ap_id(c_uint32_t mme_ue_s1ap_id);
CORE_DECLARE(enb_ue_t*) enb_ue_first_in_enb(mme_enb_t *enb);
CORE_DECLARE(enb_ue_t*) enb_ue_next_in_enb(enb_ue_t *enb_ue);
CORE_DECLARE(mme_ue_t*) mme_ue_add(enb_ue_t *enb_ue);
CORE_DECLARE(status_t) mme_ue_remove(mme_ue_t *mme_ue);
CORE_DECLARE(status_t) mme_ue_remove_all();
@ -497,18 +510,7 @@ CORE_DECLARE(status_t) mme_pdn_remove_all(mme_ue_t *mme_ue);
CORE_DECLARE(pdn_t*) mme_pdn_find_by_apn(
mme_ue_t *mme_ue, c_int8_t *apn);
CORE_DECLARE(enb_ue_t*) enb_ue_add(mme_enb_t *enb);
CORE_DECLARE(unsigned int) enb_ue_count();
CORE_DECLARE(status_t) enb_ue_remove(enb_ue_t *enb_ue);
CORE_DECLARE(status_t) enb_ue_remove_in_enb(mme_enb_t *enb);
CORE_DECLARE(status_t) enb_ue_switch_to_enb(enb_ue_t *enb_ue,
mme_enb_t *new_enb);
CORE_DECLARE(enb_ue_t*) enb_ue_find(index_t index);
CORE_DECLARE(enb_ue_t*) enb_ue_find_by_enb_ue_s1ap_id(mme_enb_t *enb,
c_uint32_t enb_ue_s1ap_id);
CORE_DECLARE(enb_ue_t*) enb_ue_find_by_mme_ue_s1ap_id(c_uint32_t mme_ue_s1ap_id);
CORE_DECLARE(enb_ue_t*) enb_ue_first_in_enb(mme_enb_t *enb);
CORE_DECLARE(enb_ue_t*) enb_ue_next_in_enb(enb_ue_t *enb_ue);
CORE_DECLARE(int) mme_find_served_tai(tai_t *tai);
#ifdef __cplusplus
}