MME2 changes - Propped commits from openmme/paging branch. Added scripts
for code gen
Change-Id: Ie55032217232214ac8544ca76ea34335205329e4
diff --git a/src/s1ap/handlers/attach_icsreq.c b/src/s1ap/handlers/attach_icsreq.c
new file mode 100644
index 0000000..23c00a5
--- /dev/null
+++ b/src/s1ap/handlers/attach_icsreq.c
@@ -0,0 +1,744 @@
+/*
+ * Copyright (c) 2003-2018, Great Software Laboratory Pvt. Ltd.
+ * Copyright (c) 2017 Intel Corporation
+ * Copyright (c) 2019, Infosys Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdint.h>
+
+#include "log.h"
+#include "err_codes.h"
+#include "message_queues.h"
+#include "ipc_api.h"
+#include "s1ap_config.h"
+#include "main.h"
+#include "s1ap.h"
+#include "msgType.h"
+
+extern s1ap_config g_s1ap_cfg;
+
+static void
+get_negotiated_qos_value(struct esm_qos *qos)
+{
+ qos->delay_class = 1;
+ qos->reliability_class = 3;
+ qos->peak_throughput = 5;
+ qos->precedence_class = 2;
+ qos->mean_throughput = 31;
+ qos->traffic_class = 3;
+ qos->delivery_order = 2;
+ qos->delivery_err_sdu = 3;
+ qos->max_sdu_size = 140;
+ qos->mbr_ul = 254;
+ qos->mbr_dl = 86;
+ qos->residual_ber = 7;
+ qos->sdu_err_ratio = 6;
+ qos->transfer_delay = 18;
+ qos->trffic_prio = 3;
+ qos->gbr_ul = 86;
+ qos->gbr_dl = 86;
+ qos->sig_ind = 0;
+ qos->src_stat_desc = 0;
+ qos->mbr_dl_ext = 108;
+ qos->gbr_dl_ext = 0;
+ qos->mbr_ul_ext = 108;
+ qos->gbr_ul_ext = 0;
+
+ return;
+}
+
+/**
+* Get ProtocolIE value for ICS Request sent by mme-app
+*/
+static int
+get_icsreq_protoie_value(struct proto_IE *value, struct init_ctx_req_Q_msg *g_icsReqInfo)
+{
+ uint8_t ieCnt = 0;
+ uint8_t nasIeCnt = 0;
+
+ value->no_of_IEs = ICS_REQ_NO_OF_IES;
+
+ value->data = (proto_IEs *) malloc(ICS_REQ_NO_OF_IES *
+ sizeof(proto_IEs));
+
+
+ value->data[ieCnt].val.mme_ue_s1ap_id = g_icsReqInfo->ue_idx;
+ ieCnt++;
+
+ value->data[ieCnt].val.enb_ue_s1ap_id = g_icsReqInfo->enb_s1ap_ue_id;
+ ieCnt++;
+
+ log_msg(LOG_INFO, "mme_ue_s1ap_id %d and enb_ue_s1ap_id %d\n",
+ g_icsReqInfo->ue_idx, g_icsReqInfo->enb_s1ap_ue_id);
+
+ value->data[ieCnt].val.ue_aggrt_max_bit_rate.uEaggregateMaxBitRateDL =
+ g_icsReqInfo->exg_max_dl_bitrate;
+ value->data[ieCnt].val.ue_aggrt_max_bit_rate.uEaggregateMaxBitRateUL =
+ g_icsReqInfo->exg_max_ul_bitrate;
+ ieCnt++;
+
+ /* E-RABToBeSetupItemCtxtSUReq start */
+ ERABSetup *e_rab = &(value->data[ieCnt].val.E_RABToBeSetupItemCtxtSUReq);
+ /* TODO: Remove hardcoded values. */
+ e_rab->e_RAB_ID = 1;
+ e_rab->e_RAB_QoS_Params.qci = 9;
+ e_rab->e_RAB_QoS_Params.arPrio.prioLevel = 15;
+ e_rab->e_RAB_QoS_Params.arPrio.preEmptionCapab = 1;
+ e_rab->e_RAB_QoS_Params.arPrio.preEmptionVulnebility = 1;
+
+ /*S1u information : transport layer addr and teid*/
+ e_rab->transportLayerAddress = htonl(g_icsReqInfo->gtp_teid.ip.ipv4.s_addr);
+ //e_rab->gtp_teid = htonl(g_icsReqInfo->gtp_teid.header.teid_gre);
+ {
+ char *dst = (char *)&(e_rab->gtp_teid);
+ char *src = (char *)&(g_icsReqInfo->gtp_teid.header.teid_gre);
+ memcpy(dst, src+3, 1);
+ memcpy(dst+1, src+2, 1);
+ memcpy(dst+2, src+1, 1);
+ memcpy(dst+3, src, 1);
+ }
+
+ /* NAS PDU values start */
+ e_rab->nas.header.security_header_type =
+ IntegrityProtectedCiphered;
+ e_rab->nas.header.proto_discriminator =
+ EPSMobilityManagementMessages;
+
+ /* placeholder for mac. mac value will be calculated later */
+ uint8_t mac[MAC_SIZE] = {0};
+ memcpy(e_rab->nas.header.mac, mac, MAC_SIZE);
+
+ e_rab->nas.header.seq_no = g_icsReqInfo->dl_seq_no;
+ e_rab->nas.header.message_type = AttachAccept;
+ /* TODO: Remove hardcoded value */
+ e_rab->nas.header.eps_bearer_identity = 0;
+ e_rab->nas.header.procedure_trans_identity = 1;
+
+ e_rab->nas.elements_len = ICS_REQ_NO_OF_NAS_IES;
+ e_rab->nas.elements = (nas_pdu_elements *)
+ malloc(ICS_REQ_NO_OF_NAS_IES * sizeof(nas_pdu_elements));
+
+ nas_pdu_elements *nasIEs = e_rab->nas.elements;
+ nasIEs[nasIeCnt].pduElement.attach_res = 2; /* EPS Only */
+ nasIeCnt++;
+
+ /* Refer : 24008. Section - 10.5.7.3. We want to disable TAU request coming from UE.
+ */
+//#define DISABLE_TAU 0
+#if DISABLE_TAU
+ nasIEs[nasIeCnt].pduElement.t3412 = 224;
+#else
+ nasIEs[nasIeCnt].pduElement.t3412 = 0x21; // per min
+#endif
+ nasIeCnt++;
+
+ nasIEs[nasIeCnt].pduElement.tailist.type = 1;
+ nasIEs[nasIeCnt].pduElement.tailist.num_of_elements = 0;
+
+ /* S1AP TAI mcc 123, mnc 456 : 214365 */
+ /* NAS GUTI mcc 123, mnc 456 : 216354 */
+ if ((g_icsReqInfo->tai.plmn_id.idx[1] & 0xF0) != 0xF0)
+ {
+ unsigned char x3 = g_icsReqInfo->tai.plmn_id.idx[2];
+ unsigned char x2 = g_icsReqInfo->tai.plmn_id.idx[1];
+ unsigned char x31 = x3 >> 4;
+ unsigned char x32 = x3 & 0xf;
+ unsigned char x21 = x2 >> 4;
+ unsigned char x22 = x2 & 0xf;
+ x3 = x21 | (x32 <<4);
+ x2 = (x31 << 4) | x22;
+ g_icsReqInfo->tai.plmn_id.idx[1] = x2;
+ g_icsReqInfo->tai.plmn_id.idx[2] = x3;
+ }
+
+ memcpy(&(nasIEs[nasIeCnt].pduElement.tailist.partial_list[0]),
+ &(g_icsReqInfo->tai), sizeof(g_icsReqInfo->tai));
+ nasIeCnt++;
+
+ nasIEs[nasIeCnt].pduElement.esm_msg.eps_bearer_id = 5; /* TODO: revisit */
+ nasIEs[nasIeCnt].pduElement.esm_msg.proto_discriminator = 2;
+ memcpy(&(nasIEs[nasIeCnt].pduElement.esm_msg.procedure_trans_identity), &(g_icsReqInfo->pti), 1);
+ nasIEs[nasIeCnt].pduElement.esm_msg.session_management_msgs =
+ ESM_MSG_ACTV_DEF_BEAR__CTX_REQ;
+ nasIEs[nasIeCnt].pduElement.esm_msg.eps_qos = 9;
+
+ /* TODO: Remove hardcoded value */
+ /*char apnname[4] = "apn1";
+ memcpy(&(nasIEs[nasIeCnt].esm_msg.apn.val), apnname, 4);
+ nasIEs[nasIeCnt].esm_msg.apn.len = 4;
+ */
+ nasIEs[nasIeCnt].pduElement.esm_msg.apn.len = g_icsReqInfo->apn.len;
+ memcpy(nasIEs[nasIeCnt].pduElement.esm_msg.apn.val,
+ g_icsReqInfo->apn.val, g_icsReqInfo->apn.len);
+
+
+ nasIEs[nasIeCnt].pduElement.esm_msg.pdn_addr.type = 1;
+ /*TODO : endian issue */
+ nasIEs[nasIeCnt].pduElement.esm_msg.pdn_addr.ipv4 = htonl(g_icsReqInfo->pdn_addr.ip_type.ipv4.s_addr);
+ nasIEs[nasIeCnt].pduElement.esm_msg.linked_ti.flag = 0;
+ nasIEs[nasIeCnt].pduElement.esm_msg.linked_ti.val = 0;
+ get_negotiated_qos_value(&nasIEs[nasIeCnt].pduElement.esm_msg.negotiated_qos);
+ nasIeCnt++;
+
+ /* Send the allocated GUTI to UE */
+ nasIEs[nasIeCnt].pduElement.mi_guti.odd_even_indication = 0;
+ nasIEs[nasIeCnt].pduElement.mi_guti.id_type = 6;
+
+ memcpy(&(nasIEs[nasIeCnt].pduElement.mi_guti.plmn_id),
+ &(g_icsReqInfo->tai.plmn_id), sizeof(struct PLMN));
+ nasIEs[nasIeCnt].pduElement.mi_guti.mme_grp_id = htons(g_s1ap_cfg.mme_group_id);
+ nasIEs[nasIeCnt].pduElement.mi_guti.mme_code = g_s1ap_cfg.mme_code;
+ /* TODO : Revisit, temp fix for handling detach request retransmit.
+ * M-TMSI should come from MME */
+ nasIEs[nasIeCnt].pduElement.mi_guti.m_TMSI = htonl(g_icsReqInfo->m_tmsi);
+ nasIeCnt++;
+
+ ieCnt++;
+ /* NAS PDU values end */
+ /* E-RABToBeSetupItemCtxtSUReq values end */
+
+
+ /* TODO Get value of ue_sec_capabilities
+ *
+ * value->data[ieCnt].ue_sec_capabilities = ??
+ *
+ * */
+
+
+ ieCnt++;
+
+ /* TODO: remove hard coded value */
+ /*char sec_key[32] = "abcdefghijklmnopqrstuvwxyz012345";
+ memcpy(value->data[ieCnt].sec_key, sec_key,
+ SECURITY_KEY_SIZE);
+ */
+
+ memcpy(value->data[ieCnt].val.sec_key, g_icsReqInfo->sec_key,
+ SECURITY_KEY_SIZE);
+
+ ieCnt++;
+
+ return SUCCESS;
+}
+
+
+
+/**
+* Stage specific message processing.
+*/
+static int
+icsreq_processing(struct init_ctx_req_Q_msg *g_icsReqInfo)
+{
+
+ Buffer g_ics_buffer;
+ Buffer g_s1ap_buffer;
+ Buffer g_rab1_buffer;
+ Buffer g_rab2_buffer;
+ Buffer g_nas_buffer;
+
+ unsigned char tmpStr[4];
+ struct s1ap_PDU s1apPDU;
+ uint16_t protocolIe_Id;
+ uint8_t protocolIe_criticality;
+ uint8_t initiating_msg = 0;
+ uint8_t datalen = 0;
+ //uint8_t s1ap_len_pos;
+ //uint8_t erab_len_pos;
+ //uint8_t erab_item_len_pos;
+ //uint8_t nas_len_pos;
+ uint16_t esm_len_pos;
+ uint8_t u8value = 0;
+ uint8_t mac_data_pos;
+
+ s1apPDU.procedurecode = id_InitialContextSetup;
+ s1apPDU.criticality = CRITICALITY_REJECT;
+
+ get_icsreq_protoie_value(&s1apPDU.value, g_icsReqInfo);
+
+ g_ics_buffer.pos = 0;
+
+ buffer_copy(&g_ics_buffer, &initiating_msg,
+ sizeof(initiating_msg));
+
+ buffer_copy(&g_ics_buffer, &s1apPDU.procedurecode,
+ sizeof(s1apPDU.procedurecode));
+
+ buffer_copy(&g_ics_buffer, &s1apPDU.criticality,
+ sizeof(s1apPDU.criticality));
+
+ /* TODO: revisit , why 128 (0x80) required */
+#if 0
+ s1ap_len_pos = g_ics_buffer.pos;
+ u8value = 128;
+ buffer_copy(&g_ics_buffer, &u8value, sizeof(u8value));
+
+
+
+
+ u8value = 0;
+ buffer_copy(&g_ics_buffer, &u8value, sizeof(u8value));
+#endif
+
+ g_s1ap_buffer.pos = 0;
+
+ /* TODO remove hardcoded values */
+ uint8_t chProtoIENo[3] = {0,0,6};
+ buffer_copy(&g_s1ap_buffer, chProtoIENo, 3);
+
+ /* id-MME-UE-S1AP-ID */
+ protocolIe_Id = id_MME_UE_S1AP_ID;
+ copyU16(tmpStr, protocolIe_Id);
+ buffer_copy(&g_s1ap_buffer, tmpStr, sizeof(protocolIe_Id));
+ protocolIe_criticality = CRITICALITY_REJECT;
+ buffer_copy(&g_s1ap_buffer, &protocolIe_criticality,
+ sizeof(protocolIe_criticality));
+ datalen = 2;
+ /* TODO need to add proper handling*/
+ unsigned char mme_ue_id[3];
+ datalen = copyU16(mme_ue_id, s1apPDU.value.data[0].val.mme_ue_s1ap_id);
+ buffer_copy(&g_s1ap_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_s1ap_buffer, mme_ue_id, datalen);
+
+ /* id-eNB-UE-S1AP-ID */
+ protocolIe_Id = id_eNB_UE_S1AP_ID;
+ copyU16(tmpStr, protocolIe_Id);
+ buffer_copy(&g_s1ap_buffer, tmpStr, sizeof(protocolIe_Id));
+ buffer_copy(&g_s1ap_buffer, &protocolIe_criticality,
+ sizeof(protocolIe_criticality));
+ /* TODO needs proper handling*/
+ unsigned char enb_ue_id[3];
+ datalen = copyU16(enb_ue_id, s1apPDU.value.data[1].val.enb_ue_s1ap_id);
+ buffer_copy(&g_s1ap_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_s1ap_buffer, enb_ue_id, datalen);
+
+ protocolIe_Id = id_uEaggregatedMaximumBitrate;
+ copyU16(tmpStr, protocolIe_Id);
+ buffer_copy(&g_s1ap_buffer, tmpStr, sizeof(protocolIe_Id));
+ buffer_copy(&g_s1ap_buffer, &protocolIe_criticality,
+ sizeof(protocolIe_criticality));
+ datalen = 10;
+
+ uint8_t maximum_bit_rate_dl = 0x18;
+ uint8_t maximum_bit_rate_ul = 0x60;
+
+ buffer_copy(&g_s1ap_buffer, &datalen, sizeof(datalen));
+
+ buffer_copy(&g_s1ap_buffer, &maximum_bit_rate_dl, sizeof(maximum_bit_rate_dl));
+
+ uint32_t temp_bitrate = htonl(g_icsReqInfo->exg_max_dl_bitrate);
+ memset(tmpStr, 0, sizeof(tmpStr));
+ memcpy(tmpStr, &temp_bitrate, sizeof(temp_bitrate));
+
+ buffer_copy(&g_s1ap_buffer, tmpStr,
+ sizeof(tmpStr));
+
+ temp_bitrate = 0;
+ temp_bitrate = htonl(g_icsReqInfo->exg_max_ul_bitrate);
+ memset(tmpStr, 0, sizeof(tmpStr));
+ memcpy(tmpStr, &temp_bitrate, sizeof(temp_bitrate));
+
+ buffer_copy(&g_s1ap_buffer, &maximum_bit_rate_ul,
+ sizeof(maximum_bit_rate_ul));
+ buffer_copy(&g_s1ap_buffer, tmpStr,
+ sizeof(tmpStr));
+
+
+ /* id-E-RABToBeSetupListCtxtSUReq */
+ ERABSetup *erab = &(s1apPDU.value.data[3].val.E_RABToBeSetupItemCtxtSUReq);
+ protocolIe_Id = id_ERABToBeSetupListCtxtSUReq;
+ copyU16(tmpStr, protocolIe_Id);
+ buffer_copy(&g_s1ap_buffer, tmpStr, sizeof(protocolIe_Id));
+ buffer_copy(&g_s1ap_buffer, &protocolIe_criticality,
+ sizeof(protocolIe_criticality));
+
+ /* Lets put this in new buffer */
+ /*rab_len_1 */
+#if 0
+ erab_len_pos = g_s1ap_buffer.pos;
+ datalen = 0;
+ buffer_copy(&g_ics_buffer, &datalen, sizeof(datalen));
+#endif
+ g_rab1_buffer.pos = 0;
+
+ buffer_copy(&g_rab1_buffer, &initiating_msg,
+ sizeof(initiating_msg));
+
+ protocolIe_Id = id_ERABToBeSetupItemCtxtSUReq;
+ copyU16(tmpStr, protocolIe_Id);
+ buffer_copy(&g_rab1_buffer, tmpStr, sizeof(protocolIe_Id));
+ buffer_copy(&g_rab1_buffer, &protocolIe_criticality,
+ sizeof(protocolIe_criticality));
+
+ /*rab_len_2 */
+#if 0
+ erab_item_len_pos = g_rab1_buffer.pos;
+ datalen = 0;
+ buffer_copy(&g_ics_buffer, &datalen, sizeof(datalen));
+#endif
+
+ /*
+ buffer_copy(&g_ics_buffer, &(erab->e_RAB_ID),
+ sizeof(erab->e_RAB_ID));
+ */
+ g_rab2_buffer.pos = 0;
+ /* TODO : Remove hardcoded value of erab id */
+ u8value =69; // 0x45 //1;
+ buffer_copy(&g_rab2_buffer, &u8value, sizeof(u8value));
+ /* TODO: Need to revisit why add 00 before qci value? */
+ u8value = 0;
+ buffer_copy(&g_rab2_buffer, &u8value, sizeof(u8value));
+ buffer_copy(&g_rab2_buffer, &(erab->e_RAB_QoS_Params.qci),
+ sizeof(erab->e_RAB_QoS_Params.qci));
+ buffer_copy(&g_rab2_buffer, &(erab->e_RAB_QoS_Params.arPrio),
+ sizeof(erab->e_RAB_QoS_Params.arPrio));
+
+ /* TODO: Revisit why we need to add 0f 80 before transport add? */
+
+ u8value = 15;
+ buffer_copy(&g_rab2_buffer, &u8value, sizeof(u8value));
+ u8value = 128;
+ buffer_copy(&g_rab2_buffer, &u8value, sizeof(u8value));
+
+ buffer_copy(&g_rab2_buffer, &(erab->transportLayerAddress),
+ sizeof(erab->transportLayerAddress));
+
+ buffer_copy(&g_rab2_buffer, &(erab->gtp_teid),
+ sizeof(erab->gtp_teid));
+
+
+ /* E_RABToBeSetupListCtxtSUReq NAS PDU start */
+ // at the end we will do.... rab2_buf + <nas_len> + nas_buffer
+
+#if 0
+ nas_len_pos = g_rab2_buffer.pos;
+ datalen = 0;
+ buffer_copy(&g_ics_buffer, &datalen, sizeof(datalen));
+#endif
+
+ nas_pdu_header *nas_hdr = &(erab->nas.header);
+
+ g_nas_buffer.pos = 0;
+ /* security header and protocol discriminator */
+ u8value = (nas_hdr->security_header_type << 4 |
+ nas_hdr->proto_discriminator);
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+
+ /* mac */
+ /* placeholder for mac. mac value will be calculated later */
+ buffer_copy(&g_nas_buffer, nas_hdr->mac, MAC_SIZE);
+ mac_data_pos = g_nas_buffer.pos;
+
+ /* sequence number */
+ buffer_copy(&g_nas_buffer, &(nas_hdr->seq_no),
+ sizeof(nas_hdr->seq_no));
+
+ /* security header and protocol discriminator */
+ nas_hdr->security_header_type = Plain;
+ u8value = (nas_hdr->security_header_type << 4 |
+ nas_hdr->proto_discriminator);
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+
+ /* message type */
+ buffer_copy(&g_nas_buffer, &(nas_hdr->message_type),
+ sizeof(nas_hdr->message_type));
+
+ nas_pdu_elements *ies = erab->nas.elements;
+
+ /* eps attach result */
+ buffer_copy(&g_nas_buffer, &(ies[0].pduElement.attach_res), sizeof(u8value));
+
+ /* GPRS timer */
+#define DISABLE_TAU 1
+#if DISABLE_TAU
+ uint8_t temp_timer = 224; /*e0*/
+#else
+ uint8_t temp_timer = 0x21; /*per min */
+#endif
+ //buffer_copy(&g_ics_buffer, &(ies[1].t3412), sizeof(ies[1].t3412));
+ buffer_copy(&g_nas_buffer, &temp_timer, sizeof(temp_timer));
+
+ /* TAI list */
+ u8value = 6;
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+ u8value = 32; /* TODO: use value from tai list */
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+ buffer_copy(&g_nas_buffer, &(ies[2].pduElement.tailist.partial_list[0].plmn_id.idx), 3);
+ buffer_copy(&g_nas_buffer, &(ies[2].pduElement.tailist.partial_list[0].tac), 2);
+
+ esm_len_pos = g_nas_buffer.pos;
+
+ /* esm message container length */
+ char tmplen[2] = {0, 0};
+ buffer_copy(&g_nas_buffer, tmplen, 2);
+
+ /* ESM message container start */
+
+ /* esm message bearer id and protocol discriminator */
+ u8value = (ies[3].pduElement.esm_msg.eps_bearer_id << 4 |
+ ies[3].pduElement.esm_msg.proto_discriminator);
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+
+ /* esm message procedure identity */
+ buffer_copy(&g_nas_buffer, &(ies[3].pduElement.esm_msg.procedure_trans_identity),
+ sizeof(ies[3].pduElement.esm_msg.procedure_trans_identity));
+
+ /* esm message session management message */
+ buffer_copy(&g_nas_buffer, &(ies[3].pduElement.esm_msg.session_management_msgs),
+ sizeof(ies[3].pduElement.esm_msg.session_management_msgs));
+
+ /* eps qos */
+ datalen = 1;
+ buffer_copy(&g_nas_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_nas_buffer, &(ies[3].pduElement.esm_msg.eps_qos),
+ sizeof(ies[3].pduElement.esm_msg.eps_qos));
+
+ /* apn */
+ char apn_name[25]={};
+ strncpy(apn_name, (char *)ies[3].pduElement.esm_msg.apn.val,
+ ies[3].pduElement.esm_msg.apn.len);
+ datalen = ies[3].pduElement.esm_msg.apn.len;
+ buffer_copy(&g_nas_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_nas_buffer, (char *)ies[3].pduElement.esm_msg.apn.val, datalen);
+
+ /* pdn address */
+ //datalen = sizeof(ies[3].esm_msg.pdn_addr);
+ datalen = 5; //sizeof(ies[3].esm_msg.pdn_addr);
+ buffer_copy(&g_nas_buffer, &datalen, sizeof(datalen));
+ u8value = 1;
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+ //buffer_copy(&g_ics_buffer, &(ies[3].esm_msg.pdn_addr.pdn_type), 1);
+ buffer_copy(&g_nas_buffer, &(ies[3].pduElement.esm_msg.pdn_addr.ipv4), datalen-1);
+
+ /* linked ti */
+ u8value = 0x5d; /* element id TODO: define macro or enum */
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+ datalen = 1;//sizeof(ies[3].esm_msg.linked_ti);
+ buffer_copy(&g_nas_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_nas_buffer, &(ies[3].pduElement.esm_msg.linked_ti), datalen);
+
+ /* negotiated qos */
+ u8value = 0x30; /* element id TODO: define macro or enum */
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+ datalen = 16;//sizeof(ies[3].esm_msg.negotiated_qos);
+ buffer_copy(&g_nas_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_nas_buffer, &(ies[3].pduElement.esm_msg.negotiated_qos), datalen);
+
+ /* apn ambr */
+#if 0
+ u8value = 0x5e; /* element id TODO: define macro or enum */
+ buffer_copy(&g_ics_buffer, &u8value, sizeof(u8value));
+ datalen = sizeof(ies[3].esm_msg.apn_ambr);
+ buffer_copy(&g_ics_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_ics_buffer, &(ies[3].esm_msg.apn_ambr), datalen);
+#endif
+ /* TODO: remove hardcoded values of apn ambr */
+ char apn_ambr[8] = {0x5e, 0x06, 0x80, 0x00, 0x04, 0x05, 0x06, 0x07};
+ buffer_copy(&g_nas_buffer, apn_ambr, 8);
+
+#if 1
+ char pco_options[29] = {0x27, 0x1B, 0x80, 0x80, 0x21, 0x10, 0x03, 0x00, 0x00,0x10, 0x81, 0x06, 0x08,0x08,0x08, 0x08,0x83,0x06,0x08,0x08,0x08,0x04,0x00,0x0d, 0x04,0x08,0x08,0x08,0x08};
+ buffer_copy(&g_nas_buffer, &pco_options[0], 29);
+#endif
+
+ /* ESM message container end */
+
+ /* Copy esm container length to esm container length field */
+ uint16_t esm_datalen = g_nas_buffer.pos - esm_len_pos - 2;
+ unsigned char esm_len[2];
+ copyU16(esm_len, esm_datalen);
+ /* memcpy(&g_ics_buffer.buf[esm_len_pos], tmplen, sizeof(esm_datalen)); */
+ /*TODO: needs proper handling */
+ g_nas_buffer.buf[esm_len_pos] = esm_len[0];
+ g_nas_buffer.buf[esm_len_pos + 1] = esm_len[1];
+
+ /* EPS mobile identity GUTI */
+#if 0
+ u8value = 0x50; /* element id TODO: define macro or enum */
+ buffer_copy(&g_ics_buffer, &u8value, sizeof(u8value));
+ datalen = sizeof(ies[4].mi_guti);
+ buffer_copy(&g_ics_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_ics_buffer, &(ies[4].mi_guti), datalen);
+#endif
+
+ u8value = 0x50; /* element id TODO: define macro or enum */
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+ datalen = 11;
+ buffer_copy(&g_nas_buffer, &datalen, sizeof(datalen));
+
+ u8value = 246; /* TODO: remove hard coding */
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+ buffer_copy(&g_nas_buffer, &(ies[4].pduElement.mi_guti.plmn_id.idx), 3);
+ buffer_copy(&g_nas_buffer, &(ies[4].pduElement.mi_guti.mme_grp_id),
+ sizeof(ies[4].pduElement.mi_guti.mme_grp_id));
+ buffer_copy(&g_nas_buffer, &(ies[4].pduElement.mi_guti.mme_code),
+ sizeof(ies[4].pduElement.mi_guti.mme_code));
+ buffer_copy(&g_nas_buffer, &(ies[4].pduElement.mi_guti.m_TMSI),
+ sizeof(ies[4].pduElement.mi_guti.m_TMSI));
+
+#if 0
+ {
+ // sending mobile identity to UE
+ /*TODO : Experiment */
+ u8value = 0x23; /* element id TODO: define macro or enum */
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+ datalen = 0x05;
+ buffer_copy(&g_nas_buffer, &datalen, sizeof(datalen));
+ u8value = 0xf4; //
+ buffer_copy(&g_nas_buffer, &u8value, sizeof(u8value));
+ buffer_copy(&g_nas_buffer, &(ies[4].pduElement.mi_guti.m_TMSI),
+ sizeof(ies[4].pduElement.mi_guti.m_TMSI));
+ }
+#endif
+ /* E_RABToBeSetupListCtxtSUReq NAS PDU end */
+
+ /* Calculate mac */
+ uint8_t direction = 1;
+ uint8_t bearer = 0;
+
+ calculate_mac(g_icsReqInfo->int_key, nas_hdr->seq_no,
+ direction, bearer, &g_nas_buffer.buf[mac_data_pos],
+ g_nas_buffer.pos - mac_data_pos,
+ &g_nas_buffer.buf[mac_data_pos - MAC_SIZE]);
+
+ /* Copy nas length to nas length field */
+ //uint16_t nas_pay_len = g_nas_buffer.pos - nas_len_pos - 1;
+ log_msg(LOG_INFO, "NAS payload length %d\n", g_nas_buffer.pos);
+
+ /* start: RAB2 + NAS start */
+ /* Now lets append NAS buffer to rab2....so rab2 = rab2_buf + nas_length + nas_buf */
+ if(g_nas_buffer.pos <= 127 )
+ {
+ /* datalen = g_nas_buffer.pos - nas_len_pos - 1; */
+ datalen = g_nas_buffer.pos;
+ buffer_copy(&g_rab2_buffer, &datalen, sizeof(datalen));
+ }
+ else
+ {
+ uint16_t nas_pay_len = g_nas_buffer.pos | 0x8000; // set MSB to 1
+ unsigned char lenStr[2];
+ lenStr[0] = nas_pay_len >> 8;
+ lenStr[1] = nas_pay_len & 0xff;
+ buffer_copy(&g_rab2_buffer, lenStr, sizeof(lenStr));
+ }
+ buffer_copy(&g_rab2_buffer, &g_nas_buffer.buf[0], g_nas_buffer.pos);
+ /* end : RAB2 + NAS done */
+
+ log_msg(LOG_INFO, "RAB2 payload length %d\n", g_rab2_buffer.pos);
+ /* Now lets append rab2 to rab1 */
+ if(g_rab2_buffer.pos <= 127)
+ {
+ datalen = g_rab2_buffer.pos;
+ buffer_copy(&g_rab1_buffer, &datalen, sizeof(datalen));
+ }
+ else
+ {
+ uint16_t rab2_pay_len = g_rab2_buffer.pos | 0x8000; // set MSB to 1
+ unsigned char lenStr[2];
+ lenStr[0] = rab2_pay_len >> 8;
+ lenStr[1] = rab2_pay_len & 0xff;
+ buffer_copy(&g_rab1_buffer, lenStr, sizeof(lenStr));
+ }
+ buffer_copy(&g_rab1_buffer, &g_rab2_buffer.buf[0], g_rab2_buffer.pos);
+ /* rab1 + rab2 is appended */
+ // rab1 is combined now ...
+
+ /*g_s1ap_buffer is having rab appended to it.. */
+
+ log_msg(LOG_INFO, "RAB1 payload length %d\n", g_rab1_buffer.pos);
+ if(g_rab1_buffer.pos <= 127)
+ {
+ datalen = g_rab1_buffer.pos;
+ buffer_copy(&(g_s1ap_buffer), &datalen, sizeof(datalen));
+ }
+ else
+ {
+ uint16_t rab1_pay_len = g_rab1_buffer.pos | 0x8000; // set MSB to 1
+ unsigned char lenStr[2];
+ lenStr[0] = rab1_pay_len >> 8;
+ lenStr[1] = rab1_pay_len & 0xff;
+ buffer_copy(&g_s1ap_buffer, lenStr, sizeof(lenStr));
+ }
+ buffer_copy(&g_s1ap_buffer, &g_rab1_buffer.buf[0], g_rab1_buffer.pos);
+ /* RAB is appended to s1ap payload now */
+
+ /* id-UESecurityCapabilities */
+ char ue_sec_capab[5] = {0x1c, 0x00, 0x0c, 0x00, 0x00};
+ protocolIe_Id = id_UESecurityCapabilities;
+ copyU16(tmpStr, protocolIe_Id);
+ buffer_copy(&g_s1ap_buffer, tmpStr, sizeof(protocolIe_Id));
+ protocolIe_criticality = CRITICALITY_REJECT;
+ buffer_copy(&g_s1ap_buffer, &protocolIe_criticality,
+ sizeof(protocolIe_criticality));
+ datalen = 5;
+ buffer_copy(&g_s1ap_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_s1ap_buffer, ue_sec_capab, 5);
+
+ protocolIe_Id = id_SecurityKey;
+ copyU16(tmpStr, protocolIe_Id);
+ buffer_copy(&g_s1ap_buffer, tmpStr, sizeof(protocolIe_Id));
+ protocolIe_criticality = CRITICALITY_REJECT;
+ buffer_copy(&g_s1ap_buffer, &protocolIe_criticality,
+ sizeof(protocolIe_criticality));
+ datalen = SECURITY_KEY_SIZE;
+ buffer_copy(&g_s1ap_buffer, &datalen, sizeof(datalen));
+ buffer_copy(&g_s1ap_buffer, s1apPDU.value.data[5].val.sec_key,
+ SECURITY_KEY_SIZE);
+
+ /* Copy length to s1ap length field */
+ //datalen = g_s1ap_buffer.pos - s1ap_len_pos - 1;
+ //uint16_t s1aplen = g_s1ap_buffer.pos - s1ap_len_pos - 1;
+ log_msg(LOG_INFO, "S1AP payload length %d\n", g_s1ap_buffer.pos);
+ uint16_t s1aplen = g_s1ap_buffer.pos;
+ if(s1aplen <= 127 )
+ {
+ datalen = s1aplen;
+ buffer_copy(&g_ics_buffer, &datalen, sizeof(datalen));
+ }
+ else
+ {
+ s1aplen = g_s1ap_buffer.pos | 0x8000; // set MSB to 1
+ unsigned char lenStr[2];
+ lenStr[0] = s1aplen >> 8;
+ lenStr[1] = s1aplen & 0xff;
+ buffer_copy(&g_ics_buffer, lenStr, sizeof(lenStr));
+ }
+
+ /* this is my final s1ap buffer */
+ buffer_copy(&g_ics_buffer, &g_s1ap_buffer.buf[0], g_s1ap_buffer.pos);
+
+ free(s1apPDU.value.data[3].val.E_RABToBeSetupItemCtxtSUReq.nas.elements);
+ free(s1apPDU.value.data);
+
+ send_sctp_msg(g_icsReqInfo->enb_fd, g_ics_buffer.buf, g_ics_buffer.pos, 1);
+ log_msg(LOG_INFO,"Initial Context Setup Request sent successfully\n");
+ return SUCCESS;
+}
+
+void*
+icsreq_handler(void *data)
+{
+ log_msg(LOG_INFO, "icsreq handler ready.\n");
+
+
+ icsreq_processing((struct init_ctx_req_Q_msg *)data);
+
+
+ return NULL;
+}