NetSim Source Code Help v14.4
All 13 Components
 
Loading...
Searching...
No Matches
LTENR_NAS.c
1/************************************************************************************
2* Copyright (C) 2023 *
3* TETCOS, Bangalore. India *
4* *
5* Tetcos owns the intellectual property rights in the Product and its content. *
6* The copying, redistribution, reselling or publication of any or all of the *
7* Product or its content without express prior written consent of Tetcos is *
8* prohibited. Ownership and / or any other right relating to the software and all *
9* intellectual property rights therein shall remain at all times with Tetcos. *
10* *
11* This source code is licensed per the NetSim license agreement. *
12* *
13* No portion of this source code may be used as the basis for a derivative work, *
14* or used, for any purpose other than its intended use per the NetSim license *
15* agreement. *
16* *
17* This source code and the algorithms contained within it are confidential trade *
18* secrets of TETCOS and may not be used as the basis for any other software, *
19* hardware, product or service. *
20* *
21* Author: Kumar Gaurav *
22* *
23* ----------------------------------------------------------------------------------*/
24
25#pragma region HEADER_FILES
26#include "stdafx.h"
27#include "LTENR_GNBRRC.h"
28#include "LTENR_NAS.h"
29#include "LTENR_PHY.h"
30#include "LTENR_EPC.h"
31#include "LTENR_Core.h"
32#include "LTENR_RLC.h"
33#pragma endregion
34
35#pragma region ADD_PACKET_INTO_BUFFER
36void fn_NetSim_NAS_ADD_PACKET_INTO_BUUFER(void* msg) {
37 NETSIM_ID d = pstruEventDetails->nDeviceId;
38 NETSIM_ID in = pstruEventDetails->nInterfaceId;
39 bool isCopy = false;
40 if (DEVICE(d)->nNumOfInterface > 2) isCopy = true;
41 NetSim_PACKET* p = pstruEventDetails->pPacket;
42 //NETSIM_ID i;
43 /*for (i = 0; i < DEVICE(d)->nNumOfInterface; i++)
44 {*/
45 /*if (DEVICE_INTERFACE(d, i + 1)->nInterfaceId == in)
46 continue;*/
47 if (isCopy) p = fn_NetSim_Packet_CopyPacket(pstruEventDetails->pPacket);
48 NETSIM_ID outIn = fn_NetSim_Stack_GetInterfaceIdByName(d, "LTE_S1");
49 NetSim_BUFFER* buf = DEVICE_ACCESSBUFFER(d, outIn);
50 if (!fn_NetSim_GetBufferStatus(buf))
51 {
52 NetSim_EVENTDETAILS pevent;
53 memset(&pevent, 0, sizeof pevent);
54 pevent.dEventTime = pstruEventDetails->dEventTime;
55 pevent.dPacketSize = sizeof(msg);
56 pevent.nDeviceId = d;
57 pevent.nDeviceType = DEVICE_TYPE(d);
58 pevent.nEventType = MAC_OUT_EVENT;
59 pevent.nInterfaceId = outIn;
60 pevent.nPacketId = p->nPacketId;
61 pevent.nProtocolId = DEVICE_MACLAYER(d, outIn)->nMacProtocolId;
62 fnpAddEvent(&pevent);
63 }
64 fn_NetSim_Packet_AddPacketToList(buf, p, 0);
65 //}
66
67 if (isCopy) fn_NetSim_Packet_FreePacket(pstruEventDetails->pPacket);
68}
69#pragma endregion
70
71#pragma region HANDOVER_COMPLETE
72void fn_NetSim_LTENR_NAS_HANDOVER_COMPLETE(ptrLTENR_HANDOVER_Hdr hdr) {
73 NetSim_EVENTDETAILS pevent;
74 memset(&pevent, 0, sizeof pevent);
75 pevent.dEventTime = pstruEventDetails->dEventTime;
76 pevent.nDeviceId = hdr->serveringCellID;
77 pevent.nDeviceType = DEVICE_TYPE(hdr->serveringCellID);
78 pevent.nEventType = TIMER_EVENT;
79 pevent.nInterfaceId = hdr->serveringCellIF;
80 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(hdr->serveringCellID, hdr->serveringCellIF);
81 LTENR_SET_SUBEVENT(pd, &pevent, LTENR_SUBEVENT_GENERATE_HANDOVER_COMPLETE);
82 pevent.pPacket = LTENR_PACKET_CREATE(hdr->serveringCellID, hdr->targetCellID, pstruEventDetails->dEventTime, LTENR_MSG_NAS_HANDOVER_COMPLETE);
83 ptrLTENR_MSG msg = pevent.pPacket->pstruMacData->Packet_MACProtocol;
84 msg->logicalChannel = LTENR_LOGICALCHANNEL_CCCH;
85 msg->physicalChannel = LTENR_PHYSICALCHANNEL_PDCCH;
86 msg->transportChannel = LTENR_TRANSPORTCHANNEL_DL_SCH;
87 msg->rlcMode = LTENR_RLCMODE_TM;
88 fn_NetSIm_LTENR_NAS_ADD_HDR_INTO_PACKET(pevent.pPacket, hdr, nasHandoverComplete, LTENR_MSG_NAS_HANDOVER_COMPLETE);
89 fnpAddEvent(&pevent);
90}
91void fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_COMPLETE() {
92 ptrLTENR_HANDOVER_Hdr hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasHandoverComplete);
93 hdr->msgType = LTENR_MSG_NAS_HANDOVER_COMPLETE;
94 LTENR_CallPDCPOut();
95}
96void fn_NetSim_LTENR_NAS_HANDOVER_COMPLETE_RECV() {
97 //do nothing
98}
99#pragma endregion
100
101#pragma region UE_CONTEXT_RELEASE_ACK
102void fn_NetSim_LTENR_NAS_UE_CONTEXT_RELEASE_ACK(ptrLTENR_HANDOVER_Hdr hdr) {
103 NetSim_EVENTDETAILS pevent;
104 memset(&pevent, 0, sizeof pevent);
105 pevent.dEventTime = pstruEventDetails->dEventTime;
106 pevent.nDeviceId = hdr->serveringCellID;
107 pevent.nDeviceType = DEVICE_TYPE(hdr->serveringCellID);
108 pevent.nEventType = TIMER_EVENT;
109 pevent.nInterfaceId = hdr->serveringCellIF;
110 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(hdr->serveringCellID, hdr->serveringCellIF);
111 LTENR_SET_SUBEVENT(pd, &pevent, LTENR_SUBEVENT_GENERATE_UECONTEXTRELEASE_ACK);
112 pevent.pPacket = LTENR_PACKET_CREATE(hdr->serveringCellID, hdr->targetCellID, pstruEventDetails->dEventTime, LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE_ACK);
113 ptrLTENR_MSG msg = pevent.pPacket->pstruMacData->Packet_MACProtocol;
114 msg->logicalChannel = LTENR_LOGICALCHANNEL_CCCH;
115 msg->physicalChannel = LTENR_PHYSICALCHANNEL_PDCCH;
116 msg->transportChannel = LTENR_TRANSPORTCHANNEL_DL_SCH;
117 msg->rlcMode = LTENR_RLCMODE_TM;
118 fn_NetSIm_LTENR_NAS_ADD_HDR_INTO_PACKET(pevent.pPacket, hdr, nasUEContextReleaseACK, LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE_ACK);
119 fnpAddEvent(&pevent);
120}
121void fn_NetSim_LTENR_NAS_GENERATE_UE_CONTEXT_RELEASE_ACK() {
122 ptrLTENR_HANDOVER_Hdr hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasUEContextReleaseACK);
123 hdr->msgType = LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE_ACK;
124 ptrLTENR_NAS_UECONTEXTRELEASECOMMAND msg = calloc(1, sizeof * msg);
125 msg->ueID = hdr->UEID;
126 msg->outCome = HANDOVER_OUTCOME_SUCESSFUL;
127 msg->cause = HANDOVER_CAUSE_RADIO_NETWORK;
128 hdr->msg = msg;
129 pstruEventDetails->pPacket->pstruMacData->dontFree = true;
130 fn_NetSim_NAS_ADD_PACKET_INTO_BUUFER(msg);
131}
132void fn_NetSim_LTENR_NAS_UE_CONTEXT_RELEASE_ACK_RECV(ptrLTENR_HANDOVER_Hdr hdr) {
133 ptrLTENR_NAS_UECONTEXTRELEASECOMMAND msg = hdr->msg;
134 if (msg->outCome != HANDOVER_OUTCOME_SUCESSFUL) {
135 fnNetSimError("UE context release outcome is unsuccessful.");
136 }
137}
138#pragma endregion
139
140#pragma region UE_CONTEXT_RELEASE
141void fn_NetSim_LTENR_NAS_UE_CONTEXT_RELEASE(ptrLTENR_HANDOVER_Hdr hdr) {
142 NetSim_EVENTDETAILS pevent;
143 memset(&pevent, 0, sizeof pevent);
144 pevent.dEventTime = pstruEventDetails->dEventTime;
145 pevent.nDeviceId = hdr->targetCellID;
146 pevent.nDeviceType = DEVICE_TYPE(hdr->targetCellID);
147 pevent.nEventType = TIMER_EVENT;
148 pevent.nInterfaceId = hdr->targetCellIF;
149 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(hdr->targetCellID, hdr->targetCellIF);
150 LTENR_SET_SUBEVENT(pd, &pevent, LTENR_SUBEVENT_GENERATE_UECONTEXTRELEASE);
151 pevent.pPacket = LTENR_PACKET_CREATE(hdr->targetCellID, hdr->serveringCellID, pstruEventDetails->dEventTime, LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE);
152 ptrLTENR_MSG msg = pevent.pPacket->pstruMacData->Packet_MACProtocol;
153 msg->logicalChannel = LTENR_LOGICALCHANNEL_CCCH;
154 msg->physicalChannel = LTENR_PHYSICALCHANNEL_PDCCH;
155 msg->transportChannel = LTENR_TRANSPORTCHANNEL_DL_SCH;
156 msg->rlcMode = LTENR_RLCMODE_TM;
157 fn_NetSIm_LTENR_NAS_ADD_HDR_INTO_PACKET(pevent.pPacket, hdr, nasUEContextRelease, LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE);
158 fnpAddEvent(&pevent);
159}
160void fn_NetSim_LTENR_NAS_GENERATE_UE_CONTEXT_RELEASE() {
161 ptrLTENR_HANDOVER_Hdr hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasUEContextRelease);
162 hdr->msgType = LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE;
163 ptrLTENR_NAS_UECONTEXTRELEASEREQUEST msg = calloc(1, sizeof * msg);
164 msg->cause = HANDOVER_CAUSE_RADIO_NETWORK;
165 msg->gnb_UE_ID = hdr->targetCellIF;
166 msg->mme_UE_ID = hdr->AMFID;
167 hdr->msg = msg;
168 pstruEventDetails->pPacket->pstruMacData->dontFree = true;
169 fn_NetSim_NAS_ADD_PACKET_INTO_BUUFER(msg);
170}
171void fn_NetSim_LTENR_NAS_UE_CONTEXT_RELEASE_RECV(ptrLTENR_HANDOVER_Hdr hdr) {
172 fn_NetSim_LTENR_NAS_UE_CONTEXT_RELEASE_ACK(hdr);
173}
174#pragma endregion
175
176#pragma region PATH_SWITCH_ACK
177void fn_NetSim_LTENR_NAS_PATH_SWITCH_ACK(ptrLTENR_HANDOVER_Hdr hdr) {
178 NetSim_EVENTDETAILS pevent;
179 memset(&pevent, 0, sizeof pevent);
180 pevent.dEventTime = pstruEventDetails->dEventTime;
181 pevent.nDeviceId = hdr->AMFID;
182 pevent.nDeviceType = DEVICE_TYPE(hdr->AMFID);
183 pevent.nEventType = TIMER_EVENT;
184 pevent.nInterfaceId = LTENR_NSA_EPC_HLR_FindOutInterface_FOR_GNB(hdr->AMFID, hdr->UEID, hdr->targetCellID);
185 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(hdr->AMFID, hdr->AMFIF);
186 LTENR_SET_SUBEVENT(pd, &pevent, LTENR_SUBEVENT_GENERATE_PATH_SWITCH_ACK);
187 pevent.pPacket = LTENR_PACKET_CREATE(hdr->AMFID, hdr->targetCellID, pstruEventDetails->dEventTime, LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK);
188 ptrLTENR_MSG msg = pevent.pPacket->pstruMacData->Packet_MACProtocol;
189 msg->logicalChannel = LTENR_LOGICALCHANNEL_CCCH;
190 msg->physicalChannel = LTENR_PHYSICALCHANNEL_PDCCH;
191 msg->transportChannel = LTENR_TRANSPORTCHANNEL_DL_SCH;
192 msg->rlcMode = LTENR_RLCMODE_TM;
193 fn_NetSIm_LTENR_NAS_ADD_HDR_INTO_PACKET(pevent.pPacket, hdr, naspathSwitchAck, LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK);
194 fnpAddEvent(&pevent);
195}
196void fn_NetSim_LTENR_NAS_GENERATE_PATH_SWITCH_REQUEST_ACK() {
197 ptrLTENR_HANDOVER_Hdr hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, naspathSwitchAck);
198 ptrLTENR_NAS_PATH_SWITCH_REQUEST msg = calloc(1, sizeof * msg);
199 hdr->msgType = LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK;
200 //path switch
201 //NETSIM_ID epcIn = LTENR_EPC_HLR_FindOutInterface(hdr->AMFID, hdr->serveringCellID);
202 //ptrLTENR_EPC_HLR hlr = LTENR_EPC_FindHLR(hdr->AMFID, epcIn, hdr->serveringCellID);
203 //ptrLTENR_EPC epc = LTENR_EPC_GET(hdr->AMFID, epcIn);
204 //LTENR_EPC_HLR_REMOVE(epc, hlr);
205 pstruEventDetails->pPacket->pstruMacData->dontFree = true;
206 //add into buffer
207 NetSim_BUFFER* buf = DEVICE_ACCESSBUFFER(pstruEventDetails->nDeviceId, pstruEventDetails->nInterfaceId);
208 NetSim_PACKET* p = pstruEventDetails->pPacket;
209 if (!fn_NetSim_GetBufferStatus(buf))
210 {
211 NetSim_EVENTDETAILS pevent;
212 memset(&pevent, 0, sizeof pevent);
213 pevent.dEventTime = pstruEventDetails->dEventTime;
214 pevent.dPacketSize = sizeof(msg);
215 pevent.nDeviceId = pstruEventDetails->nDeviceId;
216 pevent.nDeviceType = DEVICE_TYPE(pstruEventDetails->nDeviceId);
217 pevent.nEventType = MAC_OUT_EVENT;
218 pevent.nInterfaceId = pstruEventDetails->nInterfaceId;
219 pevent.nPacketId = p->nPacketId;
220 pevent.nProtocolId = DEVICE_MACLAYER(pstruEventDetails->nDeviceId, pstruEventDetails->nInterfaceId)->nMacProtocolId;
221 fnpAddEvent(&pevent);
222 }
223 fn_NetSim_Packet_AddPacketToList(buf, p, 0);
224 pstruEventDetails->pPacket = NULL;
225}
226void fn_NetSim_LTENR_NAS_PATH_SWITCH_ACK_RECV(ptrLTENR_HANDOVER_Hdr hdr) {
227 if (fn_NetSim_LTENR_CORE_INTERFACE(hdr->serveringCellID, nGC_INTERFACE_XN)) {
228 LTENR_HANDOVER_UE_CONTEXT_RELEASE(hdr);
229 }
230 else {
231 fn_NetSim_LTENR_NAS_UE_CONTEXT_RELEASE(hdr);
232 }
233}
234#pragma endregion
235
236#pragma region PATH_SWITCH_REQUEST
237void fn_NetSim_LTENR_NAS_PATH_SWITCH_REQUEST(ptrLTENR_HANDOVER_Hdr hdr) {
238 NetSim_EVENTDETAILS pevent;
239 memset(&pevent, 0, sizeof pevent);
240 pevent.dEventTime = pstruEventDetails->dEventTime;
241 pevent.nDeviceId = hdr->targetCellID;
242 pevent.nDeviceType = DEVICE_TYPE(hdr->targetCellID);
243 pevent.nEventType = TIMER_EVENT;
244 pevent.nInterfaceId = hdr->targetCellIF;
245 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(hdr->targetCellID, hdr->targetCellIF);
246 LTENR_SET_SUBEVENT(pd, &pevent, LTENR_SUBEVENT_GENERATE_PATH_SWITCH);
247 pevent.pPacket = LTENR_PACKET_CREATE(hdr->targetCellID, hdr->AMFID, pstruEventDetails->dEventTime, LTENR_MSG_NAS_HANDOVER_PATH_SWITCH);
248 ptrLTENR_MSG msg = pevent.pPacket->pstruMacData->Packet_MACProtocol;
249 msg->logicalChannel = LTENR_LOGICALCHANNEL_CCCH;
250 msg->physicalChannel = LTENR_PHYSICALCHANNEL_PDCCH;
251 msg->transportChannel = LTENR_TRANSPORTCHANNEL_DL_SCH;
252 msg->rlcMode = LTENR_RLCMODE_TM;
253 fn_NetSIm_LTENR_NAS_ADD_HDR_INTO_PACKET(pevent.pPacket, hdr, nasPathSwitch, LTENR_MSG_NAS_HANDOVER_PATH_SWITCH);
254 fnpAddEvent(&pevent);
255}
256void fn_NetSim_LTENR_NAS_GENERATE_PATH_SWITCH_REQUEST() {
257 ptrLTENR_HANDOVER_Hdr hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasPathSwitch);
258 ptrLTENR_NAS_PATH_SWITCH_REQUEST msg = calloc(1, sizeof * msg);
259 msg->targetGNBID = hdr->targetCellID;
260 hdr->msg = msg;
261 hdr->msgType = LTENR_MSG_NAS_HANDOVER_PATH_SWITCH;
262 pstruEventDetails->pPacket->pstruMacData->dontFree = true;
263 //add into buffer
264 NETSIM_ID d = pstruEventDetails->nDeviceId;
265 NETSIM_ID in = fn_NetSim_LTENR_CORE_INTERFACE(d, nGC_INTERFACE_LTE_S1);
266 NetSim_BUFFER* buf = DEVICE_ACCESSBUFFER(d, in);
267 NetSim_PACKET* p = pstruEventDetails->pPacket;
268 if (!fn_NetSim_GetBufferStatus(buf))
269 {
270 NetSim_EVENTDETAILS pevent;
271 memset(&pevent, 0, sizeof pevent);
272 pevent.dEventTime = pstruEventDetails->dEventTime;
273 pevent.dPacketSize = sizeof(msg);
274 pevent.nDeviceId = pstruEventDetails->nDeviceId;
275 pevent.nDeviceType = DEVICE_TYPE(d);
276 pevent.nEventType = MAC_OUT_EVENT;
277 pevent.nInterfaceId = in;
278 pevent.nPacketId = p->nPacketId;
279 pevent.nProtocolId = DEVICE_MACLAYER(d, in)->nMacProtocolId;
280 fnpAddEvent(&pevent);
281 }
282 fn_NetSim_Packet_AddPacketToList(buf, p, 0);
283 pstruEventDetails->pPacket = NULL;
284}
285void fn_NetSim_LTENR_NAS_PATH_SWITCH_REQUEST_RECV(ptrLTENR_HANDOVER_Hdr hdr) {
286 pstruEventDetails->pPacket = NULL;
287 fn_NetSim_LTENR_NAS_PATH_SWITCH_ACK(hdr);
288}
289#pragma endregion
290
291#pragma region BUFFER_TRANSFER
292void fn_NetSim_LTENR_NAS_PDCP_BUFFER_TRANSFER(ptrLTENR_PDCPENTITY ser, ptrLTENR_PDCPENTITY tar, int flag) {
293 if (!ser)
294 return;
295 if (!tar)
296 return;
297
298 tar->transmissionBuffer = ser->transmissionBuffer;
299 if (tar->transmissionBuffer->headPacket != NULL) {
300 ptrLTENR_BUFFEREDPACKET buf = tar->transmissionBuffer->headPacket;
301 NetSim_PACKET* head = tar->transmissionBuffer->headPacket->packet;
302 NetSim_PACKET* packet = NULL;
303 while (buf) {
304 packet = buf->packet;
305 while (packet) {
306 if (flag == 0)
307 packet->nTransmitterId = tar->enbId;
308 else
309 packet->nReceiverId = tar->enbId;
310 packet = packet->pstruNextPacket;
311 }
312 buf = buf->next;
313 }
314 tar->transmissionBuffer->headPacket->packet = head;
315 }
316
317 ser->transmissionBuffer = NULL;
318 tar->receiveBuffer = ser->receiveBuffer;
319 ser->receiveBuffer = NULL;
320 tar->TX_NEXT = ser->TX_NEXT;
321 tar->last_RECV_COUNT = ser->last_RECV_COUNT;
322 tar->RX_DELIV = ser->RX_DELIV;
323 tar->RX_NEXT = ser->RX_NEXT;
324 tar->RX_REORD = ser->RX_REORD;
325}
326void fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(ptrLTENR_RLCENTITY ser, ptrLTENR_RLCENTITY tar, int flag) {
327 if (!ser)
328 return;
329 if (!tar)
330 return;
331
332 tar->transmissionBuffer = ser->transmissionBuffer;
333 ser->transmissionBuffer = NULL;
334 tar->AM = ser->AM;
335 if (tar->AM.receptionBuffer != NULL) {
336 ptrLTENR_RLC_RECEPTIONBUFFER buf = tar->AM.receptionBuffer;
337 NetSim_PACKET* head = tar->AM.receptionBuffer->head;
338 NetSim_PACKET* packet = NULL;
339 while (buf) {
340 packet = buf->head;
341 while (packet) {
342 if (flag == 0)
343 packet->nReceiverId = tar->d;
344 else
345 packet->nTransmitterId = tar->peerId;
346 packet = packet->pstruNextPacket;
347 }
348 buf = LTENR_RLC_RECEPTIONBUFFER_NEXT(buf);
349 }
350 tar->AM.receptionBuffer->head = head;
351 }
352 ser->AM.receptionBuffer = NULL;
353 tar->UM = ser->UM;
354 if (tar->UM.receptionBuffer != NULL) {
355 ptrLTENR_RLC_RECEPTIONBUFFER buf = tar->UM.receptionBuffer;
356 NetSim_PACKET* head = tar->UM.receptionBuffer->head;
357 NetSim_PACKET* packet = NULL;
358 while (buf) {
359 packet = buf->head;
360 while (packet) {
361 if (flag == 0)
362 packet->nReceiverId = tar->d;
363 else
364 packet->nTransmitterId = tar->peerId;
365 packet = packet->pstruNextPacket;
366 }
367 buf = LTENR_RLC_RECEPTIONBUFFER_NEXT(buf);
368 }
369 tar->UM.receptionBuffer->head = head;
370 }
371 ser->UM.receptionBuffer = NULL;
372 tar->retransmissionBuffer = ser->retransmissionBuffer;
373 ser->retransmissionBuffer = NULL;
374 tar->rlcMode = ser->rlcMode;
375 tar->transmittedBuffer = ser->transmittedBuffer;
376 tar->pollRetransmitTimerId = ser->pollRetransmitTimerId;
377 tar->isPollRetransmitTimerStarted = ser->isPollRetransmitTimerStarted;
378 tar->reassemblyTimerId = ser->reassemblyTimerId;
379 if (ser->isPollRetransmitTimerStarted) {
380 LTENR_RLCAM_Stop_t_PollRetransmitTimer(ser);
381 LTENR_RLCAM_Start_t_PollRetransmitTimer(tar);
382 }
383 tar->isReassemblyTimerStarted = ser->isReassemblyTimerStarted;
384 if (ser->isReassemblyTimerStarted) {
385 fnDeleteEvent(ser->reassemblyTimerId);
386 LTENR_RLCAM_Start_t_ReassemblyTimer(tar);
387 }
388 tar->statusProhibitTimerId = ser->statusProhibitTimerId;
389 tar->isStatusProhibitTimerStarted = ser->isStatusProhibitTimerStarted;
390 ser->transmittedBuffer = NULL;
391 for (int i = 0; i < LTENR_LOGICALCHANNEL_LAST; i++)
392 tar->bufferStatus[i] = ser->bufferStatus[i];
393}
394
395void fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_TRANSMISSION_ID(ptrLTENR_RLCENTITY entity, NETSIM_ID t)
396{
397 if (!entity)
398 return;
399
400 ptrLTENR_RLCBUFFER_DATA buf = entity->transmissionBuffer->head;
401 while (buf)
402 {
403 buf->packet->nTransmitterId = t;
404 buf = buf->next;
405 }
406
407 ptrLTENR_RLCBUFFER_DATA rxbuf = entity->retransmissionBuffer->head;
408 while (rxbuf)
409 {
410 rxbuf->packet->nTransmitterId = t;
411 rxbuf = rxbuf->next;
412 }
413}
414
415void fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_RECEIVER_ID(ptrLTENR_RLCENTITY entity, NETSIM_ID t)
416{
417 if (!entity)
418 return;
419
420 ptrLTENR_RLCBUFFER_DATA buf = entity->transmissionBuffer->head;
421 while (buf)
422 {
423 buf->packet->nReceiverId = t;
424 buf = buf->next;
425 }
426
427 ptrLTENR_RLCBUFFER_DATA rxbuf = entity->retransmissionBuffer->head;
428 while (rxbuf)
429 {
430 rxbuf->packet->nReceiverId = t;
431 rxbuf = rxbuf->next;
432 }
433}
434
435void fn_NetSim_LTENR_NAS_RLC_UE_BUFFER_TRANSFER(NETSIM_ID d, NETSIM_ID in,
436 NETSIM_ID r, NETSIM_ID rin,
437 NETSIM_ID t, NETSIM_ID tin) {
438
439 ptrLTENR_RLCENTITY SerEntity = LTENR_RLC_FINDENTITY(r, rin, d, in, LTENR_RLCMODE_TM, true, false);
440 ptrLTENR_RLCENTITY TarEntity = LTENR_RLC_FINDENTITY(r, rin, t, tin, LTENR_RLCMODE_TM, true, false);
441 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 1);
442 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_RECEIVER_ID(TarEntity, t);
443
444 SerEntity = LTENR_RLC_FINDENTITY(r, rin, d, in, LTENR_RLCMODE_TM, false, true);
445 TarEntity = LTENR_RLC_FINDENTITY(r, rin, t, tin, LTENR_RLCMODE_TM, false, true);
446 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 1);
447 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_RECEIVER_ID(TarEntity, t);
448
449 SerEntity = LTENR_RLC_FINDENTITY(r, rin, d, in, LTENR_RLCMODE_UM, true, false);
450 TarEntity = LTENR_RLC_FINDENTITY(r, rin, t, tin, LTENR_RLCMODE_UM, true, false);
451 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 1);
452 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_RECEIVER_ID(TarEntity, t);
453
454 SerEntity = LTENR_RLC_FINDENTITY(r, rin, d, in, LTENR_RLCMODE_UM, false, true);
455 TarEntity = LTENR_RLC_FINDENTITY(r, rin, t, tin, LTENR_RLCMODE_UM, false, true);
456 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 1);
457 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_RECEIVER_ID(TarEntity, t);
458
459 SerEntity = LTENR_RLC_FINDENTITY(r, rin, d, in, LTENR_RLCMODE_AM, true, true);
460 TarEntity = LTENR_RLC_FINDENTITY(r, rin, t, tin, LTENR_RLCMODE_AM, true, true);
461 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 1);
462 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_RECEIVER_ID(TarEntity, t);
463
464}
465void fn_NetSim_LTENR_NAS_RLC_GNB_BUFFER_TRANSFER(NETSIM_ID d, NETSIM_ID in,
466 NETSIM_ID r, NETSIM_ID rin,
467 NETSIM_ID t, NETSIM_ID tin) {
468
469 ptrLTENR_RLCENTITY SerEntity = LTENR_RLC_FINDENTITY(d, in, r, rin, LTENR_RLCMODE_TM, true, false);
470 ptrLTENR_RLCENTITY TarEntity = LTENR_RLC_FINDENTITY(t, tin, r, rin, LTENR_RLCMODE_TM, true, false);
471 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 0);
472 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_TRANSMISSION_ID(TarEntity, t);
473 SerEntity = LTENR_RLC_FINDENTITY(d, in, r, rin, LTENR_RLCMODE_TM, false, true);
474 TarEntity = LTENR_RLC_FINDENTITY(t, tin, r, rin, LTENR_RLCMODE_TM, false, true);
475 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 0);
476 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_TRANSMISSION_ID(TarEntity, t);
477 SerEntity = LTENR_RLC_FINDENTITY(d, in, r, rin, LTENR_RLCMODE_UM, true, false);
478 TarEntity = LTENR_RLC_FINDENTITY(t, tin, r, rin, LTENR_RLCMODE_UM, true, false);
479 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 0);
480 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_TRANSMISSION_ID(TarEntity, t);
481 SerEntity = LTENR_RLC_FINDENTITY(d, in, r, rin, LTENR_RLCMODE_UM, false, true);
482 TarEntity = LTENR_RLC_FINDENTITY(t, tin, r, rin, LTENR_RLCMODE_UM, false, true);
483 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 0);
484 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_TRANSMISSION_ID(TarEntity, t);
485 SerEntity = LTENR_RLC_FINDENTITY(d, in, r, rin, LTENR_RLCMODE_AM, true, true);
486 TarEntity = LTENR_RLC_FINDENTITY(t, tin, r, rin, LTENR_RLCMODE_AM, true, true);
487 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER(SerEntity, TarEntity, 0);
488 fn_NetSim_LTENR_NAS_RLC_BUFFER_TRANSFER_CHANGE_TRANSMISSION_ID(TarEntity, t);
489}
490#pragma endregion
491
492#pragma region HANDOVER_COMMAND
493void fn_NetSim_LTENR_NAS_HANDOVER_COMMAND(ptrLTENR_HANDOVER_Hdr hdr) {
494 NetSim_EVENTDETAILS pevent;
495 memset(&pevent, 0, sizeof pevent);
496 pevent.dEventTime = pstruEventDetails->dEventTime;
497 pevent.nDeviceId = hdr->serveringCellID;
498 pevent.nDeviceType = DEVICE_TYPE(hdr->serveringCellID);
499 pevent.nEventType = TIMER_EVENT;
500 pevent.nInterfaceId = hdr->serveringCellIF;
501 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(hdr->serveringCellID, hdr->serveringCellIF);
502 LTENR_SET_SUBEVENT(pd, &pevent, LTENR_SUBEVENT_GENERATE_HANDOVER_COMMAND);
503 pevent.pPacket = LTENR_PACKET_CREATE(hdr->serveringCellID, hdr->UEID, pstruEventDetails->dEventTime, LTENR_MSG_NAS_HANDOVER_COMMAND);
504 ptrLTENR_MSG msg = pevent.pPacket->pstruMacData->Packet_MACProtocol;
505 msg->logicalChannel = LTENR_LOGICALCHANNEL_CCCH;
506 msg->physicalChannel = LTENR_PHYSICALCHANNEL_PDCCH;
507 msg->transportChannel = LTENR_TRANSPORTCHANNEL_DL_SCH;
508 msg->rlcMode = LTENR_RLCMODE_TM;
509 fn_NetSIm_LTENR_NAS_ADD_HDR_INTO_PACKET(pevent.pPacket, hdr, nasHandoverTrigger, LTENR_MSG_NAS_HANDOVER_COMMAND);
510 fnpAddEvent(&pevent);
511}
512void fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_COMMAND() {
513 ptrLTENR_HANDOVER_Hdr hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasHandoverTrigger);
514 ptrLTENR_NAS_HANDOVER_COMMAND msg = calloc(1, sizeof * msg);
515 msg->E_RADataForwading_DL_TransportLayerAddress = DEVICE_NWADDRESS(hdr->targetCellID, hdr->targetCellIF);
516 msg->MME_UE_ID = hdr->AMFID;
517 msg->type = HANDOVER_TYPE_INTRA_LTENR;
518 hdr->msg = msg;
519 hdr->msgType = LTENR_MSG_NAS_HANDOVER_COMMAND;
520 pstruEventDetails->pPacket->pstruMacData->dontFree = true;
521 LTENR_CallPDCPOut();
522}
523
524void fn_NetSim_LTENR_NAS_HANDOVER_COMMAND_HANDLE(ptrLTENR_HANDOVER_Hdr hdr) {
525 NetSim_EVENTDETAILS pevent;
526 memset(&pevent, 0, sizeof pevent);
527 NETSIM_ID sin = fn_NetSim_LTENR_SEC_INTEFACE_FOR_UE(hdr->UEID, hdr->UEIF);
528 ptrLTENR_UERRC uerrc_secondary = LTENR_UERRC_GET(hdr->UEID, sin);
529 ptrLTENR_UERRC uerrc = LTENR_UERRC_GET(hdr->UEID, hdr->UEIF);
530 ptrLTENR_GNBRRC gNBrrc = LTENR_GNBRRC_GET(hdr->serveringCellID, hdr->serveringCellIF);
531
532 uerrc->isMNHandoverComplete = true;
533 uerrc->ueRRCState = UERRC_INACTIVE;
534 if (uerrc_secondary->isSecondaryAssociated)
535 uerrc_secondary->ueRRCState = UERRC_INACTIVE;
536
537 double T1 = pstruEventDetails->dEventTime;
538 double Time_Diff = pstruEventDetails->dEventTime - hdr->HandoverStartTime;
539 double Time_added = max((gNBrrc->InterruptionTime - Time_Diff), 0);
540 uerrc->InteruptionInterval = Time_added;
541 pevent.dEventTime = pstruEventDetails->dEventTime +Time_added;
542 pevent.nDeviceId = pstruEventDetails->nDeviceId;
543 pevent.nDeviceType = DEVICE_TYPE(pstruEventDetails->nDeviceId);
544 pevent.nEventType = TIMER_EVENT;
545 pevent.nInterfaceId = pstruEventDetails->nInterfaceId;
546 pevent.szOtherDetails = hdr;
547 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(pstruEventDetails->nDeviceId, pstruEventDetails->nInterfaceId);
548 LTENR_SET_SUBEVENT(pd, &pevent, LTENR_SUBEVENT_GENERATE_HANDOVER_COMMAND_HANDLE);
549 fnpAddEvent(&pevent);
550}
551
552void fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_COMMAND_HANDLE()
553{
554 ptrLTENR_HANDOVER_Hdr hdr = pstruEventDetails->szOtherDetails;
555 NETSIM_ID d = hdr->serveringCellID;
556 NETSIM_ID in = hdr->serveringCellIF;
557 NETSIM_ID r = hdr->UEID;
558 NETSIM_ID rin = hdr->UEIF;
559 NETSIM_ID t = hdr->targetCellID;
560 NETSIM_ID tin = hdr->targetCellIF;
561
562
563 ptrLTENR_UERRC ueRRC = LTENR_UERRC_GET(r, rin);
564 NETSIM_ID sin = fn_NetSim_LTENR_SEC_INTEFACE_FOR_UE(r,rin);
565
566 ptrLTENR_UERRC uerrc_secondary = LTENR_UERRC_GET(hdr->UEID, sin);
567 uerrc_secondary->ueRRCState = UERRC_CONNECTED;
568 ueRRC->ueRRCState = UERRC_CONNECTED;
569 ueRRC->ueCMState = UE_CM_CONNECTED;
570 //Association and Dissociation of interface
571 LTENR_ASSOCIATEINFO_REMOVE(d, in, r, rin);
572 LTENR_ASSOCIATEINFO_ADD(t, tin, r, rin);
573
574 LTENR_PHY_ASSOCIATION(t, tin, r, rin, true);
575 LTENR_PDCP_ASSOCIATION(t, tin, r, rin, true);
576 LTENR_RLC_ASSOCIATION(t, tin, r, rin, true);
577 //ptrLTENR_UERRC ueRRC = LTENR_UERRC_GET(r, rin);
578 ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(r, rin);
579
580 ptrLTENR_PDCPVAR serPDCPVar = LTENR_GNBPDCP_GET(d, in);
581 ptrLTENR_PDCPVAR tarPDCPVar = LTENR_GNBPDCP_GET(t, tin);
582 ptrLTENR_PDCPVAR uePDCPVar = LTENR_UEPDCP_GET(r, rin);
583
584 //Buffer transfer GNB PDCP
585 ptrLTENR_PDCPENTITY serentity = LTENR_PDCP_FindEntity(serPDCPVar, d, in, r, rin, LTENR_RLCMODE_TM);
586 ptrLTENR_PDCPENTITY tarentity = LTENR_PDCP_FindEntity(tarPDCPVar, t, tin, r, rin, LTENR_RLCMODE_TM);
587 fn_NetSim_LTENR_NAS_PDCP_BUFFER_TRANSFER(serentity, tarentity, 0);
588
589 serentity = LTENR_PDCP_FindEntity(serPDCPVar, d, in, r, rin, LTENR_RLCMODE_UM);
590 tarentity = LTENR_PDCP_FindEntity(tarPDCPVar, t, tin, r, rin, LTENR_RLCMODE_UM);
591 fn_NetSim_LTENR_NAS_PDCP_BUFFER_TRANSFER(serentity, tarentity, 0);
592
593 serentity = LTENR_PDCP_FindEntity(serPDCPVar, d, in, r, rin, LTENR_RLCMODE_AM);
594 tarentity = LTENR_PDCP_FindEntity(tarPDCPVar, t, tin, r, rin, LTENR_RLCMODE_AM);
595 fn_NetSim_LTENR_NAS_PDCP_BUFFER_TRANSFER(serentity, tarentity, 0);
596
597 //Buffer transfer UE PDCP
598 serentity = LTENR_PDCP_FindEntity(uePDCPVar, d, in, r, rin, LTENR_RLCMODE_TM);
599 tarentity = LTENR_PDCP_FindEntity(uePDCPVar, t, tin, r, rin, LTENR_RLCMODE_TM);
600 fn_NetSim_LTENR_NAS_PDCP_BUFFER_TRANSFER(serentity, tarentity, 1);
601
602 serentity = LTENR_PDCP_FindEntity(uePDCPVar, d, in, r, rin, LTENR_RLCMODE_UM);
603 tarentity = LTENR_PDCP_FindEntity(uePDCPVar, t, tin, r, rin, LTENR_RLCMODE_UM);
604 fn_NetSim_LTENR_NAS_PDCP_BUFFER_TRANSFER(serentity, tarentity, 1);
605
606 serentity = LTENR_PDCP_FindEntity(uePDCPVar, d, in, r, rin, LTENR_RLCMODE_AM);
607 tarentity = LTENR_PDCP_FindEntity(uePDCPVar, t, tin, r, rin, LTENR_RLCMODE_AM);
608 fn_NetSim_LTENR_NAS_PDCP_BUFFER_TRANSFER(serentity, tarentity, 1);
609
610 fn_NetSim_LTENR_NAS_RLC_GNB_BUFFER_TRANSFER(d, in, r, rin, t, tin);
611 fn_NetSim_LTENR_NAS_RLC_UE_BUFFER_TRANSFER(d, in, r, rin, t, tin);
612
613 //rrc reconfig remaining
614 ueRRC->SelectedCellID = hdr->targetCellID;
615 ueRRC->SelectedCellIF = hdr->targetCellIF;
616
617 //disassociation
618 LTENR_PHY_ASSOCIATION(d, in, r, rin, false);
619 LTENR_PDCP_ASSOCIATION(d, in, r, rin, false);
620 LTENR_RLC_ASSOCIATION(d, in, r, rin, false);
621
622 //EPC Dissociation
623 if (fn_NetSim_LTENR_IS_S1_INTERFACE_EXISTS(d)) {
624 NETSIM_ID epcIn = LTENR_NSA_EPC_HLR_FindOutInterface_FOR_GNB(hdr->AMFID, hdr->UEID, hdr->serveringCellID);
625 ptrLTENR_EPC_HLR hlr = LTENR_EPC_FindHLR_For_GNB(hdr->AMFID, epcIn, hdr->UEID, hdr->serveringCellID);
626 ptrLTENR_EPC epc = LTENR_EPC_GET(hdr->AMFID, epcIn);
627 LTENR_EPC_HLR_REMOVE(epc, hlr);
628
629 hlr = LTENR_EPC_FindHLR_For_GNB(hdr->AMFID, epcIn, hdr->UEID, hdr->serveringCellID);
630 if (hlr != NULL) {
631 LTENR_EPC_HLR_REMOVE(epc, hlr);
632 }
633 }
634
635 fn_NetSim_Stack_RemoveDeviceFromlink(r, rin, DEVICE_PHYLAYER(d, in)->nLinkId);
636 fn_NetSim_Stack_AddDeviceTolink(r, rin, DEVICE_PHYLAYER(t, tin)->nLinkId);
637 fn_NetSim_LTENR_RRC_RECONFIGURATION(r, rin, t, tin);
638 if (!fn_NetSim_LTENR_IS_S1_INTERFACE_EXISTS(d))
639 fn_NetSim_LTENR_GNB_CORE_PATH_SWITCH_MSG(hdr);
640 else
641 fn_NetSim_LTENR_NAS_PATH_SWITCH_REQUEST(hdr);
642}
643
644void fn_NetSim_LTENR_NAS_HANDOVER_COMMAND_RECV(ptrLTENR_HANDOVER_Hdr hdr) {
645 fn_NetSim_LTENR_NAS_HANDOVER_COMMAND_HANDLE(hdr);
646}
647#pragma endregion
648
649#pragma region Handover_Request_ACK
650void fn_NetSim_LTENR_NAS_HANDOVER_REQUEST_ACK(ptrLTENR_HANDOVER_Hdr hdr) {
651 NetSim_EVENTDETAILS pevent;
652 memset(&pevent, 0, sizeof pevent);
653 pevent.dEventTime = pstruEventDetails->dEventTime;
654 pevent.nDeviceId = hdr->targetCellID;
655 pevent.nDeviceType = DEVICE_TYPE(hdr->targetCellID);
656 pevent.nEventType = TIMER_EVENT;
657 pevent.nInterfaceId = hdr->targetCellIF;
658 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(hdr->targetCellID, hdr->targetCellIF);
659 LTENR_SET_SUBEVENT(pd, &pevent, LTENR_SUBEVENT_GENERATE_HANDOVER_REQUEST_ACK);
660 pevent.pPacket = LTENR_PACKET_CREATE(hdr->targetCellID, hdr->serveringCellID, pstruEventDetails->dEventTime, LTENR_MSG_NAS_HANDOVER_REQUEST_ACK);
661 ptrLTENR_MSG msg = pevent.pPacket->pstruMacData->Packet_MACProtocol;
662 msg->logicalChannel = LTENR_LOGICALCHANNEL_CCCH;
663 msg->physicalChannel = LTENR_PHYSICALCHANNEL_PDCCH;
664 msg->transportChannel = LTENR_TRANSPORTCHANNEL_DL_SCH;
665 msg->rlcMode = LTENR_RLCMODE_TM;
666 fn_NetSIm_LTENR_NAS_ADD_HDR_INTO_PACKET(pevent.pPacket, hdr, nasHandoverRequestAck, LTENR_MSG_NAS_HANDOVER_REQUEST_ACK);
667 fnpAddEvent(&pevent);
668}
669void fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_REQUEST_ACK() {
670 ptrLTENR_HANDOVER_Hdr hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasHandoverRequestAck);
671 ptrLTENR_NAS_HANDOVER_REQUEST_ACK msg = calloc(1, sizeof * msg);
672 msg->GNB_UE_ID = hdr->serveringCellID;
673 msg->MME_UE_ID = hdr->AMFID;
674 hdr->msgType = LTENR_MSG_NAS_HANDOVER_REQUEST_ACK;
675 msg->outCome = HANDOVER_OUTCOME_SUCESSFUL;
676 hdr->msg = msg;
677 pstruEventDetails->pPacket->pstruMacData->dontFree = true;
678 fn_NetSim_NAS_ADD_PACKET_INTO_BUUFER(msg);
679}
680void fn_NetSim_LTENR_NAS_HANDOVER_REQUEST_ACK_RECV(ptrLTENR_HANDOVER_Hdr hdr) {
681 fn_NetSim_LTENR_NAS_HANDOVER_COMMAND(hdr);
682}
683#pragma endregion
684
685#pragma region Handover_Request
686void fn_NetSim_LTENR_NAS_HANDOVER_REQUEST(ptrLTENR_HANDOVER_Hdr hdr) {
687 NetSim_EVENTDETAILS pevent;
688 memset(&pevent, 0, sizeof pevent);
689 pevent.dEventTime = pstruEventDetails->dEventTime;
690 pevent.nDeviceId = hdr->serveringCellID;
691 pevent.nDeviceType = DEVICE_TYPE(hdr->serveringCellID);
692 pevent.nEventType = TIMER_EVENT;
693 pevent.nInterfaceId = hdr->serveringCellIF;
694 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(hdr->serveringCellID, hdr->serveringCellIF);
695 LTENR_SET_SUBEVENT(pd, &pevent, LTENR_SUBEVENT_GENERATE_HANDOVER_REQUEST);
696 pevent.pPacket = LTENR_PACKET_CREATE(hdr->serveringCellID, hdr->targetCellID, pstruEventDetails->dEventTime, LTENR_MSG_NAS_HANDOVER_REQUEST);
697 ptrLTENR_MSG msg = pevent.pPacket->pstruMacData->Packet_MACProtocol;
698 msg->logicalChannel = LTENR_LOGICALCHANNEL_CCCH;
699 msg->physicalChannel = LTENR_PHYSICALCHANNEL_PDCCH;
700 msg->transportChannel = LTENR_TRANSPORTCHANNEL_DL_SCH;
701 msg->rlcMode = LTENR_RLCMODE_TM;
702 fn_NetSIm_LTENR_NAS_ADD_HDR_INTO_PACKET(pevent.pPacket, hdr, nasHandoverRequest, LTENR_MSG_NAS_HANDOVER_REQUEST);
703 fnpAddEvent(&pevent);
704}
705void fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_REQUEST() {
706 ptrLTENR_HANDOVER_Hdr hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasHandoverRequest);
707 ptrLTENR_NAS_HANDOVER_REQUEST msg = calloc(1, sizeof * msg);
708 msg->MME_UE_ID = hdr->AMFID;
709 msg->type = HANDOVER_TYPE_INTRA_LTENR;
710 msg->cause = HANDOVER_CAUSE_RADIO_NETWORK;
711 msg->targetID = hdr->targetCellID;
712 msg->lastVisitedCellID = hdr->serveringCellID;
713 msg->LastVisitedCellType = CELL_TYPE_LARGE;
714 hdr->msg = msg;
715 hdr->msgType = LTENR_MSG_NAS_HANDOVER_REQUEST;
716 pstruEventDetails->pPacket->pstruMacData->dontFree = true;
717
718 fn_NetSim_NAS_ADD_PACKET_INTO_BUUFER(msg);
719}
720void fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_REQUEST_RECV(ptrLTENR_HANDOVER_Hdr hdr) {
721 fn_NetSim_LTENR_NAS_HANDOVER_REQUEST_ACK(hdr);
722}
723#pragma endregion
724
725#pragma region EPC_ROUTE
726void fn_NetSim_LTENR_EPC_RouteHOPacket() {
727 NetSim_EVENTDETAILS pevent;
728 NetSim_BUFFER* buffer;
729 NetSim_PACKET* packet = pstruEventDetails->pPacket;
730 ptrLTENR_EPC epc = LTENR_EPC_GET(pstruEventDetails->nDeviceId, pstruEventDetails->nInterfaceId);
731 memcpy(&pevent, pstruEventDetails, sizeof pevent);
732 if (epc)
733 {
734 NETSIM_ID gnbId = get_first_dest_from_packet(pevent.pPacket);
735 NETSIM_ID i;
736 NETSIM_ID j, k;
737 for (i = 0; i < NETWORK->ppstruDeviceList[pstruEventDetails->nDeviceId - 1]->nNumOfInterface; i++)
738 {
739 fn_NetSim_Stack_GetConnectedDevice(pstruEventDetails->nDeviceId, i + 1, &j, &k);
740 if (j == gnbId)
741 {
742 pevent.nInterfaceId = i + 1;
743 break;
744 }
745 }
746 }
747 buffer = DEVICE_ACCESSBUFFER(pevent.nDeviceId, pevent.nInterfaceId);
748
749 if (!fn_NetSim_GetBufferStatus(buffer))
750 {
751 //Add the MAC out event
752 pevent.nEventType = MAC_OUT_EVENT;
753 pevent.nPacketId = packet->nPacketId;
754 pevent.nProtocolId = fn_NetSim_Stack_GetMacProtocol(pstruEventDetails->nDeviceId, pstruEventDetails->nInterfaceId);
755 pevent.nSubEventType = 0;
756 pevent.pPacket = NULL;
757 pevent.szOtherDetails = NULL;
758 fnpAddEvent(&pevent);
759 }
760 packet->nTransmitterId = pevent.nDeviceId;
761 fn_NetSim_Packet_AddPacketToList(buffer, packet, 0);
762 pstruEventDetails->pPacket = NULL;
763}
764
765void fn_NetSim_LTENR_EPC_RoutePacket()
766{
767 NetSim_BUFFER* buffer;
768 NetSim_PACKET* packet = pstruEventDetails->pPacket;
769 //Add macout event
770 buffer = DEVICE_ACCESSBUFFER(pstruEventDetails->nDeviceId, pstruEventDetails->nInterfaceId);
771
772 if (!fn_NetSim_GetBufferStatus(buffer))
773 {
774 //Add the MAC out event
775 if (packet->pstruAppData)
776 {
777 pstruEventDetails->nApplicationId = packet->pstruAppData->nApplicationId;
778 pstruEventDetails->nSegmentId = packet->pstruAppData->nSegmentId;
779 }
780 pstruEventDetails->nEventType = MAC_OUT_EVENT;
781 pstruEventDetails->nPacketId = packet->nPacketId;
782 pstruEventDetails->nProtocolId = fn_NetSim_Stack_GetMacProtocol(pstruEventDetails->nDeviceId, pstruEventDetails->nInterfaceId);
783 pstruEventDetails->nSubEventType = 0;
784 pstruEventDetails->pPacket = NULL;
785 pstruEventDetails->szOtherDetails = NULL;
786 fnpAddEvent(pstruEventDetails);
787 }
788 fn_NetSim_Packet_AddPacketToList(buffer, packet, 0);
789}
790#pragma endregion
791
792#pragma region NAS_INIT
793void fn_NetSim_LTENR_NAS_Init() {
794 LTENR_SUBEVENT_REGISTER(LTENR_SUBEVENT_GENERATE_HANDOVER_REQUEST,
795 "LTENR_GENERATE_NAS_HANDOVER_REQUEST",
796 fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_REQUEST);
797 LTENR_SUBEVENT_REGISTER(LTENR_SUBEVENT_GENERATE_HANDOVER_REQUEST_ACK,
798 "HANDOVER_REQUEST_ACK",
799 fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_REQUEST_ACK);
800 LTENR_SUBEVENT_REGISTER(LTENR_SUBEVENT_GENERATE_HANDOVER_COMMAND,
801 "HANDOVER_REQUEST_COMMAND",
802 fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_COMMAND);
803 LTENR_SUBEVENT_REGISTER(LTENR_SUBEVENT_GENERATE_HANDOVER_COMMAND_HANDLE,
804 "HANDOVER_REQUEST_COMMAND_HANDLE",
805 fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_COMMAND_HANDLE);
806 LTENR_SUBEVENT_REGISTER(LTENR_SUBEVENT_GENERATE_PATH_SWITCH,
807 "PATH_SWITCH",
808 fn_NetSim_LTENR_NAS_GENERATE_PATH_SWITCH_REQUEST);
809 LTENR_SUBEVENT_REGISTER(LTENR_SUBEVENT_GENERATE_PATH_SWITCH_ACK,
810 "PATH_SWITCH_ACK",
811 fn_NetSim_LTENR_NAS_GENERATE_PATH_SWITCH_REQUEST_ACK);
812 LTENR_SUBEVENT_REGISTER(LTENR_SUBEVENT_GENERATE_UECONTEXTRELEASE,
813 "UE_CONTEXT_RELEASE",
814 fn_NetSim_LTENR_NAS_GENERATE_UE_CONTEXT_RELEASE);
815 LTENR_SUBEVENT_REGISTER(LTENR_SUBEVENT_GENERATE_UECONTEXTRELEASE_ACK,
816 "UE_CONTEXT_RELEASE_ACK",
817 fn_NetSim_LTENR_NAS_GENERATE_UE_CONTEXT_RELEASE_ACK);
818 LTENR_SUBEVENT_REGISTER(LTENR_SUBEVENT_GENERATE_HANDOVER_COMPLETE,
819 "HANDOVER_COMPLETE",
820 fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_COMPLETE);
821}
822#pragma endregion
823
824#pragma region NAS_IN
825void fn_NetSim_NAS_IN() {
826 NetSim_PACKET* packet = pstruEventDetails->pPacket;
827 ptrLTENR_HANDOVER_Hdr hdr = NULL;
828 switch (packet->nControlDataType) {
829 case LTENR_MSG_NAS_HANDOVER_REQUEST:
830 hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasHandoverRequest);
831 fn_NetSim_LTENR_NAS_GENERATE_HANDOVER_REQUEST_RECV(hdr);
832 //LTENR_HDR_FREE_FROM_PACKET(packet, nasHandoverRequest);
833 break;
834 case LTENR_MSG_NAS_HANDOVER_REQUEST_ACK:
835 hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasHandoverRequestAck);
836 fn_NetSim_LTENR_NAS_HANDOVER_REQUEST_ACK_RECV(hdr);
837 //LTENR_HDR_FREE_FROM_PACKET(packet, nasHandoverRequestAck);
838 break;
839 case LTENR_MSG_NAS_HANDOVER_COMMAND:
840 hdr = LTENR_NAS_HDR_GET(packet, nasHandoverTrigger);
841 fn_NetSim_LTENR_NAS_HANDOVER_COMMAND_RECV(hdr);
842 //LTENR_HDR_FREE_FROM_PACKET(packet, nasHandoverTrigger);
843 break;
844 case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH:
845 hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasPathSwitch);
846 fn_NetSim_LTENR_NAS_PATH_SWITCH_REQUEST_RECV(hdr);
847 //LTENR_HDR_FREE_FROM_PACKET(packet, nasPathSwitch);
848 break;
849 case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK:
850 hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, naspathSwitchAck);
851 fn_NetSim_LTENR_NAS_PATH_SWITCH_ACK_RECV(hdr);
852 //LTENR_HDR_FREE_FROM_PACKET(packet, naspathSwitchAck);
853 break;
854 case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE:
855 hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasUEContextRelease);
856 fn_NetSim_LTENR_NAS_UE_CONTEXT_RELEASE_RECV(hdr);
857 //LTENR_HDR_FREE_FROM_PACKET(packet, nasUEContextRelease);
858 break;
859 case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE_ACK:
860 hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasUEContextReleaseACK);
861 fn_NetSim_LTENR_NAS_UE_CONTEXT_RELEASE_ACK_RECV(hdr);
862 //LTENR_HDR_FREE_FROM_PACKET(packet, nasUEContextReleaseACK);
863 break;
864 case LTENR_MSG_NAS_HANDOVER_COMPLETE:
865 hdr = LTENR_NAS_HDR_GET(pstruEventDetails->pPacket, nasHandoverComplete);
866 fn_NetSim_LTENR_NAS_HANDOVER_COMPLETE_RECV();
867 break;
868 default:
869 break;
870 }
871}
872#pragma endregion
873
874#pragma region NAS_HANDER
875void fn_NetSIm_LTENR_NAS_ADD_HDR_INTO_PACKET(NetSim_PACKET* packet, ptrLTENR_HANDOVER_Hdr hdr, UINT hdrID, LTENR_MSGTYPE type) {
876 LTENR_RRC_HDR_ADD_TO_PACKET(packet, hdr, hdrID, sizeof(hdr), type);
877}
878
879ptrLTENR_HANDOVER_Hdr LTENR_NAS_HDR_GET(NetSim_PACKET* packet, UINT hdrID)
880{
881 return (ptrLTENR_HANDOVER_Hdr)LTENR_HDR_GET_FROM_PACKET(packet, hdrID);
882}
883
884void LTENR_NAS_HDR_REMOVE(NetSim_PACKET* packet, UINT hdrID)
885{
886 LTENR_HDR_FREE_FROM_PACKET(packet, hdrID);
887}
888#pragma endregion
stru_LTENR_PDCPEntity::RX_REORD
UINT32 RX_REORD
Definition LTENR_PDCP.h:77
stru_LTENR_PDCPEntity::RX_DELIV
UINT32 RX_DELIV
Definition LTENR_PDCP.h:73
stru_LTENR_PDCPEntity::RX_NEXT
UINT32 RX_NEXT
Definition LTENR_PDCP.h:70
stru_LTENR_PDCPEntity::last_RECV_COUNT
UINT32 last_RECV_COUNT
Definition LTENR_PDCP.h:80