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;
+}