/*****************************************************************************
			Eurecom OpenAirInterface 3
			Copyright(c) 2012 Eurecom

Source		as_process.c

Version		0.1

Date		2013/04/11

Product		Access-Stratum sublayer simulator

Subsystem	AS message processing

Author		Frederic Maurel

Description	Defines functions executed by the Access-Stratum sublayer
		upon receiving AS messages from the Non-Access-Stratum.

*****************************************************************************/

#include "as_process.h"
#include "nas_process.h"

#include "commonDef.h"
#include "as_data.h"

#include <sys/types.h>
#include <stdio.h>	// snprintf
#include <string.h>	// memcpy

/****************************************************************************/
/****************  E X T E R N A L    D E F I N I T I O N S  ****************/
/****************************************************************************/

/****************************************************************************/
/*******************  L O C A L    D E F I N I T I O N S  *******************/
/****************************************************************************/

/* Message Sequence Chart Generator's buffer */
#define MSCGEN_BUFFER_SIZE	1024
static char _mscgen_buffer[MSCGEN_BUFFER_SIZE];

/* Tracking area code */
#define DEFAULT_TAC	0xCAFE		// two byte in hexadecimal format

/* Cell identity */
#define DEFAULT_CI	0x01020304	// four byte in hexadecimal format

/* Reference signal received power */
#define DEFAULT_RSRP	27

/* Reference signal received quality */
#define DEFAULT_RSRQ	55

static ssize_t _process_plmn(char* buffer, const plmn_t* plmn, size_t len);
static int _process_dump(char* buffer, int len, const char* msg, int size);

/****************************************************************************/
/******************  E X P O R T E D    F U N C T I O N S  ******************/
/****************************************************************************/

/*
 * =============================================================================
 *	Functions used to process messages received from the UE NAS process
 * =============================================================================
 */

/*
 * -----------------------------------------------------------------------------
 *		    Process cell information request message
 * -----------------------------------------------------------------------------
 */
int process_cell_info_req(int msg_id, const cell_info_req_t* req,
			  cell_info_cnf_t* cnf)
{
    int index = 0;

    printf("INFO\t: %s - Process cell information request\n", __FUNCTION__);

    index += _process_plmn(_mscgen_buffer, &req->plmnID, MSCGEN_BUFFER_SIZE);
    snprintf(_mscgen_buffer + index, MSCGEN_BUFFER_SIZE - index,
	     ", rat = 0x%x%c", req->rat, '\0');
    MSCGEN("[MSC_MSG][%s][%s][--- Cell Information Request (0x%.4x)\\n%s --->][%s]\n",
	   getTime(), _ue_id, msg_id, _mscgen_buffer, _as_id);

    /* Setup cell information confirm message */
    cnf->errCode = AS_SUCCESS;
    cnf->tac = DEFAULT_TAC;
    cnf->cellID = DEFAULT_CI;
    cnf->rat = AS_EUTRAN;
    cnf->rsrp = DEFAULT_RSRP;
    cnf->rsrq = DEFAULT_RSRQ;

    snprintf(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
	     "tac = 0x%.4x, cellID = 0x%.8x, rat = 0x%x, RSRQ = %u, RSRP = %u%c",
	     cnf->tac, cnf->cellID, cnf->rat, cnf->rsrq, cnf->rsrp, '\0');
    MSCGEN("[MSC_MSG][%s][%s][--- Cell Information Confirm (0x%.4x)\\n%s --->][%s]\n",
	   getTime(), _as_id, AS_CELL_INFO_CNF, _mscgen_buffer, _ue_id);

    printf("INFO\t: %s - Send cell informtion confirm\n", __FUNCTION__);
    return (AS_CELL_INFO_CNF);
}

/*
 * -----------------------------------------------------------------------------
 *	Process NAS signalling connection establishment request message
 * -----------------------------------------------------------------------------
 */
int process_nas_establish_req(int msg_id, const nas_establish_req_t* req,
			      nas_establish_ind_t* ind,
			      nas_establish_cnf_t* cnf)
{
    int bytes;

    printf("INFO\t: %s - Process NAS signalling connection establishment "
	   "request\n", __FUNCTION__);

    // Attach_Request.Pdn_Connectivity_Request.ebi = 5
    //req->initialNasMsg.data[23] = 0x52; // MME DEBUG (Reject Attachment)
    // Attach_Request.Pdn_Connectivity_Request.messagetype = WRONG_MESSAGE_TYPE
    //req->initialNasMsg.data[25] = 0xc4; // MME DEBUG (Send ESM status)
	    
    snprintf(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
	     "cause = %s, type = %s, tmsi = {MMEcode = %d, m_tmsi = %u}%c",
	     rrcCause(req->cause), rrcType(req->type),
	     req->s_tmsi.MMEcode, req->s_tmsi.m_tmsi, '\0');
    MSCGEN("[MSC_MSG][%s][%s][--- NAS Signalling Connection Establishment Request "
	   "(0x%.4x)\\n%s --->][%s]\n",
	   getTime(), _ue_id, msg_id, _mscgen_buffer, _as_id);

    _process_dump(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
		 (char*)req->initialNasMsg.data, req->initialNasMsg.length);
    MSCGEN("[MSC_RBOX][%s][%s][%s]\n", _ue_id, _as_id, _mscgen_buffer);

    /* Process initial NAS message */
    bytes = nas_process(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
			(char*)req->initialNasMsg.data,
			req->initialNasMsg.length);
    if (bytes < 0) {
	MSCGEN("[MSC_MSG][%s][%s][--- NAS Signalling Connection Establishment "
	       "Indication (0x%.4x)\\ntac = 0x%.4x\\n%s ---x][%s]\n", getTime(),
	       _as_id, AS_NAS_ESTABLISH_IND, ind->tac, _mscgen_buffer, _mme_id);
	/* Setup NAS signalling connection establishment confirmation message */
	cnf->errCode = AS_TERMINATED_AS;
	return (0);
    }

    /* Setup NAS signalling connection establishment indication message */
    ind->UEid = 1;	// Valid UEid starts at index 1
    ind->tac = DEFAULT_TAC;
    if (req->initialNasMsg.length > 0) {
	ind->initialNasMsg.data = (Byte_t*)malloc(req->initialNasMsg.length);
	if (ind->initialNasMsg.data) {
	    memcpy(ind->initialNasMsg.data, req->initialNasMsg.data,
		   req->initialNasMsg.length);
	    ind->initialNasMsg.length = req->initialNasMsg.length;
	}
    }

    // Attach_Request.messagetype = WRONG_MESSAGE_TYPE
    //ind->initialNasMsg.data[1] = 0x47; // MME DEBUG (Send EMM status)

    /* Setup NAS signalling connection establishment confirmation message */
    cnf->errCode = AS_SUCCESS;
    // Transmission failure of Attach Request message
    //cnf->errCode = AS_FAILURE; // UE DEBUG

    MSCGEN("[MSC_MSG][%s][%s][--- NAS Signalling Connection Establishment Indication "
	   "(0x%.4x)\\nUEid = %u, tac = 0x%.4x\\n%s --->][%s]\n", getTime(),
	   _as_id, AS_NAS_ESTABLISH_IND, ind->UEid, ind->tac, _mscgen_buffer, _mme_id);

    printf("INFO\t: %s - Send NAS signalling connection establishment "
	   "indication\n", __FUNCTION__);
    return (AS_NAS_ESTABLISH_IND);
}

/*
 * -----------------------------------------------------------------------------
 *		Process Uplink data transfer request message
 * -----------------------------------------------------------------------------
 */
int process_ul_info_transfer_req(int msg_id, const ul_info_transfer_req_t* req,
				 ul_info_transfer_ind_t* ind,
				 ul_info_transfer_cnf_t* cnf)
{
    int bytes;

    printf("INFO\t: %s - Process uplink data transfer request\n", __FUNCTION__);

    // Attach_Complete.Activate_Default_EPS_Bearer_Context_Accept.ebi = UNASSIGNED
    //if (req->nasMsg.data[7] == 0x43) {
    //	req->nasMsg.data[10] = 0x02; // MME DEBUG (Send ESM status)
    //}
    // Deactivate_EPS_Bearer_Context_Accept.ebi = UNASSIGNED
    //if (req->nasMsg.data[8] == 0xCE) {
    //	req->nasMsg.data[6] = 0x02; // MME DEBUG (Discard ESM message)
    //}
	    
    snprintf(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
	     "tmsi = {MMEcode = %d, m_tmsi = %u}%c",
	     req->s_tmsi.MMEcode, req->s_tmsi.m_tmsi, '\0');
    MSCGEN("[MSC_MSG][%s][%s][--- Uplink Information Request "
	   "(0x%.4x)\\n%s --->][%s]\n",
	   getTime(), _ue_id, msg_id, _mscgen_buffer, _as_id);

    _process_dump(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
		 (char*)req->nasMsg.data, req->nasMsg.length);
    MSCGEN("[MSC_RBOX][%s][%s][%s]\n", _ue_id, _as_id, _mscgen_buffer);

    /* Process NAS message */
    bytes = nas_process(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
			(char*)req->nasMsg.data,
			req->nasMsg.length);
    if (bytes < 0) {
	MSCGEN("[MSC_MSG][%s][%s][--- Uplink Information Indication "
	       "(0x%.4x)\\n%s ---x][%s]\n", getTime(),
	       _as_id, AS_UL_INFO_TRANSFER_IND, _mscgen_buffer, _mme_id);
	/* Setup uplink information confirmation message */
	cnf->errCode = AS_TERMINATED_AS;
	return (0);
    }

    /* Setup uplink information indication message */
    ind->UEid = 1;	// Valid UEid starts at index 1
    if (req->nasMsg.length > 0) {
	ind->nasMsg.data = (Byte_t*)malloc(req->nasMsg.length);
	if (ind->nasMsg.data) {
	    memcpy(ind->nasMsg.data, req->nasMsg.data, req->nasMsg.length);
	    ind->nasMsg.length = req->nasMsg.length;
	}
    }

    // Identity-Response.messagetype = WRONG_MESSAGE_TYPE
    //if (ind->nasMsg.data[1] == 0x56) {
    //	ind->nasMsg.data[1] = 0x47; // MME DEBUG (Send EMM status)
    //}
    // Authentication-Response.messagetype = WRONG_MESSAGE_TYPE
    //if (ind->nasMsg.data[1] == 0x53) {
    //	ind->nasMsg.data[1] = 0x47; // MME DEBUG (Send EMM status)
    //}
    // Security-Mode-Complete.messagetype = WRONG_MESSAGE_TYPE
    //if (ind->nasMsg.data[7] == 0x5e) {
    //	ind->nasMsg.data[7] = 0x47; // MME DEBUG (Send EMM status)
    //}

    /* Setup uplink information confirmation message */
    cnf->UEid = 0;
    cnf->errCode = AS_SUCCESS;
    // Transmission failure of Attach Complete message
    //if (req->nasMsg.data[7] == 0x43) {
    //	cnf->errCode = AS_FAILURE; // UE DEBUG
    //}

    MSCGEN("[MSC_MSG][%s][%s][--- Uplink Information Indication "
	   "(0x%.4x), UEid = %u\\n%s --->][%s]\n", getTime(),
	   _as_id, AS_UL_INFO_TRANSFER_IND, ind->UEid, _mscgen_buffer, _mme_id);

    printf("INFO\t: %s - Send uplink data transfer indication\n", __FUNCTION__);
    return (AS_UL_INFO_TRANSFER_IND);
}

/*
 * -----------------------------------------------------------------------------
 *	    Process NAS signalling connection release request message
 * -----------------------------------------------------------------------------
 */
int process_nas_release_req(int msg_id, const nas_release_req_t* req)
{
    printf("INFO\t: %s - Process NAS signalling connection release request\n",
	   __FUNCTION__);

    MSCGEN("[MSC_MSG][%s][%s][--- NAS Signalling Release Request "
	   "(0x%.4x), tmsi = {MMEcode = %d, m_tmsi = %u}, "
	   "cause = %s (%u) --->][%s]\n", getTime(), _ue_id, msg_id,
	   req->s_tmsi.MMEcode, req->s_tmsi.m_tmsi,
	   rrcReleaseCause(req->cause), req->cause, _as_id);
    return (AS_NAS_RELEASE_REQ);
}

/*
 * =============================================================================
 *	Functions used to process messages received from the MME NAS process
 * =============================================================================
 */

/*
 * -----------------------------------------------------------------------------
 *	Process NAS signalling connection establishment response message
 * -----------------------------------------------------------------------------
 */
int process_nas_establish_rsp(int msg_id, const nas_establish_rsp_t* rsp,
			      nas_establish_cnf_t* cnf)
{
    int bytes;

    printf("INFO\t: %s - Process NAS signalling connection establishment "
	   "response\n", __FUNCTION__);

    // Attach_Accept
    //if (rsp->nasMsg.data[7] == 0x42) {
	// Activate_Default_EPS_Bearer_Context_Request.ebi = UNASSIGNED
    	//rsp->nasMsg.data[19] = 0x02; // UE DEBUG (Send ESM status)
	// Activate_Default_EPS_Bearer_Context_Request.messagetype = WRONG_MESSAGE_TYPE
	//rsp->nasMsg.data[21] = 0xc4; // MME DEBUG (Send ESM status)
    //}

    MSCGEN("[MSC_MSG][%s][%s][--- NAS Signalling Connection Establishment "
	   "Response (0x%.4x)\\nerrCode = %s, UEid = %u --->][%s]\n",
	   getTime(), _mme_id, msg_id,
	   rrcErrCode(rsp->errCode), rsp->UEid, _as_id);

    _process_dump(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
		 (char*)rsp->nasMsg.data, rsp->nasMsg.length);
    MSCGEN("[MSC_RBOX][%s][%s][%s]\n", _mme_id, _as_id, _mscgen_buffer);

    // Discard Attach Accept message
    //return (0); // UE DEBUG

    /* Process initial NAS message */
    bytes = nas_process(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
			(char*)rsp->nasMsg.data,
			rsp->nasMsg.length);

    if (bytes < 0) {
	MSCGEN("[MSC_MSG][%s][%s][--- NAS Signalling Connection Establishment "
	       "Confirm (0x%.4x)\\n%s ---x][%s]\n", getTime(),
	       _as_id, AS_NAS_ESTABLISH_CNF, _mscgen_buffer, _ue_id);
	return (0);
    }

    /* Setup NAS signalling connection establishment confirm message */
    cnf->errCode = rsp->errCode;
    if (rsp->nasMsg.length > 0) {
	cnf->nasMsg.data = (Byte_t*)malloc(rsp->nasMsg.length);
	if (cnf->nasMsg.data) {
	    memcpy(cnf->nasMsg.data, rsp->nasMsg.data,
		   rsp->nasMsg.length);
	    cnf->nasMsg.length = rsp->nasMsg.length;
	}
    }

    MSCGEN("[MSC_MSG][%s][%s][--- NAS Signalling Connection Establishment "
	   "Confirm (0x%.4x)\\n%s --->][%s]\n", getTime(),
	   _as_id, AS_NAS_ESTABLISH_CNF, _mscgen_buffer, _ue_id);

    printf("INFO\t: %s - Send NAS signalling connection establishment "
	   "confirm\n", __FUNCTION__);
    return (AS_NAS_ESTABLISH_CNF);
}

/*
 * -----------------------------------------------------------------------------
 *		Process Downlink data transfer request message
 * -----------------------------------------------------------------------------
 */
int process_dl_info_transfer_req(int msg_id, const dl_info_transfer_req_t* req,
				 dl_info_transfer_ind_t* ind,
				 dl_info_transfer_cnf_t* cnf)
{
    int bytes;

    printf("INFO\t: %s - Process downlink data transfer request\n",
	   __FUNCTION__);

    // Activate_default_EPS_Bearer_Context_Request.ebi = 6 (already active)
    //if (req->nasMsg.data[8] == 0xC1) {
    //	req->nasMsg.data[6] = 0x52; // UE DEBUG (Accept with same ebi)
    //}
    // Deactivate_EPS_Bearer_Context_Request.ebi = UNASSIGNED
    //if (req->nasMsg.data[8] == 0xCD) {
    //	req->nasMsg.data[6] = 0x02; // UE DEBUG
    //}

    MSCGEN("[MSC_MSG][%s][%s][--- Downlink Information Request "
	   "(0x%.4x), UEid = %u --->][%s]\n",
	   getTime(), _mme_id, msg_id, req->UEid, _as_id);

    _process_dump(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
		 (char*)req->nasMsg.data, req->nasMsg.length);
    MSCGEN("[MSC_RBOX][%s][%s][%s]\n", _mme_id, _as_id, _mscgen_buffer);

    /* Process NAS message */
    bytes = nas_process(_mscgen_buffer, MSCGEN_BUFFER_SIZE,
			(char*)req->nasMsg.data,
			req->nasMsg.length);
    if (bytes < 0) {
	MSCGEN("[MSC_MSG][%s][%s][--- Downlink Information Indication "
	       "(0x%.4x)\\n%s ---x][%s]\n", getTime(),
	       _as_id, AS_DL_INFO_TRANSFER_IND, _mscgen_buffer, _ue_id);
	/* Setup downlink information confirmation message */
	cnf->UEid = req->UEid;
	cnf->errCode = AS_TERMINATED_AS;
	return (0);
    }

    /* Setup downlink information indication message */
    if (req->nasMsg.length > 0) {
	ind->nasMsg.data = (Byte_t*)malloc(req->nasMsg.length);
	if (ind->nasMsg.data) {
	    memcpy(ind->nasMsg.data, req->nasMsg.data, req->nasMsg.length);
	    ind->nasMsg.length = req->nasMsg.length;
	}
    }

    /* Setup downlink information confirmation message */
    cnf->UEid = req->UEid;
    cnf->errCode = AS_SUCCESS;

    //if (req->nasMsg.data[1] == 0x55) {
	// Transmission failure of identification request message
    //	cnf->errCode = AS_FAILURE; // MME DEBUG
	// Discard identification request message
    //	return (0); // MME DEBUG
    //}

    MSCGEN("[MSC_MSG][%s][%s][--- Downlink Information Indication "
	   "(0x%.4x)\\n%s --->][%s]\n", getTime(),
	   _as_id, AS_DL_INFO_TRANSFER_IND, _mscgen_buffer, _ue_id);

    printf("INFO\t: %s - Send downlink data transfer indication\n", __FUNCTION__);
    return (AS_DL_INFO_TRANSFER_IND);
}

/*
 * -----------------------------------------------------------------------------
 *	    Process NAS signalling connection release indication message
 * -----------------------------------------------------------------------------
 */
int process_nas_release_ind(int msg_id, const nas_release_req_t* req,
			    nas_release_ind_t* ind)
{
    printf("INFO\t: %s - Process NAS signalling connection release request\n",
	   __FUNCTION__);

    MSCGEN("[MSC_MSG][%s][%s][--- NAS Signalling Connection Release Request "
	   "(0x%.4x), UEid = %u, cause = %s (%u) --->][%s]\n",
	   getTime(), _mme_id, msg_id, req->UEid,
	   rrcReleaseCause(req->cause), req->cause, _as_id);

    /* Forward NAS release indication to the UE */
    ind->cause = req->cause;
    MSCGEN("[MSC_MSG][%s][%s][--- NAS Signalling Connection Release Indication "
	   "(0x%.4x), cause = %s (%u) --->][%s]\n",
	   getTime(), _as_id, msg_id, rrcReleaseCause(req->cause),
	   ind->cause, _ue_id);

    printf("INFO\t: %s - Send NAS signalling connection release indication\n",
	   __FUNCTION__);
    return (AS_NAS_RELEASE_IND);
}

/****************************************************************************/
/*********************  L O C A L    F U N C T I O N S  *********************/
/****************************************************************************/

/*
 * -----------------------------------------------------------------------------
 *				Display PLMN identity
 * ----------------------------------------------------------------------------- 
 */
static ssize_t _process_plmn(char* buffer, const plmn_t* plmn, size_t len)
{
    int index = 0;
    index += snprintf(buffer + index, len - index, "plmnID = %u%u%u%u%u",
		  plmn->MCCdigit1, plmn->MCCdigit2, plmn->MCCdigit3,
		  plmn->MNCdigit1, plmn->MNCdigit2);
    if ( (index < len) && (plmn->MNCdigit3 != 0xf) ) {
	index += snprintf(buffer + index, len - index, "%u", plmn->MNCdigit3);
    }
    return (index);
}

/*
 * -----------------------------------------------------------------------------
 *				Message dump utility
 * ----------------------------------------------------------------------------- 
 */
static int _process_dump(char* buffer, int len, const char* msg, int size)
{
    int index = 0;
    for (int i = 0; i < size; i++) {
	if ( (i%16) == 0 ) index += snprintf(buffer + index,
					     len - index, "\\n");
	index += snprintf(buffer + index, len - index,
			  " %.2hx", (unsigned char)(msg[i]));
    }
    buffer[index] = '\0';
    return (index);
}

/*
        04 01 04 10 00 00 0f 00 00 00 01 00 00 00 20 8f 
        10 00 22 00 00 00 07 41 71 0b f6 02 f8 01 01 02 
        0f 00 00 00 01 05 80 80 00 00 00 00 04 02 01 d0 
        31 52 02 f8 01 00 01 e0 
*/
/*
  U16 msgID = [04 01]	- AS_NAS_ESTABLISH_REQ
  U8 cause = [04]	- NET_ESTABLISH_CAUSE_MO_SIGNAL
  U8 type = [10]	- NET_ESTABLISH_TYPE_ORIGINATING_SIGNAL
  as_stmsi_t s_tmsi
	U8 MMEcode = [0f]
	U32 m_tmsi = [00 00 00 01]
  plmn_t plmnID = [20 8f 10]
	Byte_t MCCdigit2:4 = [0]
	Byte_t MCCdigit1:4 = [2]
	Byte_t MNCdigit3:4 = [f]
	Byte_t MCCdigit3:4 = [8]
	Byte_t MNCdigit2:4 = [0]
	Byte_t MNCdigit1:4 = [1]

  U32 Length = [22 00 00 00] (34 octets)
  U8* initialNasMsg = [07 41 71 0b f6 02 f8 01 01 02 0f 00 00 00 01 05]
  		      [80 80 00 00 00 00 04 02 01 d0 31 52 02 f8 01 00]
		      [01 e0]

  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [41]	- Attach Request

  U8:4 NAS KSI = [7]	- No key available
  U8:4 Attach Type = [1]
  EPS Mobile Identity = [0b f6 02 f8 01 01 02 0f 00 00 00 01]
  Length = [0b] (11 bytes)
	U8:4 = 1111 = [f]
	U8:1 oddeven = 0
	U8:3 typeofidentity = 110 = [6]	- GUTI
	U8:4 mccdigit2 = [0]
	U8:4 mccdigit1 = [2]
	U8:4 mncdigit3 = [f]
	U8:4 mccdigit3 = [8]
	U8:4 mncdigit2 = [0]
	U8:4 mncdigit1 = [1]
	U16  mmegroupid = [01 02]
	U8   mmecode = [0f]
	U32  mtmsi = [00 00 00 01]
  UE network capability = [05 80 80 00 00 00]
  Length = [05] (5 bytes)
 	U8   eea = [80]	- EEA0
	U8   eia = [80]	- EIA0
	U8   uea = [00]
	U8:1 ucs2 = 0
	U8:7 uia = 0000000 = [00]
	U8:3 spare = 000
	U8:1 csfb = 0
	U8:1 lpp = 0
	U8:1 lcs = 0
	U8:1 srvcc = 0
	U8:1 nf = 0 = [00]

  ESM message container = [00 04 02 01 d0 31]
  Length = [00 04] (4 bytes)
  ESM message = [02 01 d0 31]
  U8:4 EPS bearer identity = [0]	- Not assigned
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [01]
  U8   ESM message identifier = [d0]	- PDN Connectivity Request
  U8:4 Pdn type = [3]			- IPv4v6
  U8:4 Request type = [1]		- Initial request

  Last TAI = [52 02 f8 01 00 01]	- PLMN = 20810, TAC = 00 01
  Old GUTI type = [e0]			- Native GUTI
*/

/*
        07 04 00 00 00 00 03 00 00 00 07 44 03 
*/
/*
  U16 msgID = [07 04]	- AS_DL_INFO_TRANSFER_IND
  U32 UEid = [00 00 00 00]

  U32 Length = [03 00 00 00] (3 octets)
  U8* NasMsg = [07 44 03]

  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [44]	- Attach Reject

  U8   EMM cause code = [03]		- EMM_CAUSE_ILLEGAL_UE
*/

/*
        07 04 00 00 00 00 10 00 00 00 27 ab ab ab ab 00 
        07 44 13 78 00 04 02 01 d1 1f 
*/
/*
  U16 msgID = [07 04]	- AS_DL_INFO_TRANSFER_IND
  U32 UEid = [00 00 00 00]

  U32 Length = [10 00 00 00] (16 octets)
  U8* NasMsg = [27 ab ab ab ab 00 07 44 13 78 00 04 02 01 d1 1f]

  U8:4 Security header type = [2]	- Integrity protected and cyphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- 0

  NAS message = [07 44 13 78 00 04 02 d1 1f]
  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [44]	- Attach Reject

  U8   EMM cause code = [13]		- #19 ESM failure

  ESM message container = [00 04 02 01 d1 1f]
  U16 Length = [00 04] (4 octets)
  U8* EsmMsg = [02 01 d1 1f]
  U8:4 EPS bearer identity = [0]	- Not assigned
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [01]
  U8   ESM message identifier = [d1]	- PDN Connectivity Reject

  U8   ESM cause code = [1f]		- REQUEST_REJECTED_UNSPECIFIED
*/

/*
        04 08 01 00 00 00 46 00 00 00 27 ab ab ab ab 00 
        07 42 01 e0 06 24 02 f8 01 00 01 00 26 52 01 c1 
        05 03 48 87 40 78 0e 77 77 77 2e 65 75 72 65 63 
        6f 6d 2e 66 72 0d 03 c0 a8 02 3c 02 21 70 ff c0 
        a8 02 3c 50 0b f6 02 f8 01 01 02 0f 00 00 00 01 
*/
/*
  U16 msgID = [04 08]	- AS_NAS_ESTABLISH_CNF
  U8 errCode = [01]	- SUCCESS

  U32 Length = [00 00 00 46] (70 octets)
  U8* NasMsg = [27 ab ab ab ab 00 07 42 01 e0 06 24 02 f8 01 00]
  	       [01 00 26 52 01 c1 05 03 48 87 40 78 0e 77 77 77]
	       [2e 65 75 72 65 63 6f 6d 2e 66 72 0d 03 c0 a8 02]
	       [3c 02 21 70 ff c0 a8 02 3c 50 0b f6 02 f8 01 01]
	       [02 0f 00 00 00 01]

  U8:4 Security header type = [2]	- Integrity protected and cyphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- 0

  NAS message = [07 42 01 e0 06 24 02 f8 01 00 01 00 26 52 01 c1]
		[05 03 48 87 40 78 0e 77 77 77 2e 65 75 72 65 63]
		[6f 6d 2e 66 72 0d 03 c0 a8 02 3c 02 21 70 ff c0]
		[a8 02 3c 50 0b f6 02 f8 01 01 02 0f 00 00 00 01]
  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [42]	- Attach Accept

  U8:4 Spare = [0]
  U8:4 EPS attach result = [1]		- EPS
  U8:3 T3412 unit = 111			- Deactivated
  U8:5 T3412 value = 00000

  TAI list = [06 24 02 f8 01 00 01]
  Length = [06]
  U8:1 spare = 0
  U8:2 Type of list = 01		- list of TACs belonging to one PLMN,
  					  with consecutive TAC values
  U8:5 Number of elements = 0 0100	- 4 consecutive TACs
  TAI = [02 f8 01 00 01]		- PLMN = 20810, TAC = 00 01

  ESM message container = [00 26 52 01 c1 05 03 48 87 40 78 0e 77 77 77 2e]
  			  [65 75 72 65 63 6f 6d 2e 66 72 0d 03 c0 a8 02 3c]
			  [02 21 70 ff c0 a8 02 3c]
  U16 Length = [00 26] (38 octets)
  U8:4 EPS bearer identity = [5]	- ebi = 5
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [01]
  U8   ESM message identifier = [c1]	- Activate Default EPS Bearer Context Request

  EPS Qos = [05 03 48 87 40 78]
  Length = [05]	- 5 octets
  QCI = [03]	- 3
  Maximum bit rate for uplink = [48]	  - 128K
  Maximum bit rate for downlink = [87]	  - 1024K
  Guaranteed bit rate for uplink = [40]	  - 64K
  Guaranteed bit rate for downlink = [78] - 512K

  Access point name  = [0e 77 77 77 2e 65 75 72 65 63 6f 6d 2e 66 72]
  Length = [0e]	- 14 octets
  APN = "www.eurecom.fr"

  PDN address = [0d 03 c0 a8 02 3c 02 21 70 ff c0 a8 02 3c]
  Length = [0d]	- 13 octets
  U8:5 Spare = 00000	- 0
  U8:3 Pdn type = 011	- IPv4v6
  PDN address information = [c0 a8 02 3c 02 21 70 ff c0 a8 02 3c]
*/

/*
        06 01 00 00 00 00 0f 00 00 00 01 00 00 00 0d 00 
        00 00 27 ab ab ab ab 00 07 43 00 03 52 00 c2 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [0f]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 0d] (13 octets)
  U8* NasMsg = [27 ab ab ab ab 00 07 43 00 03 52 00 c2]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [07 43 00 03 52 00 c2]
  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [43]	- Attach Complete

  ESM message container = [00 03 52 00 c2]
  Length = [00 03] (3 bytes)
  ESM message = [52 00 c2]
  U8:4 EPS bearer identity = [5]	- ebi = 5
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [00]	- unassigned
  U8   ESM message identifier = [c2]	- Activate Default EPS Bearer Context Accept
*/

/*
        07 04 00 00 00 00 03 00 00 00 07 55 10 
*/
/*
  U16 msgID = [07 04]	- AS_DL_INFO_TRANSFER_IND
  U32 UEid = [00 00 00 00]

  U32 Length = [03 00 00 00] (3 octets)
  U8* NasMsg = [07 55 10]

  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [55]	- Identity Request

  U8:4 Identity type = [1]	- IMSI
  U8:4 spare = [0]
*/

/*
        06 01 00 00 00 00 0f 00 00 00 01 00 00 00 0b 00 
        00 00 07 56 08 21 80 01 0f 00 10 32 f4 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [0f]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 0b] (11 octets)
  U8* NasMsg = [07 56 08 21 80 01 0f 00 10 32 f4]
  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [56]	- Identity Response

  Mobile identity = [08 21 80 01 0f 00 10 32 f4]
  Length = [08] - 8 octets
  U8:4 Identity digit 1 = [2]	 - 2
  U8:1 odd/even indicator = [0]	 - even number of identity digits
  U8:3 Type of identity = [001]	 - IMSI
  U8:4 Identity digit 3 = [8]	 - 8
  U8:4 Identity digit 2 = [0]	 - 0
  U8:4 Identity digit 5 = [0]	 - 0
  U8:4 Identity digit 4 = [1]	 - 1
  U8:4 Identity digit 7 = [0]	 - 0
  U8:4 Identity digit 6 = [f]	 - f
  U8:4 Identity digit 9 = [0]	 - 0
  U8:4 Identity digit 8 = [0]	 - 0
  U8:4 Identity digit 11 = [1]	 - 1
  U8:4 Identity digit 10 = [0]	 - 0
  U8:4 Identity digit 13 = [3]	 - 3
  U8:4 Identity digit 12 = [2]	 - 2
  U8:4 Identity digit 15 = [f]	 - f
  U8:4 Identity digit 16 = [4]	 - 4

IMSI = 20810f00001234f (2081000001234)
*/

/*
        07 04 00 00 00 00 24 00 00 00 07 52 00 00 00 00 
        00 00 00 00 00 00 00 00 00 01 02 03 04 10 00 00 
        00 00 00 00 80 05 04 03 02 00 00 00 00 00 
*/
/*
  U16 msgID = [07 04]	- AS_DL_INFO_TRANSFER_IND
  U32 UEid = [00 00 00 00]

  U32 Length = [24 00 00 00] (36 octets)
  U8* NasMsg = [07 52 00 00 00 00 00 00 00 00 00 00 00 00 00 01]
	       [02 03 04 10 00 00 00 00 00 00 80 05 04 03 02 00]
	       [00 00 00 00]

  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [52]	- Authentication Request

  U8:4 NAS key set identifier = [0]	- 000
  U8:4 spare = [0]
  RAND  = [00 00 00 00 00 00 00 00 00 00 00 00 01 02 03 04]
  AUTHN Length = [10]	- 16 octets
  AUTHN = [00 00 00 00 00 00 80 05 04 03 02 00 00 00 00 00]
*/

/*
        06 01 00 00 00 00 0f 00 00 00 01 00 00 00 13 00 
        00 00 07 53 10 67 70 3a 31 f2 2a 2d 51 00 00 00 
        00 00 00 00 00 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [0f]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 13] (19 octets)
  U8* NasMsg = [07 53 10 67 70 3a 31 f2 2a 2d 51 00 00 00 00 00 00 00 00]
  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [53]	- Authentication Response

  RES Length = [10]	- 16 octets
  RES = [67 70 3a 31 f2 2a 2d 51 00 00 00 00 00 00 00 00]
*/

/*
        07 04 00 00 00 00 10 00 00 00 37 ab ab ab ab 00 
        07 5d 00 00 05 80 80 00 00 00 
*/
/*
  U16 msgID = [07 04]	- AS_DL_INFO_TRANSFER_IND
  U32 UEid = [00 00 00 00]

  U32 Length = [10 00 00 00] (16 octets)
  U8* NasMsg = [37 ab ab ab ab 00 07 5d 00 00 05 80 80 00 00 00]

  U8:4 Security header type = [3]	- Integrity protected with
					  new EPS security context
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- 0

  NAS message = [07 5d 00 00 05 80 80 00 00 00]
  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [5d]	- Security Mode Command

  U8   Selected NAS security algorithms = [00]
  U8:4 Spare half octet = [0]
  U8:4 NAS key set identifier = [0]
  Replayed UE security capabilities = [05 80 80 00 00 00]
	U8 EEA = [80]	- EEA0
	U8 EIA = [80]	- EIA0
	U8 UEA = [00]
	U8 UIA = [00]
	U8 GEA = [00]
*/

/*
        06 01 00 00 00 00 0f 00 00 00 01 00 00 00 08 00 
        00 00 47 ab ab ab ab 00 07 5e 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [0f]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 08] (8 octets)
  U8* NasMsg = [47 ab ab ab ab 00 07 5e]

  U8:4 Security header type = [4]	- Integrity protected and ciphered with
					  new EPS security context
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [07 5e]
  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [5e]	- Security Mode Complete
*/

/*
        06 01 00 00 00 00 0f 00 00 00 01 00 00 00 09 00 
        00 00 27 ab ab ab ab 00 07 5f 18 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [0f]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 09] (9 octets)
  U8* NasMsg = [27 ab ab ab ab 00 07 5f 18]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [07 5f 18]
  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [5f]	- Security Mode Reject

  U8   EMM cause code = [18]		- EMM_CAUSE_SECURITY_MODE_REJECTED
*/

/*
        07 01 00 00 00 00 00 00 00 00 00 00 00 00 04 00 
        00 00 52 00 e8 6f 
*/
/*
  U16 msgID = [07 01]	- AS_DL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [00]		- !!!
	U32 m_tmsi = [00 00 00 00]	- !!!

  U32 Length = [00 00 00 04] (4 octets)
  NAS message = [52 00 e8 6f]

  U8:4 EPS bearer identity = [5]	- ebi = 5
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [00]	- unassigned
  U8   ESM message identifier = [e8]	- ESM Status

  U8   ESM cause code = [6f]		- #111 PROTOCOL_ERROR
*/

/*
        06 01 00 00 00 00 12 00 00 00 01 00 00 00 0a 00 
        00 00 27 ab ab ab ab 00 02 01 e8 2b 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [12]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 0a] (10 octets)
  U8* NasMsg = [27 ab ab ab ab 00 02 01 e8 2b]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [02 01 e8 2b]
  U8:4 EPS bearer identity = [0]	- Not assigned
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [01]
  U8   ESM message identifier = [e8]	- ESM Status

  U8   ESM cause code = [2b]		- #43 INVALID_EPS_BEARER_IDENTITY
*/

/*
        06 01 00 00 00 00 12 00 00 00 01 00 00 00 0a 00 
        00 00 27 ab ab ab ab 00 02 03 d2 06 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [12]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 0a] (10 octets)
  U8* NasMsg = [27 ab ab ab ab 00 02 03 d2 06]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [02 03 d2 06]
  U8:4 EPS bearer identity = [0]	- Not assigned
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [03]
  U8   ESM message identifier = [d2]	- PDN Disconnect Request

  U8:4 Spare half octet = [0]
  U8:4 Linked EPS bearer identity = [6]	- ebi = 6
*/

/*
        06 08 00 00 00 00 01 00 00 00 
*/
/*
  U16 msgID = [06 08]	- AS_UL_INFO_TRANSFER_CNF
  U32 UEid = [00 00 00 00]
  U8 errCode = [01]	- SUCCESS
*/

/*
        06 01 00 00 00 00 12 00 00 00 01 00 00 00 09 00 
        00 00 27 ab ab ab ab 00 82 00 ce 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [12]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 09] (9 octets)
  U8* NasMsg = [27 ab ab ab ab 00 82 00 ce]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [82 00 ce]
  U8:4 EPS bearer identity = [8]	- 8
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [00]
  U8   ESM message identifier = [ce]	- Deactivate EPS Bearer Context Accept
*/

/*
        07 01 01 00 00 00 00 00 00 00 00 00 00 00 0a 00 
        00 00 27 ab ab ab ab 00 62 02 cd 24 
*/
/*
  U16 msgID = [07 01]	- AS_DL_INFO_TRANSFER_REQ
  U32 UEid = [01 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [00]
	U32 m_tmsi = [00 00 00 00]

  U32 Length = [00 00 00 0a] (10 octets)
  NAS message = [27 ab ab ab ab 00 62 02 cd 24]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [62 02 cd 24]
  U8:4 EPS bearer identity = [6]	- ebi = 6
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [02]
  U8   ESM message identifier = [cd]	- Deactivate EPS Bearer Context Request

  U8   ESM cause code = [24]		- #36 REGULAR_DEACTIVATION
*/

/*
        04 08 01 00 00 00 00 00 00 00 
*/
/*
  U16 msgID = [04 08]	- AS_NAS_ESTABLISH_CNF
  U8 errCode = [01]	- SUCCESS
  U32 Length = [00 00 00 00] (0 octets)
*/


/*
        07 01 01 00 00 00 00 00 00 00 00 00 00 00 0e 00 
        00 00 27 ab ab ab ab 00 72 00 c5 06 01 02 01 00 
*/
/*
  U16 msgID = [07 01]	- AS_DL_INFO_TRANSFER_REQ
  U32 UEid = [01 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [00]
	U32 m_tmsi = [00 00 00 00]

  U32 Length = [00 00 00 0e] (14 octets)
  NAS message = [27 ab ab ab ab 00 72 00 c5 06 01 02 01 00]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [72 00 c5 06 00 00 00 00]
  U8:4 EPS bearer identity = [7]	- ebi = 7
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity	- Unassigned
  U8   ESM message identifier = [c5]	- Activate dedicated EPS Bearer Context Request

  U8:4 Spare half octet = [0]
  U8:4 Linked EPS bearer identity = [6]
  U8 QoS length = [01]
  U8 QCI = [02]
  U8 TFT length = [01]
  U8 TFT = [00]
*/

/*
        07 04 00 00 00 00 36 00 00 00 27 ab ab ab ab 00 
        72 00 c5 06 01 02 29 22 11 02 11 10 c0 a8 0c 01 
        ff ff ff 00 30 11 40 27 11 50 2e e1 22 03 11 10 
        c0 a8 0c 01 ff ff ff 00 30 11 40 27 12 50 2e e2 
*/
/*
  U16 msgID = [07 04]	- AS_DL_INFO_TRANSFER_IND
  U32 UEid = [00 00 00 00]

  U32 Length = [36 00 00 00] (54 octets)
  U8* NasMsg = [27 ab ab ab ab 00 72 00 c5 06 01 02 29 22 11 02]
  	       [11 10 c0 a8 0c 01 ff ff ff 00 30 11 40 27 11 50]
	       [2e e1 22 03 11 10 c0 a8 0c 01 ff ff ff 00 30 11]
	       [40 27 12 50 2e e2]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- 0

  NAS message = [72 00 c5 06 01 02 29 22 11 02 11 10 c0 a8 0c 01]
  		[ff ff ff 00 30 11 40 27 11 50 2e e1 22 03 11 10]
		[c0 a8 0c 01 ff ff ff 00 30 11 40 27 12 50 2e e2]
  U8:4 EPS bearer identity = [7]	- ebi = 7
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity	- Unassigned
  U8   ESM message identifier = [c5]	- Activate dedicated EPS Bearer Context Request

  U8:4 Spare half octet = [0]
  U8:4 Linked EPS bearer identity = [6]
  U8 QoS length = [01]	- 1 octet
  U8 QCI = [02]
  U8 TFT length = [29]	- 41 octets
  U8 TFT = [22 11 02 11 10 c0 a8 0c 01 ff ff ff 00 30 11 40]
  	   [27 11 50 2e e1 22 03 11 10 c0 a8 0c 01 ff ff ff]
	   [00 30 11 40 27 12 50 2e e2]
*/

/*
        06 01 00 00 00 00 12 00 00 00 01 00 00 00 0a 00 
        00 00 27 ab ab ab ab 00 72 00 c7 2d 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [12]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 0a] (10 octets)
  U8* NasMsg = [27 ab ab ab ab 00 72 00 c7 2d]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [72 00 c7 2d]
  U8:4 EPS bearer identity = [7]	- 7
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [00]
  U8   ESM message identifier = [c7]	- Activate Dedicated EPS Bearer Context
  					  Reject

  U8   ESM cause code = [2d]		- SYNTACTICAL_ERROR_IN_PACKET_FILTER
*/

/*
        06 01 00 00 00 00 12 00 00 00 01 00 00 00 09 00 
        00 00 27 ab ab ab ab 00 72 00 c6 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [12]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 09] (9 octets)
  U8* NasMsg = [27 ab ab ab ab 00 72 00 c6]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [72 00 c6]
  U8:4 EPS bearer identity = [7]	- 7
  U8:4 Protocol discriminator = [2]	- ESM message
  U8   Procedure Transaction Identity = [00]
  U8   ESM message identifier = [c6]	- Activate Dedicated EPS Bearer Context
  					  Accept
*/

/*
        06 01 00 00 00 00 12 00 00 00 01 00 00 00 15 00 
        00 00 27 ab ab ab ab 00 07 45 01 0b f6 02 f8 01 
        01 02 12 00 00 00 01 
*/
/*
  U16 msgID = [06 01]	- AS_UL_INFO_TRANSFER_REQ
  U32 UEid = [00 00 00 00]
  as_stmsi_t s_tmsi
	U8 MMEcode = [12]
	U32 m_tmsi = [00 00 00 01]

  U32 Length = [00 00 00 15] (21 octets)
  U8* NasMsg = [27 ab ab ab ab 00 07 45 01 0b f6 02 f8 01 01 02]
	       [12 00 00 00 01]

  U8:4 Security header type = [2]	- Integrity protected and ciphered
  U8:4 Protocol discriminator = [7]	- EMM message
  U32  Message authentication code = [ab ab ab ab]
  U8   Sequence number = [00]		- Uplink counter value

  NAS message = [07 45 01 0b f6 02 f8 01 01 02 12 00 00 00 01]
  U8:4 Security header type = [0]	- Not protected
  U8:4 Protocol discriminator = [7]	- EMM message
  U8   EMM message identifier = [45]	- Detach Request

  U8:4 NAS key set identifier = [0]	- Native 0
  U8:4 Detach type = [1]		- EPS Detach

  Mobile identity = [0b f6 02 f8 01 01 02 12 00 00 00 01]
  Length = [0b] - 11 octets
	U8:4 = 1111 = [f]
	U8:1 odd/even indicator = [0]	 - even number of identity digits
	U8:3 Type of identity = [110]	 - GUTI
	plmn = [02 f8 01]		 - 20810
	U16  mmegroupid = [01 02]
	U8   mmecode = [12]
	U32  mtmsi = [00 00 00 01]
*/
