NetSim Source Code Help v14.4
All 13 Components
 
Loading...
Searching...
No Matches
LTE_NR.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: Shashi Kant Suman *
22* *
23* ----------------------------------------------------------------------------------*/
24
25#pragma region HEADER_FILES
26#include "stdafx.h"
27#include "LTENR_SDAP.h"
28#include "LTENR_NSA.h"
29#include "LTENR_Multiplexing.h"
30#include "LTENR_NetworkSlicing.h"
31#include "NTN.h"
32#pragma endregion
33
34#pragma region VARIABLE_AND_FUN_DEF
35static bool isLTENRConfigured = false;
36static bool isLTENRTraceConfigured = false;
37static bool isCalledOnce = false;
38static bool isMetricsCalled = false;
39//Function prototype
40int fn_NetSim_LTE_NR_Init_F();
41int fn_NetSim_LTE_NR_Configure_F(void** var);
42int fn_NetSim_LTE_NR_Finish_F();
43#pragma endregion
44
45#pragma region LTENR_INIT
46_declspec(dllexport) int fn_NetSim_LTE_NR_Init()
47{
48 if (!isCalledOnce)
49 {
50 if (isNTNScenario())
51 {
52 fn_NetSim_NTN_InitAssociation();
53 initNTN_UeAssociationLogs();
54 initNTNRadioMeasurementLogs();
55 }
56
57 LTENR_fn_InterferenceInit();
58 fn_NetSim_LTENR_HARQ_Init();
59 LTENR_RadioMeasurements_Init();
60 fn_NetSim_LTE_MAC_PRBLOG();
61 fn_NetSim_LTE_HandoverLOG();
62 if(nws->isSlicing)
63 LTENR_ConfigureNETWORK_SLICINGConfig();
64 init_PRBUtilization();
65 isCalledOnce = true;
66 }
67 return fn_NetSim_LTE_NR_Init_F();
68}
69#pragma endregion
70
71#pragma region LTENR_RUN
72_declspec(dllexport) int fn_NetSim_LTE_NR_Run()
73{
74 //test_olla(7, 4, 8, 1);
75 if (pstruEventDetails->nSubEventType)
76 {
77 LTENR_SUBEVENT_CALL();
78 return 0;
79 }
80
81 switch (pstruEventDetails->nEventType)
82 {
83 case APPLICATION_IN_EVENT:
84 {
85 NetSim_PACKET* packet = pstruEventDetails->pPacket;
86 switch (packet->nControlDataType)
87 {
88 case LTENR_MSG_CORE_INITIAL_UE_MESSAGE:
89 case LTENR_MSG_CORE_CREATE_SESSION_RESPONSE:
90 case LTENR_MSG_CORE_INITIAL_CONTEXT_SETUP_RESPONSE:
91 case LTENR_MSG_CORE_REGISTRATION_COMPLETE:
92 case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH:
93 case LTENR_MSG_CORE_MODIFY_BEARER_RESPONSE:
94 fn_NetSim_LTENR_AMF_PACKET_HANDLER();
95 break;
96 case LTENR_MSG_CORE_CREATE_SESSION_REQUEST:
97 case LTENR_MSG_CORE_PFCP_SESSION_REQUSET:
98 case LTENR_MSG_CORE_PFCP_SESSION_RESPONSE:
99 case LTENR_MSG_CORE_MODIFY_BEARER_REQUEST:
100 fn_NetSim_LTENR_SMF_UPF_PACKET_HANDLER();
101 break;
102 case LTENR_MSG_CORE_INITIAL_CONTEXT_SETUP_REQUEST:
103 case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK:
104 fn_NetSim_LTENR_GNB_CORE_PACKET_HANDLER();
105 break;
106 }
107 }
108 break;
109 case NETWORK_OUT_EVENT:
110 {
111 NETSIM_ID d = pstruEventDetails->nDeviceId;
112 NETSIM_ID in = pstruEventDetails->nInterfaceId;
113 ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(d, in);
114 if (data->deviceType == LTENR_DEVICETYPE_EPC) {
115 LTENR_CallEPCOut();
116 break;
117 }
118
119 NetSim_PACKET* packet = pstruEventDetails->pPacket;
120 NETSIM_ID dest = get_first_dest_from_packet(packet);
121
122 if (isGNB(d, in))
123 {
124 if (data->IFType == nGC_INTERFACE_XN)
125 {
126 gNB_N3_Forward_packet_to_MAC(d, in, packet);
127 pstruEventDetails->pPacket = NULL;
128 break;
129 }
130 }
131
132 if (dest == d) break;
133
134 if (isGNB(d, in))
135 {
136 if (data->IFType == nGC_INTERFACE_N3 || data->IFType == nGC_INTERFACE_LTE_S1)
137 {
138 gNB_N3_Forward_packet_to_MAC(d, in, packet);
139 pstruEventDetails->pPacket = NULL;
140 break;
141 }
142 }
143
144 if (isUPF(d)) {
145 if (data->isDCEnable && fn_NetSim_LTENR_NSA_IS_CORE_SPLIT_EXISTS(d, in)) {
146 NETSIM_ID splitID = fn_NetSim_LTENR_NSA_Splitting_Alogrithm_For_EPC(dest);
147
148 if (!splitID)
149 {
150 //Drop the Packet
151 packet->nPacketStatus = PacketStatus_Buffer_Dropped;
152 packet->nReceiverId = get_first_dest_from_packet(packet);
153 fn_NetSim_WritePacketTrace(packet);
154 fn_NetSim_Packet_FreePacket(packet);
155 pstruEventDetails->pPacket = NULL;
156 break;
157 }
158
159 NETSIM_ID splitIF = fn_NetSim_LTENR_CORE_INTERFACE(splitID, nGC_INTERFACE_N3);
160 packet->pstruNetworkData->szNextHopIp = IP_COPY(DEVICE_NWADDRESS(splitID, splitIF));
161 packet->nReceiverId = splitID;
162 }
163 gNB_N3_Forward_packet_to_MAC(d, in, packet);
164 pstruEventDetails->pPacket = NULL;
165 break;
166 }
167 }
168 break;
169 case NETWORK_IN_EVENT:
170 {
171 NETSIM_ID d = pstruEventDetails->nDeviceId;
172 NETSIM_ID in = pstruEventDetails->nInterfaceId;
173 NetSim_PACKET* packet = pstruEventDetails->pPacket;
174
175 if (isLTENRControlPacket(packet) == false &&
176 !fn_NetSim_LTENR_NSA_IS_CORE_SPLIT_EXISTS(d, in))
177 {
178 ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(d, in);
179 if (data->IFType == nGC_INTERFACE_XN && isGNB(d,in))
180 {
181 ptrLTENR_XN_HDR hdr = packet->pstruNetworkData->Packet_NetworkProtocol;
182 if (hdr->flag)
183 {
184 packet->pstruNetworkData->Packet_NetworkProtocol = NULL;
185 packet->pstruMacData->Packet_MACProtocol = hdr->msg;
186 NETSIM_ID RANIF = fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d);
187 packet->nTransmitterId = d;
188 packet->nReceiverId = hdr->UEID;
189 if (fn_NetSim_isDeviceLTENR(d, in))
190 packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_LTE_NR;
191 else
192 packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_LTE;
193 packet->pstruNetworkData->szGatewayIP = STR_TO_IP4(hdr->gateway);
194 packet->pstruNetworkData->szNextHopIp = IP_COPY(DEVICE_NWADDRESS(hdr->UEID, hdr->UEIF));
195 LTENR_NSA_XN_INTERFACE_TO_RAN(d, RANIF, packet);
196 }
197 else
198 {
199 NETSIM_ID RANIF;
200 if (fn_NetSim_LTENR_IS_S1_INTERFACE_EXISTS(d))
201 {
202 RANIF = fn_NetSim_LTENR_CORE_INTERFACE(d, nGC_INTERFACE_LTE_S1);
203 NETSIM_ID r, rin;
204 fn_NetSim_Stack_GetConnectedDevice(d, RANIF, &r, &rin);
205 packet->pstruNetworkData->szGatewayIP = IP_COPY(DEVICE_NWADDRESS(hdr->UEID, hdr->UEIF));
206 packet->pstruNetworkData->szNextHopIp = IP_COPY(DEVICE_NWADDRESS(r, rin));
207 packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_LTE;
208 }
209 else
210 {
211 RANIF = fn_NetSim_LTENR_CORE_INTERFACE(d, nGC_INTERFACE_N3);
212 if (packet->pstruMacData->Packet_MACProtocol != NULL)
213 fn_NetSim_Packet_FreeMacProtocolData(packet);
214 packet->pstruMacData->nMACProtocol = DEVICE_MACPROTOCOL(d, RANIF);
215
216 ptrLTENR_PROTODATA pd = LTENR_PROTODATA_GET(d,
217 fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d));
218 packet->pstruNetworkData->szGatewayIP = IP_COPY(DEVICE_NWADDRESS(d, in));
219 NETSIM_ID r = fn_NetSim_Stack_GetDeviceId_asName(pd->connectedUPFName);
220 NETSIM_ID rin = fn_NetSim_LTENR_CORE_INTERFACE(r, nGC_INTERFACE_N3);
221 packet->pstruNetworkData->szNextHopIp = IP_COPY(DEVICE_NWADDRESS(r, rin));
222 }
223 gNB_N3_Forward_packet_to_MAC(d, RANIF, packet);
224 }
225 free(hdr);
226 pstruEventDetails->pPacket = NULL;
227 break;
228 }
229 }
230
231 if (isGNB(d, in))
232 {
233 ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(d, in);
234 if (data->IFType == nGC_INTERFACE_N3 && isLTENRControlPacket(packet) == false)
235 {
236 NETSIM_ID RANIF = 0;
237 if (fn_NetSim_isDeviceLTENR(d, in))
238 RANIF = fn_NetSim_FIND_LTENR_INTERFACE(d);
239 else
240 RANIF = fn_NetSim_FIND_LTE_INTERFACE(d);
241 gNB_N3_Forward_packet_to_RAN(d, in, RANIF, packet);
242 pstruEventDetails->pPacket = NULL;
243 break;
244 }
245 if (data->IFType == nGC_INTERFACE_LTE_S1 && isLTENRControlPacket(packet) == false)
246 {
247 NETSIM_ID RANIF = fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d);
248 gNB_N3_Forward_packet_to_RAN(d, in, RANIF, packet);
249 pstruEventDetails->pPacket = NULL;
250 break;
251 }
252 }
253
254 switch (pstruEventDetails->pPacket->nControlDataType)
255 {
256 case LTENR_MSG_NAS_HANDOVER_REQUEST:
257 case LTENR_MSG_NAS_HANDOVER_REQUEST_ACK:
258 case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE:
259 case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE_ACK:
260 if (!isEPC(d,in)) {
261 ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(d, in);
262 if (data->IFType == nGC_INTERFACE_LTE_S1) {
263 NETSIM_ID RANIF = fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d);
264 fn_NetSim_LTENR_LTE_S1_CONTROL_PACKET_TO_RAN(d, RANIF, packet);
265 }
266 else {
267 fn_NetSim_LTENR_Handover_RECV();
268 }
269 pstruEventDetails->pPacket = NULL;
270 }
271 else
272 fn_NetSim_LTENR_EPC_RouteHOPacket();
273 break;
274 case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH:
275 case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK:
276 LTENR_CallNASIn();
277 pstruEventDetails->pPacket = NULL;
278 break;
279 case LTENR_MSG_DC_SEC_CELL_ADDITION_REQUEST:
280 case LTENR_MSG_DC_SEC_CELL_ADDITION_RESPONSE:
281 if (!isEPC(d,in)) {
282 fn_NetSim_LTENR_NSA_RECV();
283 pstruEventDetails->pPacket = NULL;
284 }
285 else
286 fn_NetSim_LTENR_EPC_RouteHOPacket();
287 break;
288 case LTENR_MSG_DC_HO_SEC_CELL_ADDITION_REQUEST:
289 case LTENR_MSG_DC_HO_SEC_CELL_ADDITION_REQUEST_ACK:
290 case LTENR_MSG_DC_HO_SEC_CELL_RELEASE_REQUEST:
291 case LTENR_MSG_DC_HO_SEC_CELL_RELEASE_REQUEST_ACK:
292 case LTENR_MSG_DC_HO_SEC_CELL_UE_CONTEXT_RELEASE:
293 case LTENR_MSG_DC_HO_SEC_CELL_UE_CONTEXT_RELEASE_ACK:
294 if (!isEPC(d, in)) {
295 fn_NetSim_SN_HANDOVER_PACKET_HANDLER();
296 pstruEventDetails->pPacket = NULL;
297 }
298 else
299 fn_NetSim_LTENR_EPC_RouteHOPacket();
300 break;
301 default:
302 {
303 if (isGNB(d, in)) {
304 NETSIM_ID RANIF = fn_NetSim_Get_LTENR_INTERFACE_ID_FROM_DEVICE_ID(d);
305 gNB_N3_Forward_packet_to_RAN(d, in, RANIF, packet);
306 pstruEventDetails->pPacket = NULL;
307 }
308 }
309 break;
310 }
311 }
312 break;
313 case MAC_OUT_EVENT:
314 {
315 bool isMore = true;
316 NetSim_BUFFER* buffer = DEVICE_ACCESSBUFFER(pstruEventDetails->nDeviceId,pstruEventDetails->nInterfaceId);
317 NetSim_PACKET* packet = fn_NetSim_Packet_GetPacketFromBuffer(buffer, 0);
318 switch (packet->nControlDataType)
319 {
320 case LTENR_MSG_NAS_HANDOVER_REQUEST:
321 case LTENR_MSG_NAS_HANDOVER_REQUEST_ACK:
322 case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH_ACK:
323 case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE:
324 case LTENR_MSG_NAS_HANDOVER_UE_CONTEXT_RELEASE_ACK:
325 packet = fn_NetSim_Packet_GetPacketFromBuffer(buffer, 1);
326 pstruEventDetails->pPacket = packet;
327 LTENR_CallNASIn();
328 break;
329 case LTENR_MSG_NAS_HANDOVER_PATH_SWITCH:
330 packet = fn_NetSim_Packet_GetPacketFromBuffer(buffer, 1);
331 break;
332 default:
333 while (isMore)
334 {
335 isMore = LTENR_GET_PACKET_FROM_ACCESS_BUFFER();
336 LTENR_CallSDAPOut();
337 }
338 break;
339 }
340 }
341 break;
342 case MAC_IN_EVENT:
343 LTENR_CallMACIn();
344 break;
345 case PHYSICAL_OUT_EVENT:
346 fn_NetSim_LTENR_HandlePhyOut();
347 break;
348 case PHYSICAL_IN_EVENT:
349 {
350 if (!isLTENRControlPacket(pstruEventDetails->pPacket))
351 {
352 fn_NetSim_Metrics_Add(pstruEventDetails->pPacket);
353 }
354
355 pstruEventDetails->nEventType = MAC_IN_EVENT;
356 fnpAddEvent(pstruEventDetails);
357 }
358 break;
359 default:
360 fnNetSimError("LTE-NR, Unknown event type %d.\n",
361 pstruEventDetails->nEventType);
362 break;
363 }
364 return 0;
365}
366#pragma endregion
367
368#pragma region LTENR_TRACE
369_declspec(dllexport) char* fn_NetSim_LTE_NR_Trace(NETSIM_ID id)
370{
371 return LTENR_SUBEVNET_NAME(id);
372}
373#pragma endregion
374
375#pragma region FREE_PACKET
376_declspec(dllexport) int fn_NetSim_LTE_NR_FreePacket(NetSim_PACKET* packet)
377{
378 LTENR_MSG_FREE(packet);
379 return 0;
380}
381#pragma endregion
382
383#pragma region COPY_PACKET
384_declspec(dllexport) int fn_NetSim_LTE_NR_CopyPacket(NetSim_PACKET* destPacket, const NetSim_PACKET* srcPacket)
385{
386 if (srcPacket->pstruMacData->nMACProtocol == MAC_PROTOCOL_LTE ||
387 srcPacket->pstruMacData->nMACProtocol == MAC_PROTOCOL_LTE_NR)
388 {
389 ptrLTENR_MSG smsg = srcPacket->pstruMacData->Packet_MACProtocol;
390 ptrLTENR_MSG dmsg = LTENR_MSG_COPY(srcPacket);
391 destPacket->pstruMacData->Packet_MACProtocol = dmsg;
392
393 }
394 if (srcPacket->pstruAppData) {
395 if (srcPacket->pstruAppData->nApplicationProtocol == MAC_PROTOCOL_LTE_NR) {
396 destPacket->pstruAppData->Packet_AppProtocol = LTENR_MSG_APP_COPY(srcPacket);
397 return 0;
398 }
399 }
400 return 0;
401}
402#pragma endregion
403
404#pragma region LTENR_MATRICS
405_declspec(dllexport) int fn_NetSim_LTE_NR_Metrics(PMETRICSWRITER file)
406{
407 if (!isMetricsCalled)
408 {
409 fn_NetSim_LTENR_Cell_Metrics_F(file);
410 //fn_NetSim_LTENR_SDAP_Metrics_F(file);
411 // return fn_NetSim_LTE_Metrics_F(file);
412 isMetricsCalled = true;
413 }
414 return 0;
415}
416#pragma endregion
417
418#pragma region LTENR_CONFIG
419_declspec(dllexport) int fn_NetSim_LTE_NR_Configure(void** var)
420{
421 isLTENRConfigured = true;
422 return fn_NetSim_LTE_NR_Configure_F(var);
423}
424#pragma endregion
425
426#pragma region CONFIG_PACKET_TRACE
427_declspec(dllexport) char* fn_NetSim_LTE_NR_ConfigPacketTrace(void* xmlNetSimNode)
428{
429 if (isLTENRConfigured)
430 {
431 string szStatus;
432 szStatus = fn_NetSim_xmlConfigPacketTraceField(xmlNetSimNode, "LTENR_PACKET_INFO");
433 if (!_stricmp(szStatus, "ENABLE"))
434 {
435 isLTENRTraceConfigured = true;
436 free(szStatus);
437 return "LTENR_PACKET_INFO,";
438 }
439 free(szStatus);
440 return "";
441 }
442 else
443 return "";
444}
445#pragma endregion
446
447#pragma region LTENR_FINISH
448#include "NetSim_utility.h"
449_declspec(dllexport) int fn_NetSim_LTE_NR_Finish()
450{
451 netsim_matlab_interface_close();
452 fn_NetSim_LTENR_HARQ_Finish();
453 LTENR_FreeBLERTable();
454 LTENR_RadioMeasurements_Finish();
455 close_ltenr_PRB_log();
456 close_ltenr_handover_log();
457 fn_NetSim_PRB_utilization_log_close();
458 return fn_NetSim_LTE_NR_Finish_F();
459}
460#pragma endregion
461
462#pragma region WRITE_PACKET_TRACE
463_declspec(dllexport) int fn_NetSim_LTE_NR_WritePacketTrace(NetSim_PACKET* pstruPacket, char** ppszTrace)
464{
465 if (!isLTENRTraceConfigured)
466 return -1;
467
468
469 char* s = calloc(2*BUFSIZ, sizeof * s);
470 *ppszTrace = s;
471
472 if (pstruPacket->pstruAppData) {
473 if (pstruPacket->pstruAppData->nApplicationProtocol == MAC_PROTOCOL_LTE_NR) {
474 LTENR_MSG_WriteTrace_APP(pstruPacket, s);
475 return 0;
476 }
477 }
478
479 if (pstruPacket->pstruMacData->nMACProtocol != MAC_PROTOCOL_LTE_NR &&
480 pstruPacket->pstruMacData->nMACProtocol != MAC_PROTOCOL_LTE)
481 {
482 strcpy(s, "N/A,");
483 return -2;
484 }
485
486 LTENR_MSG_WriteTrace(pstruPacket, s);
487 return 0;
488}
489#pragma endregion
490
491#pragma region LOG_TRIGGER_FUN
492bool get_ltenr_log_status()
493{
494#ifdef LTENR_LOG_DEV
495 return true;
496#else
497 return false;
498#endif
499}
500
501
502#pragma region SET_FAST_PERFORMANCE
503void set_fast_performance()
504{
505 for (NETSIM_ID i = 0; i < NETWORK->nDeviceCount; i++)
506 {
507 for (NETSIM_ID j = 0; j < DEVICE(i + 1)->nNumOfInterface; j++)
508 {
509 if (!isLTE_NRInterface(i + 1, j + 1)) continue;
510
511 ptrLTENR_SDAPVAR sdap = LTENR_SDAP_GET(i + 1, j + 1);
512 if(sdap) sdap->isSDAPDisabled = true;
513 }
514 }
515}
516#pragma endregion
517
518int LTENR_ConvertStrToEnumWithErrorMsg(const char** enumstr, const char* str, int length, char* name)
519{
520 int i;
521 for (i = 0; i < length; i++)
522 {
523 if (!_stricmp(enumstr[i], str))
524 return i;
525 }
526
527 fnNetSimError("Unknown value %s for %s. The value must be in following.\n",
528 str, name);
529 for (i = 0; i < length; i++)
530 fprintf(stderr, "\t%d. %s\n", i + 1, enumstr[i]);
531 fprintf(stderr, "\n");
532 return 0;
533}
534
535bool get_protocol_log_status(char* logname)
536{
537 FILE* fp;
538 char str[BUFSIZ];
539 char data[BUFSIZ];
540
541 sprintf(str, "%s/%s", pszIOPath, "ProtocolLogsConfig.txt");
542 fp = fopen(str, "r");
543 if (!fp)
544 return false;
545
546 sprintf(str, "%s=true", logname);
547
548 while (fgets(data, BUFSIZ, fp))
549 {
550 lskip(data);
551 if (!_strnicmp(data, str, strlen(str)))
552 {
553 fclose(fp);
554 return true;
555 }
556 }
557 fclose(fp);
558
559 return false;
560}
561
562#pragma region GBR_UE
563double LTENR_Configure_Rate_Guarantee_GBR_UEs_Config(NETSIM_ID UEId, bool isUplink)
564{
565 FILE* fp;
566 char* temp;
567 char data[BUFSIZ], input[BUFSIZ];
568 int line = 0;
569 int slCount = 0;
570 int slIndex = 0;
571 int* sdCount;
572 NETSIM_ID d;
573 double dl_mac_rg, ul_mac_rg;
574
575 sprintf(input, "%s%s%s", pszIOPath, pathSeperator, "ConfigSupport/UE_GBR_Config.csv");
576
577 fp = fopen(input, "r");
578 if (fp == NULL)
579 {
580 fnSystemError("Unable to open %s file", input);
581 perror(input);
582 return;
583 }
584 else
585 {
586 while (fgets(data, BUFSIZ, fp) != NULL)
587 {
588 line++;
589 temp = data;
590
591 if (*temp == '\n' || *temp == '#' || *temp == 0 || *temp == ',')
592 continue;
593
594 _strupr(temp);
595
596 size_t len = strlen(temp);
597 while (len > 0 && ((temp[len - 1] == '\n') || (temp[len - 1] == ','))) temp[--len] = '\0';
598
599 if (sscanf(data, "%d,%lf,%lf\"",
600 &d, &dl_mac_rg, &ul_mac_rg) == 3)
601 {
602 NETSIM_ID devId = fn_NetSim_GetDeviceIdByConfigId(d);
603 if (devId == UEId)
604 if (isUplink)
605 return ul_mac_rg;
606 else
607 return dl_mac_rg;
608 }
609 else
610 {
611 INVALIDINPUT:
612 fprintf(stderr, "Invalid input found in line %d.\n\"%s\"\n"
613 "Press any key to skip this line and continue simulation.\n", line, temp);
614 _getch();
615 }
616 }
617 }
618 if (fp)
619 fclose(fp);
620 return 0;
621}
622#pragma endregion