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

update it

This commit is contained in:
Sukchan Lee 2017-04-07 22:23:38 +09:00
parent 5aa9392d78
commit 9b5721dafc
12 changed files with 404 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
lib/nas/nas_decoder.c
View File

@ -26,7 +26,7 @@
/*******************************************************************************
* This file had been created by gtpv2c_tlv.py script v0.1.0
* Please do not modify this file but regenerate it via script.
* Created on: 2017-04-07 19:33:56.585613 by acetcom
* Created on: 2017-04-07 22:21:56.132857 by acetcom
* from 24301-d80.docx
******************************************************************************/
@ -37,7 +37,7 @@
c_int32_t nas_decode_attach_request(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_attach_request_t *attach_request = &message->attach_request;
nas_attach_request_t *attach_request = &message->emm.attach_request;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -194,7 +194,7 @@ c_int32_t nas_decode_attach_request(nas_message_t *message, pkbuf_t *pkbuf)
c_int32_t nas_decode_attach_accept(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_attach_accept_t *attach_accept = &message->attach_accept;
nas_attach_accept_t *attach_accept = &message->emm.attach_accept;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -315,7 +315,7 @@ c_int32_t nas_decode_attach_accept(nas_message_t *message, pkbuf_t *pkbuf)
c_int32_t nas_decode_attach_complete(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_attach_complete_t *attach_complete = &message->attach_complete;
nas_attach_complete_t *attach_complete = &message->emm.attach_complete;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -328,7 +328,7 @@ c_int32_t nas_decode_attach_complete(nas_message_t *message, pkbuf_t *pkbuf)
c_int32_t nas_decode_attach_reject(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_attach_reject_t *attach_reject = &message->attach_reject;
nas_attach_reject_t *attach_reject = &message->emm.attach_reject;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -383,7 +383,7 @@ c_int32_t nas_decode_attach_reject(nas_message_t *message, pkbuf_t *pkbuf)
c_int32_t nas_decode_authentication_request(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_authentication_request_t *authentication_request = &message->authentication_request;
nas_authentication_request_t *authentication_request = &message->emm.authentication_request;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -404,7 +404,7 @@ c_int32_t nas_decode_authentication_request(nas_message_t *message, pkbuf_t *pkb
c_int32_t nas_decode_authentication_response(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_authentication_response_t *authentication_response = &message->authentication_response;
nas_authentication_response_t *authentication_response = &message->emm.authentication_response;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -417,7 +417,7 @@ c_int32_t nas_decode_authentication_response(nas_message_t *message, pkbuf_t *pk
c_int32_t nas_decode_identity_request(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_identity_request_t *identity_request = &message->identity_request;
nas_identity_request_t *identity_request = &message->emm.identity_request;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -430,7 +430,7 @@ c_int32_t nas_decode_identity_request(nas_message_t *message, pkbuf_t *pkbuf)
c_int32_t nas_decode_identity_response(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_identity_response_t *identity_response = &message->identity_response;
nas_identity_response_t *identity_response = &message->emm.identity_response;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -443,7 +443,7 @@ c_int32_t nas_decode_identity_response(nas_message_t *message, pkbuf_t *pkbuf)
c_int32_t nas_decode_authentication_failure(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_authentication_failure_t *authentication_failure = &message->authentication_failure;
nas_authentication_failure_t *authentication_failure = &message->emm.authentication_failure;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -480,7 +480,7 @@ c_int32_t nas_decode_authentication_failure(nas_message_t *message, pkbuf_t *pkb
c_int32_t nas_decode_security_mode_command(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_security_mode_command_t *security_mode_command = &message->security_mode_command;
nas_security_mode_command_t *security_mode_command = &message->emm.security_mode_command;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -537,7 +537,7 @@ c_int32_t nas_decode_security_mode_command(nas_message_t *message, pkbuf_t *pkbu
c_int32_t nas_decode_security_mode_complete(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_security_mode_complete_t *security_mode_complete = &message->security_mode_complete;
nas_security_mode_complete_t *security_mode_complete = &message->emm.security_mode_complete;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -570,7 +570,7 @@ c_int32_t nas_decode_security_mode_complete(nas_message_t *message, pkbuf_t *pkb
c_int32_t nas_decode_security_mode_reject(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_security_mode_reject_t *security_mode_reject = &message->security_mode_reject;
nas_security_mode_reject_t *security_mode_reject = &message->emm.security_mode_reject;
c_int32_t decoded = 0;
c_int32_t size = 0;
@ -581,7 +581,7 @@ c_int32_t nas_decode_security_mode_reject(nas_message_t *message, pkbuf_t *pkbuf
return decoded;
}
status_t nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf)
status_t nas_emm_decode(nas_message_t *message, pkbuf_t *pkbuf)
{
status_t rv = CORE_ERROR;
c_uint16_t size = 0;
@ -592,13 +592,13 @@ status_t nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf)
memset(message, 0, sizeof(nas_message_t));
size = sizeof(nas_header_t);
size = sizeof(nas_emm_header_t);
d_assert(pkbuf_header(pkbuf, -size) == CORE_OK,
return CORE_ERROR, "pkbuf_header error");
memcpy(&message->h, pkbuf->payload - size, size);
memcpy(&message->emm.h, pkbuf->payload - size, size);
decoded += size;
switch(message->h.message_type)
switch(message->emm.h.message_type)
{
case NAS_ATTACH_REQUEST:
size = nas_decode_attach_request(message, pkbuf);
@ -662,11 +662,9 @@ status_t nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf)
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
decoded += size;
break;
case NAS_ESM_INFORMATION_REQUEST:
break;
default:
d_error("Unknown message type (0x%x) or not implemented",
message->h.message_type);
message->emm.h.message_type);
break;
}
@ -675,3 +673,52 @@ status_t nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf)
return CORE_OK;
}
status_t nas_esm_decode(nas_message_t *message, pkbuf_t *pkbuf)
{
status_t rv = CORE_ERROR;
c_uint16_t size = 0;
c_uint16_t decoded = 0;
d_assert(pkbuf, return CORE_ERROR, "Null param");
d_assert(pkbuf->payload, return CORE_ERROR, "Null param");
memset(message, 0, sizeof(nas_message_t));
size = sizeof(nas_esm_header_t);
d_assert(pkbuf_header(pkbuf, -size) == CORE_OK,
return CORE_ERROR, "pkbuf_header error");
memcpy(&message->esm.h, pkbuf->payload - size, size);
decoded += size;
switch(message->esm.h.message_type)
{
case NAS_ESM_INFORMATION_REQUEST:
break;
default:
d_error("Unknown message type (0x%x) or not implemented",
message->esm.h.message_type);
break;
}
rv = pkbuf_header(pkbuf, decoded);
d_assert(rv == CORE_OK, return CORE_ERROR, "pkbuf_header error");
return CORE_OK;
}
status_t nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_security_header_t *h = NULL;
d_assert(pkbuf, return CORE_ERROR, "Null param");
h = pkbuf->payload;
d_assert(h, return CORE_ERROR, "Null param");
if (h->protocol_discriminator == NAS_PROTOCOL_DISCRIMINATOR_EMM)
return nas_emm_decode(message, pkbuf);
else if (h->protocol_discriminator == NAS_PROTOCOL_DISCRIMINATOR_ESM)
return nas_esm_decode(message, pkbuf);
d_assert(0, return CORE_ERROR,
"Invalid Protocol : %d", h->protocol_discriminator);
}

97
lib/nas/nas_encoder.c
View File

@ -26,7 +26,7 @@
/*******************************************************************************
* This file had been created by gtpv2c_tlv.py script v0.1.0
* Please do not modify this file but regenerate it via script.
* Created on: 2017-04-07 19:33:56.590092 by acetcom
* Created on: 2017-04-07 22:21:56.137354 by acetcom
* from 24301-d80.docx
******************************************************************************/
@ -37,7 +37,7 @@
c_int32_t nas_encode_attach_request(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_attach_request_t *attach_request = &message->attach_request;
nas_attach_request_t *attach_request = &message->emm.attach_request;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -261,7 +261,7 @@ c_int32_t nas_encode_attach_request(pkbuf_t *pkbuf, nas_message_t *message)
c_int32_t nas_encode_attach_accept(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_attach_accept_t *attach_accept = &message->attach_accept;
nas_attach_accept_t *attach_accept = &message->emm.attach_accept;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -427,7 +427,7 @@ c_int32_t nas_encode_attach_accept(pkbuf_t *pkbuf, nas_message_t *message)
c_int32_t nas_encode_attach_complete(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_attach_complete_t *attach_complete = &message->attach_complete;
nas_attach_complete_t *attach_complete = &message->emm.attach_complete;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -440,7 +440,7 @@ c_int32_t nas_encode_attach_complete(pkbuf_t *pkbuf, nas_message_t *message)
c_int32_t nas_encode_attach_reject(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_attach_reject_t *attach_reject = &message->attach_reject;
nas_attach_reject_t *attach_reject = &message->emm.attach_reject;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -495,7 +495,7 @@ c_int32_t nas_encode_attach_reject(pkbuf_t *pkbuf, nas_message_t *message)
c_int32_t nas_encode_authentication_request(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_authentication_request_t *authentication_request = &message->authentication_request;
nas_authentication_request_t *authentication_request = &message->emm.authentication_request;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -516,7 +516,7 @@ c_int32_t nas_encode_authentication_request(pkbuf_t *pkbuf, nas_message_t *messa
c_int32_t nas_encode_authentication_response(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_authentication_response_t *authentication_response = &message->authentication_response;
nas_authentication_response_t *authentication_response = &message->emm.authentication_response;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -529,7 +529,7 @@ c_int32_t nas_encode_authentication_response(pkbuf_t *pkbuf, nas_message_t *mess
c_int32_t nas_encode_identity_request(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_identity_request_t *identity_request = &message->identity_request;
nas_identity_request_t *identity_request = &message->emm.identity_request;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -542,7 +542,7 @@ c_int32_t nas_encode_identity_request(pkbuf_t *pkbuf, nas_message_t *message)
c_int32_t nas_encode_identity_response(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_identity_response_t *identity_response = &message->identity_response;
nas_identity_response_t *identity_response = &message->emm.identity_response;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -555,7 +555,7 @@ c_int32_t nas_encode_identity_response(pkbuf_t *pkbuf, nas_message_t *message)
c_int32_t nas_encode_authentication_failure(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_authentication_failure_t *authentication_failure = &message->authentication_failure;
nas_authentication_failure_t *authentication_failure = &message->emm.authentication_failure;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -579,7 +579,7 @@ c_int32_t nas_encode_authentication_failure(pkbuf_t *pkbuf, nas_message_t *messa
c_int32_t nas_encode_security_mode_command(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_security_mode_command_t *security_mode_command = &message->security_mode_command;
nas_security_mode_command_t *security_mode_command = &message->emm.security_mode_command;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -631,7 +631,7 @@ c_int32_t nas_encode_security_mode_command(pkbuf_t *pkbuf, nas_message_t *messag
c_int32_t nas_encode_security_mode_complete(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_security_mode_complete_t *security_mode_complete = &message->security_mode_complete;
nas_security_mode_complete_t *security_mode_complete = &message->emm.security_mode_complete;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -651,7 +651,7 @@ c_int32_t nas_encode_security_mode_complete(pkbuf_t *pkbuf, nas_message_t *messa
c_int32_t nas_encode_security_mode_reject(pkbuf_t *pkbuf, nas_message_t *message)
{
nas_security_mode_reject_t *security_mode_reject = &message->security_mode_reject;
nas_security_mode_reject_t *security_mode_reject = &message->emm.security_mode_reject;
c_int32_t encoded = 0;
c_int32_t size = 0;
@ -662,7 +662,7 @@ c_int32_t nas_encode_security_mode_reject(pkbuf_t *pkbuf, nas_message_t *message
return encoded;
}
status_t nas_plain_encode(pkbuf_t **pkbuf, nas_message_t *message)
status_t nas_emm_encode(pkbuf_t **pkbuf, nas_message_t *message)
{
status_t rv = CORE_ERROR;
c_int32_t size = 0;
@ -675,15 +675,14 @@ status_t nas_plain_encode(pkbuf_t **pkbuf, nas_message_t *message)
*pkbuf = pkbuf_alloc(NAS_HEADROOM, MAX_SDU_LEN);
d_assert(*pkbuf, return -1, "Null Param");
size = sizeof(nas_header_t);
size = sizeof(nas_emm_header_t);
rv = pkbuf_header(*pkbuf, -size);
d_assert(rv == CORE_OK, return CORE_ERROR, "pkbuf_header error");
message->h.security_header_type = 0;
memcpy((*pkbuf)->payload - size, &message->h, size);
memcpy((*pkbuf)->payload - size, &message->emm.h, size);
encoded += size;
switch(message->h.message_type)
switch(message->emm.h.message_type)
{
case NAS_ATTACH_REQUEST:
size = nas_encode_attach_request(*pkbuf, message);
@ -747,11 +746,9 @@ status_t nas_plain_encode(pkbuf_t **pkbuf, nas_message_t *message)
d_assert(size >= 0, return CORE_ERROR, "decode error");
encoded += size;
break;
case NAS_ESM_INFORMATION_REQUEST:
break;
default:
d_error("Unknown message type (0x%x) or not implemented",
message->h.message_type);
message->emm.h.message_type);
pkbuf_free((*pkbuf));
return CORE_ERROR;
}
@ -764,3 +761,61 @@ status_t nas_plain_encode(pkbuf_t **pkbuf, nas_message_t *message)
return CORE_OK;
}
status_t nas_esm_encode(pkbuf_t **pkbuf, nas_message_t *message)
{
status_t rv = CORE_ERROR;
c_int32_t size = 0;
c_int32_t encoded = 0;
d_assert(message, return CORE_ERROR, "Null param");
/* The Packet Buffer(pkbuf_t) for NAS message MUST make a HEADROOM.
* When calculating AES_CMAC, we need to use the headroom of the packet. */
*pkbuf = pkbuf_alloc(NAS_HEADROOM, MAX_SDU_LEN);
d_assert(*pkbuf, return -1, "Null Param");
size = sizeof(nas_esm_header_t);
rv = pkbuf_header(*pkbuf, -size);
d_assert(rv == CORE_OK, return CORE_ERROR, "pkbuf_header error");
memcpy((*pkbuf)->payload - size, &message->esm.h, size);
encoded += size;
switch(message->esm.h.message_type)
{
case NAS_ESM_INFORMATION_REQUEST:
break;
default:
d_error("Unknown message type (0x%x) or not implemented",
message->esm.h.message_type);
pkbuf_free((*pkbuf));
return CORE_ERROR;
}
rv = pkbuf_header(*pkbuf, encoded);
d_assert(rv == CORE_OK, return CORE_ERROR, "pkbuf_header error");
(*pkbuf)->len = encoded;
return CORE_OK;
}
status_t nas_plain_encode(pkbuf_t **pkbuf, nas_message_t *message)
{
d_assert(message, return CORE_ERROR, "Null param");
d_assert(message->emm.h.protocol_discriminator ==
message->esm.h.protocol_discriminator,
return CORE_ERROR, "check UNION for protocol");
if (message->emm.h.protocol_discriminator ==
NAS_PROTOCOL_DISCRIMINATOR_EMM)
return nas_emm_encode(pkbuf, message);
else if (message->emm.h.protocol_discriminator ==
NAS_PROTOCOL_DISCRIMINATOR_ESM)
return nas_esm_encode(pkbuf, message);
d_assert(0, return CORE_ERROR,
"Invalid Protocol : %d", message->emm.h.protocol_discriminator);
}

2
lib/nas/nas_ies.c
View File

@ -26,7 +26,7 @@
/*******************************************************************************
* This file had been created by gtpv2c_tlv.py script v0.1.0
* Please do not modify this file but regenerate it via script.
* Created on: 2017-04-07 19:33:56.575970 by acetcom
* Created on: 2017-04-07 22:21:56.122732 by acetcom
* from 24301-d80.docx
******************************************************************************/

2
lib/nas/nas_ies.h
View File

@ -26,7 +26,7 @@
/*******************************************************************************
* This file had been created by gtpv2c_tlv.py script v0.1.0
* Please do not modify this file but regenerate it via script.
* Created on: 2017-04-07 19:33:56.573522 by acetcom
* Created on: 2017-04-07 22:21:56.120273 by acetcom
* from 24301-d80.docx
******************************************************************************/

31
lib/nas/nas_message.h
View File

@ -26,7 +26,7 @@
/*******************************************************************************
* This file had been created by gtpv2c_tlv.py script v0.1.0
* Please do not modify this file but regenerate it via script.
* Created on: 2017-04-07 19:33:56.581601 by acetcom
* Created on: 2017-04-07 22:21:56.128710 by acetcom
* from 24301-d80.docx
******************************************************************************/
@ -54,11 +54,18 @@ extern "C" {
#define NAS_PROTOCOL_DISCRIMINATOR_ESM 0x2
#define NAS_PROTOCOL_DISCRIMINATOR_EMM 0x7
typedef struct _nas_header_t {
typedef struct _nas_emm_header_t {
ED2(c_uint8_t security_header_type:4;,
c_uint8_t protocol_discriminator:4;)
c_uint8_t message_type;
} __attribute__ ((packed)) nas_header_t;
} __attribute__ ((packed)) nas_emm_header_t;
typedef struct _nas_esm_header_t {
ED2(c_uint8_t eps_bearer_identity:4;,
c_uint8_t protocol_discriminator:4;)
c_uint8_t procedure_transaction_identity;
c_uint8_t message_type;
} __attribute__ ((packed)) nas_esm_header_t;
typedef struct _nas_security_header_t {
ED2(c_uint8_t security_header_type:4;,
@ -390,8 +397,8 @@ typedef struct _nas_security_mode_reject_t {
} nas_security_mode_reject_t;
typedef struct _nas_message_t {
nas_header_t h;
typedef struct _nas_emm_message_t {
nas_emm_header_t h;
union {
nas_attach_request_t attach_request;
nas_attach_accept_t attach_accept;
@ -406,6 +413,20 @@ typedef struct _nas_message_t {
nas_security_mode_complete_t security_mode_complete;
nas_security_mode_reject_t security_mode_reject;
};
} nas_emm_message_t;
typedef struct _nas_esm_message_t {
nas_esm_header_t h;
union {
};
} nas_esm_message_t;
typedef struct _nas_message_t {
nas_security_header_t h;
union {
nas_emm_message_t emm;
nas_esm_message_t esm;
};
} nas_message_t;
CORE_DECLARE(int) nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf);

231
lib/nas/support/nas_message.py
View File

@ -470,11 +470,18 @@ extern "C" {
#define NAS_PROTOCOL_DISCRIMINATOR_ESM 0x2
#define NAS_PROTOCOL_DISCRIMINATOR_EMM 0x7
typedef struct _nas_header_t {
typedef struct _nas_emm_header_t {
ED2(c_uint8_t security_header_type:4;,
c_uint8_t protocol_discriminator:4;)
c_uint8_t message_type;
} __attribute__ ((packed)) nas_header_t;
} __attribute__ ((packed)) nas_emm_header_t;
typedef struct _nas_esm_header_t {
ED2(c_uint8_t eps_bearer_identity:4;,
c_uint8_t protocol_discriminator:4;)
c_uint8_t procedure_transaction_identity;
c_uint8_t message_type;
} __attribute__ ((packed)) nas_esm_header_t;
typedef struct _nas_security_header_t {
ED2(c_uint8_t security_header_type:4;,
@ -526,20 +533,41 @@ for (k, v) in sorted_msg_list:
f.write("\n")
f.write("""typedef struct _nas_message_t {
nas_header_t h;
f.write("""typedef struct _nas_emm_message_t {
nas_emm_header_t h;
union {
""")
for (k, v) in sorted_msg_list:
if "ies" not in msg_list[k]:
continue;
if len(msg_list[k]["ies"]) == 0:
continue;
if int(msg_list[k]["type"]) < 192:
f.write(" nas_%s_t %s;\n" % (v_lower(k), v_lower(k)))
f.write(""" };
} nas_emm_message_t;
f.write(" nas_%s_t %s;\n" % (v_lower(k), v_lower(k)))
typedef struct _nas_esm_message_t {
nas_esm_header_t h;
union {
""")
for (k, v) in sorted_msg_list:
if "ies" not in msg_list[k]:
continue;
if len(msg_list[k]["ies"]) == 0:
continue;
if int(msg_list[k]["type"]) >= 192:
f.write(" nas_%s_t %s;\n" % (v_lower(k), v_lower(k)))
f.write(""" };
} nas_esm_message_t;
typedef struct _nas_message_t {
nas_security_header_t h;
union {
nas_emm_message_t emm;
nas_esm_message_t esm;
};
} nas_message_t;
CORE_DECLARE(int) nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf);
@ -572,7 +600,10 @@ for (k, v) in sorted_msg_list:
continue
f.write("c_int32_t nas_decode_%s(nas_message_t *message, pkbuf_t *pkbuf)\n{\n" % v_lower(k))
f.write(" nas_%s_t *%s = &message->%s;\n" % (v_lower(k), v_lower(k), v_lower(k)))
if int(msg_list[k]["type"]) < 192:
f.write(" nas_%s_t *%s = &message->emm.%s;\n" % (v_lower(k), v_lower(k), v_lower(k)))
else:
f.write(" nas_%s_t *%s = &message->esm.%s;\n" % (v_lower(k), v_lower(k), v_lower(k)))
f.write(" c_int32_t decoded = 0;\n")
f.write(" c_int32_t size = 0;\n\n")
@ -619,7 +650,7 @@ for (k, v) in sorted_msg_list:
""")
f.write("""status_t nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf)
f.write("""status_t nas_emm_decode(nas_message_t *message, pkbuf_t *pkbuf)
{
status_t rv = CORE_ERROR;
c_uint16_t size = 0;
@ -630,28 +661,29 @@ f.write("""status_t nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf)
memset(message, 0, sizeof(nas_message_t));
size = sizeof(nas_header_t);
size = sizeof(nas_emm_header_t);
d_assert(pkbuf_header(pkbuf, -size) == CORE_OK,
return CORE_ERROR, "pkbuf_header error");
memcpy(&message->h, pkbuf->payload - size, size);
memcpy(&message->emm.h, pkbuf->payload - size, size);
decoded += size;
switch(message->h.message_type)
switch(message->emm.h.message_type)
{
""")
for (k, v) in sorted_msg_list:
if "ies" not in msg_list[k]:
continue;
f.write(" case NAS_%s:\n" % v_upper(k))
if len(msg_list[k]["ies"]) != 0:
f.write(" size = nas_decode_%s(message, pkbuf);\n" % v_lower(k))
f.write(" d_assert(size >= CORE_OK, return CORE_ERROR, \"decode error\");\n")
f.write(" decoded += size;\n")
f.write(" break;\n")
if int(msg_list[k]["type"]) < 192:
f.write(" case NAS_%s:\n" % v_upper(k))
if len(msg_list[k]["ies"]) != 0:
f.write(" size = nas_decode_%s(message, pkbuf);\n" % v_lower(k))
f.write(" d_assert(size >= CORE_OK, return CORE_ERROR, \"decode error\");\n")
f.write(" decoded += size;\n")
f.write(" break;\n")
f.write(""" default:
d_error("Unknown message type (0x%x) or not implemented",
message->h.message_type);
message->emm.h.message_type);
break;
}
@ -662,6 +694,67 @@ f.write(""" default:
}
""")
f.write("""status_t nas_esm_decode(nas_message_t *message, pkbuf_t *pkbuf)
{
status_t rv = CORE_ERROR;
c_uint16_t size = 0;
c_uint16_t decoded = 0;
d_assert(pkbuf, return CORE_ERROR, "Null param");
d_assert(pkbuf->payload, return CORE_ERROR, "Null param");
memset(message, 0, sizeof(nas_message_t));
size = sizeof(nas_esm_header_t);
d_assert(pkbuf_header(pkbuf, -size) == CORE_OK,
return CORE_ERROR, "pkbuf_header error");
memcpy(&message->esm.h, pkbuf->payload - size, size);
decoded += size;
switch(message->esm.h.message_type)
{
""")
for (k, v) in sorted_msg_list:
if "ies" not in msg_list[k]:
continue;
if int(msg_list[k]["type"]) >= 192:
f.write(" case NAS_%s:\n" % v_upper(k))
if len(msg_list[k]["ies"]) != 0:
f.write(" size = nas_decode_%s(message, pkbuf);\n" % v_lower(k))
f.write(" d_assert(size >= CORE_OK, return CORE_ERROR, \"decode error\");\n")
f.write(" decoded += size;\n")
f.write(" break;\n")
f.write(""" default:
d_error("Unknown message type (0x%x) or not implemented",
message->esm.h.message_type);
break;
}
rv = pkbuf_header(pkbuf, decoded);
d_assert(rv == CORE_OK, return CORE_ERROR, "pkbuf_header error");
return CORE_OK;
}
status_t nas_plain_decode(nas_message_t *message, pkbuf_t *pkbuf)
{
nas_security_header_t *h = NULL;
d_assert(pkbuf, return CORE_ERROR, "Null param");
h = pkbuf->payload;
d_assert(h, return CORE_ERROR, "Null param");
if (h->protocol_discriminator == NAS_PROTOCOL_DISCRIMINATOR_EMM)
return nas_emm_decode(message, pkbuf);
else if (h->protocol_discriminator == NAS_PROTOCOL_DISCRIMINATOR_ESM)
return nas_esm_decode(message, pkbuf);
d_assert(0, return CORE_ERROR,
"Invalid Protocol : %d", h->protocol_discriminator);
}
""")
f.close()
f = open(outdir + 'nas_encoder.c', 'w')
@ -680,7 +773,10 @@ for (k, v) in sorted_msg_list:
continue
f.write("c_int32_t nas_encode_%s(pkbuf_t *pkbuf, nas_message_t *message)\n{\n" % v_lower(k))
f.write(" nas_%s_t *%s = &message->%s;\n" % (v_lower(k), v_lower(k), v_lower(k)))
if int(msg_list[k]["type"]) < 192:
f.write(" nas_%s_t *%s = &message->emm.%s;\n" % (v_lower(k), v_lower(k), v_lower(k)))
else:
f.write(" nas_%s_t *%s = &message->esm.%s;\n" % (v_lower(k), v_lower(k), v_lower(k)))
f.write(" c_int32_t encoded = 0;\n")
f.write(" c_int32_t size = 0;\n\n")
@ -709,7 +805,7 @@ for (k, v) in sorted_msg_list:
""")
f.write("""status_t nas_plain_encode(pkbuf_t **pkbuf, nas_message_t *message)
f.write("""status_t nas_emm_encode(pkbuf_t **pkbuf, nas_message_t *message)
{
status_t rv = CORE_ERROR;
c_int32_t size = 0;
@ -722,32 +818,31 @@ f.write("""status_t nas_plain_encode(pkbuf_t **pkbuf, nas_message_t *message)
*pkbuf = pkbuf_alloc(NAS_HEADROOM, MAX_SDU_LEN);
d_assert(*pkbuf, return -1, "Null Param");
size = sizeof(nas_header_t);
size = sizeof(nas_emm_header_t);
rv = pkbuf_header(*pkbuf, -size);
d_assert(rv == CORE_OK, return CORE_ERROR, "pkbuf_header error");
message->h.security_header_type = 0;
memcpy((*pkbuf)->payload - size, &message->h, size);
memcpy((*pkbuf)->payload - size, &message->emm.h, size);
encoded += size;
switch(message->h.message_type)
switch(message->emm.h.message_type)
{
""")
for (k, v) in sorted_msg_list:
if "ies" not in msg_list[k]:
continue;
f.write(" case NAS_%s:\n" % v_upper(k))
if len(msg_list[k]["ies"]) != 0:
f.write(" size = nas_encode_%s(*pkbuf, message);\n" % v_lower(k))
f.write(" d_assert(size >= 0, return CORE_ERROR, \"decode error\");\n")
f.write(" encoded += size;\n")
f.write(" break;\n")
if int(msg_list[k]["type"]) < 192:
f.write(" case NAS_%s:\n" % v_upper(k))
if len(msg_list[k]["ies"]) != 0:
f.write(" size = nas_encode_%s(*pkbuf, message);\n" % v_lower(k))
f.write(" d_assert(size >= 0, return CORE_ERROR, \"decode error\");\n")
f.write(" encoded += size;\n")
f.write(" break;\n")
f.write(""" default:
d_error("Unknown message type (0x%x) or not implemented",
message->h.message_type);
message->emm.h.message_type);
pkbuf_free((*pkbuf));
return CORE_ERROR;
}
@ -761,5 +856,77 @@ f.write(""" default:
}
""")
f.write("""status_t nas_esm_encode(pkbuf_t **pkbuf, nas_message_t *message)
{
status_t rv = CORE_ERROR;
c_int32_t size = 0;
c_int32_t encoded = 0;
d_assert(message, return CORE_ERROR, "Null param");
/* The Packet Buffer(pkbuf_t) for NAS message MUST make a HEADROOM.
* When calculating AES_CMAC, we need to use the headroom of the packet. */
*pkbuf = pkbuf_alloc(NAS_HEADROOM, MAX_SDU_LEN);
d_assert(*pkbuf, return -1, "Null Param");
size = sizeof(nas_esm_header_t);
rv = pkbuf_header(*pkbuf, -size);
d_assert(rv == CORE_OK, return CORE_ERROR, "pkbuf_header error");
memcpy((*pkbuf)->payload - size, &message->esm.h, size);
encoded += size;
switch(message->esm.h.message_type)
{
""")
for (k, v) in sorted_msg_list:
if "ies" not in msg_list[k]:
continue;
if int(msg_list[k]["type"]) >= 192:
f.write(" case NAS_%s:\n" % v_upper(k))
if len(msg_list[k]["ies"]) != 0:
f.write(" size = nas_encode_%s(*pkbuf, message);\n" % v_lower(k))
f.write(" d_assert(size >= 0, return CORE_ERROR, \"decode error\");\n")
f.write(" encoded += size;\n")
f.write(" break;\n")
f.write(""" default:
d_error("Unknown message type (0x%x) or not implemented",
message->esm.h.message_type);
pkbuf_free((*pkbuf));
return CORE_ERROR;
}
rv = pkbuf_header(*pkbuf, encoded);
d_assert(rv == CORE_OK, return CORE_ERROR, "pkbuf_header error");
(*pkbuf)->len = encoded;
return CORE_OK;
}
status_t nas_plain_encode(pkbuf_t **pkbuf, nas_message_t *message)
{
d_assert(message, return CORE_ERROR, "Null param");
d_assert(message->emm.h.protocol_discriminator ==
message->esm.h.protocol_discriminator,
return CORE_ERROR, "check UNION for protocol");
if (message->emm.h.protocol_discriminator ==
NAS_PROTOCOL_DISCRIMINATOR_EMM)
return nas_emm_encode(pkbuf, message);
else if (message->emm.h.protocol_discriminator ==
NAS_PROTOCOL_DISCRIMINATOR_ESM)
return nas_esm_encode(pkbuf, message);
d_assert(0, return CORE_ERROR,
"Invalid Protocol : %d", message->emm.h.protocol_discriminator);
}
""")
f.close()

19
src/mme/emm_handler.c
View File

@ -67,7 +67,7 @@ void emm_handle_authentication_response(
nas_message_t message;
pkbuf_t *sendbuf = NULL;
nas_security_mode_command_t *security_mode_command =
&message.security_mode_command;
&message.emm.security_mode_command;
nas_security_algorithms_t *selected_nas_security_algorithms =
&security_mode_command->selected_nas_security_algorithms;
nas_key_set_identifier_t *nas_key_set_identifier =
@ -89,8 +89,12 @@ void emm_handle_authentication_response(
d_info("[NAS] Authentication response : UE[%s] --> EMM", ue->imsi);
memset(&message, 0, sizeof(message));
message.h.security_header_type =
NAS_SECURITY_HEADER_INTEGRITY_PROTECTED_AND_NEW_SECURITY_CONTEXT;
message.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.h.message_type = NAS_SECURITY_MODE_COMMAND;
message.emm.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.emm.h.message_type = NAS_SECURITY_MODE_COMMAND;
selected_nas_security_algorithms->type_of_ciphering_algorithm =
mme_self()->selected_enc_algorithm;
@ -119,8 +123,6 @@ void emm_handle_authentication_response(
mme_kdf_nas(MME_KDF_NAS_ENC_ALG, mme_self()->selected_enc_algorithm,
ue->kasme, ue->knas_enc);
message.h.security_header_type =
NAS_SECURITY_HEADER_INTEGRITY_PROTECTED_AND_NEW_SECURITY_CONTEXT;
d_assert(nas_security_encode(&sendbuf, ue, &message) == CORE_OK &&
sendbuf,,);
mme_event_nas_to_s1ap(ue, sendbuf);
@ -135,11 +137,14 @@ void emm_handle_security_mode_complete(mme_ue_t *ue)
pkbuf_t *sendbuf = NULL;
memset(&message, 0, sizeof(message));
message.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_ESM;
message.h.message_type = NAS_ESM_INFORMATION_REQUEST;
message.h.security_header_type =
NAS_SECURITY_HEADER_INTEGRITY_PROTECTED_AND_CIPHERED;
message.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.esm.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_ESM;
message.esm.h.procedure_transaction_identity = 33;
message.esm.h.message_type = NAS_ESM_INFORMATION_REQUEST;
d_assert(nas_security_encode(&sendbuf, ue, &message) == CORE_OK &&
sendbuf,,);
d_print_hex(sendbuf->payload, sendbuf->len);

8
src/mme/emm_sm.c
View File

@ -58,12 +58,12 @@ void emm_state_operational(emm_sm_t *s, event_t *e)
break;
}
switch(message.h.message_type)
switch(message.emm.h.message_type)
{
case NAS_ATTACH_REQUEST:
{
emm_handle_attach_request(
ue, &message.attach_request);
ue, &message.emm.attach_request);
break;
}
case NAS_AUTHENTICATION_REQUEST:
@ -79,7 +79,7 @@ void emm_state_operational(emm_sm_t *s, event_t *e)
case NAS_AUTHENTICATION_RESPONSE:
{
emm_handle_authentication_response(
ue, &message.authentication_response);
ue, &message.emm.authentication_response);
break;
}
case NAS_SECURITY_MODE_COMPLETE:
@ -92,7 +92,7 @@ void emm_state_operational(emm_sm_t *s, event_t *e)
}
default:
{
d_warn("Not implemented(type:%d)", message.h.message_type);
d_warn("Not implemented(type:%d)", message.emm.h.message_type);
break;
}
}

4
src/mme/esm_sm.c
View File

@ -58,7 +58,7 @@ void esm_state_operational(esm_sm_t *s, event_t *e)
break;
}
switch(message.h.message_type)
switch(message.emm.h.message_type)
{
case NAS_PDN_CONNECTIVITY_REQUEST:
{
@ -66,7 +66,7 @@ void esm_state_operational(esm_sm_t *s, event_t *e)
}
default:
{
d_warn("Not implemented(type:%d)", message.h.message_type);
d_warn("Not implemented(type:%d)", message.emm.h.message_type);
break;
}
}

6
src/mme/mme_s6a_handler.c
View File

@ -145,7 +145,7 @@ static void mme_s6a_aia_cb(void *data, struct msg **msg)
pkbuf_t *sendbuf = NULL;
event_t e;
nas_authentication_request_t *authentication_request =
&message.authentication_request;
&message.emm.authentication_request;
CHECK_SYS_DO(clock_gettime(CLOCK_REALTIME, &ts), return);
@ -175,8 +175,8 @@ static void mme_s6a_aia_cb(void *data, struct msg **msg)
}
memset(&message, 0, sizeof(message));
message.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.h.message_type = NAS_AUTHENTICATION_REQUEST;
message.emm.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.emm.h.message_type = NAS_AUTHENTICATION_REQUEST;
d_assert(fd_msg_search_avp(*msg, s6a_authentication_info, &avp) == 0 && avp,
error++; goto out,);

2
src/mme/nas_security.c
View File

@ -59,7 +59,7 @@ status_t nas_security_encode(
memset(&h, 0, sizeof(h));
h.security_header_type = message->h.security_header_type;
h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
h.protocol_discriminator = message->h.protocol_discriminator;
h.sequence_number = (ue->dl_count & 0xff);
d_assert(nas_plain_encode(&new, message) == CORE_OK,

24
test/nas_message_test.c
View File

@ -53,14 +53,14 @@ static void nas_message_test2(abts_case *tc, void *data)
char esm_buffer[50];
nas_message_t message;
nas_attach_accept_t *attach_accept = &message.attach_accept;
nas_attach_accept_t *attach_accept = &message.emm.attach_accept;
pkbuf_t *pkbuf = NULL;
status_t rv;
memset(&message, 0, sizeof(message));
message.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.h.message_type = NAS_ATTACH_ACCEPT;
message.emm.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.emm.h.message_type = NAS_ATTACH_ACCEPT;
attach_accept->eps_attach_result.result =
NAS_ATTACH_RESULT_COMBINED_EPS_IMSI_ATTACH;
attach_accept->t3412_value.unit =
@ -137,14 +137,14 @@ static void nas_message_test4(abts_case *tc, void *data)
char buffer[3];
nas_message_t message;
nas_attach_reject_t *attach_reject = &message.attach_reject;
nas_attach_reject_t *attach_reject = &message.emm.attach_reject;
pkbuf_t *pkbuf = NULL;
status_t rv;
memset(&message, 0, sizeof(message));
message.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.h.message_type = NAS_ATTACH_REJECT;
message.emm.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.emm.h.message_type = NAS_ATTACH_REJECT;
attach_reject->emm_cause = NAS_EMM_CAUSE_NETWORK_FAILURE;
rv = nas_plain_encode(&pkbuf, &message);
@ -177,7 +177,7 @@ static void nas_message_test6(abts_case *tc, void *data)
char hexbuf[MAX_SDU_LEN];
nas_message_t message;
nas_identity_request_t *identity_request = &message.identity_request;
nas_identity_request_t *identity_request = &message.emm.identity_request;
pkbuf_t *pkbuf;
status_t rv;
@ -191,8 +191,8 @@ static void nas_message_test6(abts_case *tc, void *data)
ABTS_INT_EQUAL(tc, CORE_OK, rv);
ABTS_INT_EQUAL(tc, NAS_PROTOCOL_DISCRIMINATOR_EMM,
message.h.protocol_discriminator);
ABTS_INT_EQUAL(tc, NAS_IDENTITY_REQUEST, message.h.message_type);
message.emm.h.protocol_discriminator);
ABTS_INT_EQUAL(tc, NAS_IDENTITY_REQUEST, message.emm.h.message_type);
ABTS_INT_EQUAL(tc, NAS_IDENTITY_TYPE_2_IMSI,
identity_request->identity_type.type_of_identity);
@ -206,14 +206,14 @@ static void nas_message_test7(abts_case *tc, void *data)
char buffer[11];
nas_message_t message;
nas_identity_response_t *identity_response = &message.identity_response;
nas_identity_response_t *identity_response = &message.emm.identity_response;
pkbuf_t *pkbuf = NULL;
status_t rv;
memset(&message, 0, sizeof(message));
message.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.h.message_type = NAS_IDENTITY_RESPONSE;
message.emm.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM;
message.emm.h.message_type = NAS_IDENTITY_RESPONSE;
identity_response->mobile_identity.length = 8;
identity_response->mobile_identity.imsi.digit1 = 0;