NetSim Source Code Help v14.4
All 13 Components
 
Loading...
Searching...
No Matches
IEEE802_11_MacFrame.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 * Author: Shashi Kant Suman *
12 * *
13 * ---------------------------------------------------------------------------------*/
14#include "main.h"
15#include "IEEE802_11.h"
16#include "IEEE802_11_MAC_Frame.h"
17#include "IEEE802_11_Phy.h"
18#include "NetSim_utility.h"
19
20static UINT get_fragment_number(NetSim_PACKET* packet);
21
22double getAckSize(PIEEE802_11_PHY_VAR phy)
23{
24 switch(phy->PhyProtocol)
25 {
26 case IEEE_802_11a:
27 case IEEE_802_11b:
28 case IEEE_802_11g:
29 case IEEE_802_11p:
30 return ACK_SIZE;
31 case IEEE_802_11n:
32 return BlockACK_SIZE_802_11n;
33 case IEEE_802_11ac:
34 return BlockACK_SIZE_802_11ac;
35 case IEEE_802_11ax:
36 return BlockACK_SIZE_802_11ax;
37 default:
38 fnNetSimError("Unknown phy protocol %d in %s.",phy->PhyProtocol,__FUNCTION__);
39 return 0;
40 }
41}
42
43double getCTSSize()
44{
45 return CTS_SIZE;
46}
47
48double getRTSSize()
49{
50 return RTS_SIZE;
51}
52
53double getMacOverhead(PIEEE802_11_PHY_VAR phy,double size)
54{
55 double overhead = 0;
56 if (phy->PhyProtocol == IEEE_802_11n || phy->PhyProtocol == IEEE_802_11ac || phy->PhyProtocol == IEEE_802_11ax) //HESUOFDM@IITM
57 {
58 overhead = MAC_OVERHEAD_802_11n;
59 //This is for the 4bytes of padding
60 overhead += (4 - ((int)size % 4)) % 4;
61 }
62 else
63 overhead = MAC_OVERHEAD;
64 return overhead;
65}
66
67static double get_block_ack_size(NETSIM_ID dev, NETSIM_ID ifid)
68{
69 switch (IEEE802_11_PHY(dev, ifid)->PhyProtocol)
70 {
71 case IEEE_802_11n: return BlockACK_SIZE_802_11n;
72 case IEEE_802_11ac: return BlockACK_SIZE_802_11ac;
73 case IEEE_802_11ax: return BlockACK_SIZE_802_11ax;
74 default: fnNetSimError("Unknown phy protocol %d in %s.", IEEE802_11_PHY(dev, ifid)->PhyProtocol, __FUNCTION__);
75 return 0;
76 }
77}
78
79static void ieee802_11_set_hdr(NETSIM_ID d, NETSIM_ID in, NetSim_PACKET* packet, UINT hdrType, void* hdr)
80{
81 ptrIEEE802_11_HDR h = calloc(1, sizeof * h);
82 h->hdr = hdr;
83 h->hdrType = hdrType;
84 h->sendInterfaceId = in;
85
86 PIEEE802_11_PHY_VAR phy = IEEE802_11_PHY(d, in);
87
88 packet->pstruMacData->dOverhead = getMacOverhead(phy, packet->pstruNetworkData->dPacketSize);
89
90 packet->pstruMacData->dPayload = packet->pstruNetworkData->dPacketSize;
91 packet->pstruMacData->dPacketSize = packet->pstruMacData->dPayload \
92 + packet->pstruMacData->dOverhead;
93 packet->pstruMacData->dEndTime = pstruEventDetails->dEventTime;
94
95 if (packet->pstruMacData->Packet_MACProtocol)
96 {
97 //Free old header
98 fn_NetSim_Packet_FreeMacProtocolData(packet);
99 }
100 packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_IEEE802_11;
101 packet->pstruMacData->Packet_MACProtocol = h;
102}
103
104void* ieee802_11_get_hdr(NetSim_PACKET* packet, UINT* type)
105{
106 ptrIEEE802_11_HDR hdr = packet->pstruMacData->Packet_MACProtocol;
107 *type = hdr->hdrType;
108 return hdr->hdr;
109}
110
111#pragma region FREE_HDR
112static void free_mpdu_header(PIEEE802_11_MAC_HEADER macHdr)
113{
114 free(macHdr);
115}
116
117static void free_ack_header(PIEEE802_11_ACK ack)
118{
119 free(ack);
120}
121
122static void free_blockack_header(PIEEE802_11_BLOCKACK back)
123{
124 free(back);
125}
126
127static void free_rts_header(PIEEE802_11_RTS rts)
128{
129 free(rts);
130}
131
132static void free_cts_header(PIEEE802_11_CTS cts)
133{
134 free(cts);
135}
136
137void ieee802_11_free_hdr(NetSim_PACKET* packet)
138{
139 ptrIEEE802_11_HDR hdr = packet->pstruMacData->Packet_MACProtocol;
140 if (!hdr) return;
141
142 switch (hdr->hdrType)
143 {
144 case WLAN_RTS:
145 free_rts_header(hdr->hdr);
146 break;
147 case WLAN_ACK:
148 free_ack_header(hdr->hdr);
149 break;
150 case WLAN_BlockACK:
151 free_blockack_header(hdr->hdr);
152 break;
153 case WLAN_CTS:
154 free_cts_header(hdr->hdr);
155 break;
156 default:
157 free_mpdu_header(hdr->hdr);
158 break;
159 }
160
161 free(hdr);
162 packet->pstruMacData->Packet_MACProtocol = NULL;
163}
164#pragma endregion
165
166#pragma region COPY_HDR
167static PIEEE802_11_RTS copy_rts_header(PIEEE802_11_RTS rts)
168{
169 PIEEE802_11_RTS r = calloc(1, sizeof * r);
170 memcpy(r, rts, sizeof * r);
171 return r;
172}
173
174static PIEEE802_11_CTS copy_cts_header(PIEEE802_11_CTS cts)
175{
176 PIEEE802_11_CTS c = calloc(1, sizeof * c);
177 memcpy(c, cts, sizeof * c);
178 return c;
179}
180
181static PIEEE802_11_ACK copy_ack_header(PIEEE802_11_ACK ack)
182{
183 PIEEE802_11_ACK a = calloc(1, sizeof * a);
184 memcpy(a, ack, sizeof * a);
185 return a;
186}
187
188static PIEEE802_11_BLOCKACK copy_blockack_header(PIEEE802_11_BLOCKACK back)
189{
190 PIEEE802_11_BLOCKACK b = calloc(1, sizeof * b);
191 memcpy(b, back, sizeof * b);
192 return b;
193}
194
195static PIEEE802_11_MAC_HEADER copy_mac_header(PIEEE802_11_MAC_HEADER hdr)
196{
197 PIEEE802_11_MAC_HEADER m = calloc(1, sizeof * m);
198 memcpy(m, hdr, sizeof * m);
199 return m;
200}
201
202void ieee802_11_hdr_copy(NetSim_PACKET* dest, NetSim_PACKET* src)
203{
204 ptrIEEE802_11_HDR shdr = src->pstruMacData->Packet_MACProtocol;
205 if (!shdr) return;
206
207 ptrIEEE802_11_HDR dhdr = calloc(1, sizeof * dhdr);
208 memcpy(dhdr, shdr, sizeof * dhdr);
209 dest->pstruMacData->Packet_MACProtocol = dhdr;
210
211 switch (shdr->hdrType)
212 {
213 case WLAN_RTS:
214 dhdr->hdr = copy_rts_header(shdr->hdr);
215 break;
216 case WLAN_ACK:
217 dhdr->hdr = copy_ack_header(shdr->hdr);
218 break;
219 case WLAN_BlockACK:
220 dhdr->hdr = copy_blockack_header(shdr->hdr);
221 break;
222 case WLAN_CTS:
223 dhdr->hdr = copy_cts_header(shdr->hdr);
224 break;
225 default:
226 dhdr->hdr = copy_mac_header(shdr->hdr);
227 break;
228 }
229}
230#pragma endregion
231
232void fn_NetSim_IEEE802_11_Add_MAC_Header(NETSIM_ID nDeviceId,NETSIM_ID nInterfaceId, NetSim_PACKET *pstruPacket,unsigned int seqNo)
233{
234 PIEEE802_11_PHY_VAR phy = IEEE802_11_PHY(nDeviceId,nInterfaceId);
235 PIEEE802_11_MAC_VAR mac = IEEE802_11_MAC(nDeviceId,nInterfaceId);
236
237 phy;
238
239 PIEEE802_11_MAC_HEADER hdr;
240 hdr = (PIEEE802_11_MAC_HEADER)calloc(1, sizeof *hdr);
241
242 hdr->FrameControl.ProtocolVerSion = 0;
243 hdr->FrameControl.Type = DATA;
244 hdr->FrameControl.SubType = QoS_Data;
245
246 if(mac->BSSType==INFRASTRUCTURE)
247 {
248 if(!MAC_COMPARE(mac->BSSId,DEVICE_HWADDRESS(nDeviceId,nInterfaceId)))
249 {
250 hdr->FrameControl.ToDS = 0;
251 hdr->FrameControl.FromDS = 1;
252 hdr->Address1=pstruPacket->pstruMacData->szDestMac;
253 hdr->Address2=mac->BSSId;
254 hdr->Address3=pstruPacket->pstruMacData->szSourceMac;
255 }
256 else
257 {
258 hdr->FrameControl.ToDS = 1;
259 hdr->FrameControl.FromDS = 0;
260 hdr->Address1=mac->BSSId;
261 hdr->Address2=pstruPacket->pstruMacData->szSourceMac;
262 hdr->Address3=pstruPacket->pstruMacData->szDestMac;
263 }
264 }
265 else if(mac->BSSType==MESH)
266 {
267 hdr->FrameControl.ToDS = 1;
268 hdr->FrameControl.FromDS = 1;
269 hdr->Address1=pstruPacket->pstruMacData->szDestMac;
270 hdr->Address2=pstruPacket->pstruMacData->szSourceMac;
271 hdr->Address3= pstruPacket->pstruMacData->szDestMac;
272 hdr->Address4= pstruPacket->pstruMacData->szSourceMac;
273 }
274 else
275 {
276 fnNetSimError("%d BSS Type is not implemented for IEEE802.11 protocol",mac->BSSType);
277 }
278
279 if(pstruPacket->pstruNextPacket)
280 hdr->FrameControl.MoreFragment = 1;
281 else
282 hdr->FrameControl.MoreFragment = 0;
283
284 if(mac->nRetryCount)
285 hdr->FrameControl.Retry = 1;
286 else
287 hdr->FrameControl.Retry = 0;
288
289 hdr->FrameControl.PowerManagement = 0;
290
291 hdr->FrameControl.MoreData = 0;
292
293 hdr->FrameControl.ProtectedFrame = 0;
294
295 hdr->FrameControl.Order = 0;
296
297 hdr->snDurationID = 0;
298
299 hdr->SequenceControl.SequenceNumber = seqNo;
300 hdr->SequenceControl.FragmentNumber = 0;
301
302 memset(&hdr->QOSControl,0,sizeof(hdr->QOSControl));
303
304 hdr->HTControl = 0;
305
306 ieee802_11_set_hdr(nDeviceId, nInterfaceId, pstruPacket, WLAN_DATA, hdr);
307}
308
309NetSim_PACKET* fn_NetSim_IEEE802_11_CreateAckPacket(NETSIM_ID nDeviceId,NETSIM_ID nInterfaceId,NetSim_PACKET* data,double time)
310{
311 ptrIEEE802_11_HDR dhdr = data->pstruMacData->Packet_MACProtocol;
312 PIEEE802_11_MAC_HEADER mhdr = dhdr->hdr;
313
314 NetSim_PACKET* packet;
315 PIEEE802_11_ACK ack;
316 PIEEE802_11_MAC_VAR mac=IEEE802_11_MAC(nDeviceId,nInterfaceId);
317
318 // Create ACK Frame
319 packet = fn_NetSim_Packet_CreatePacket(MAC_LAYER);
320 packet->nPacketType = PacketType_Control;
321 packet->nPacketPriority = Priority_High;
322 packet->nControlDataType = WLAN_ACK;
323 packet->nReceiverId = data->nTransmitterId;
324 packet->nTransmitterId=nDeviceId;
325 packet->nSourceId=nDeviceId;
326 add_dest_to_packet(packet, data->nTransmitterId);
327
328 ack = calloc(1, sizeof* ack);
329
330 ack->FrameControl.Type = CONTROL;
331 ack->FrameControl.SubType = ACK;
332 ack->RA = mhdr->Address2;
333
334 switch(mac->BSSType)
335 {
336 case INFRASTRUCTURE:
337 if(MAC_COMPARE(DEVICE_HWADDRESS(nDeviceId,nInterfaceId),mac->BSSId))
338 {
339 ack->FrameControl.FromDS = 0;// Data is to AP(infra = 0 and ToDS = 1)
340 ack->FrameControl.ToDS = 1;
341 }
342 else
343 {
344 ack->FrameControl.FromDS = 1;// Data from AP
345 ack->FrameControl.ToDS = 0;
346
347 }
348 break;
349 case INDEPENDENT:
350 ack->FrameControl.FromDS = 0;// Both 0 for IBSS
351 ack->FrameControl.ToDS = 0;
352 break;
353 default:
354 break;
355 }
356
357 ptrIEEE802_11_HDR hdr = calloc(1, sizeof * hdr);
358 hdr->hdr = ack;
359 hdr->hdrType = WLAN_ACK;
360 hdr->sendInterfaceId = nInterfaceId;
361 hdr->recvInterfaceId = dhdr->sendInterfaceId;
362
363 packet->pstruMacData->Packet_MACProtocol = hdr;
364 packet->pstruMacData->dArrivalTime = time;
365 packet->pstruMacData->dStartTime = time;
366 packet->pstruMacData->dEndTime = time;
367 packet->pstruMacData->dOverhead = ACK_SIZE;
368 packet->pstruMacData->dPacketSize = packet->pstruMacData->dOverhead;
369 packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_IEEE802_11;
370
371 return packet;
372}
373
374NetSim_PACKET* fn_NetSim_IEEE802_11_CreateBlockAckPacket(NETSIM_ID nDeviceId,NETSIM_ID nInterfaceId,NetSim_PACKET* data,double time)
375{
376 ptrIEEE802_11_HDR dhdr = data->pstruMacData->Packet_MACProtocol;
377 PIEEE802_11_MAC_HEADER mhdr = dhdr->hdr;
378
379 NetSim_PACKET* packet;
380 PIEEE802_11_BLOCKACK ack;
381 PIEEE802_11_MAC_VAR mac=IEEE802_11_MAC(nDeviceId,nInterfaceId);
382
383 // Create ACK Frame
384 packet = fn_NetSim_Packet_CreatePacket(MAC_LAYER);
385 packet->nPacketType = PacketType_Control;
386 packet->nPacketPriority = Priority_High;
387 packet->nControlDataType = WLAN_BlockACK;
388 packet->nReceiverId = data->nTransmitterId;
389 packet->nTransmitterId=nDeviceId;
390 packet->nSourceId=nDeviceId;
391 add_dest_to_packet(packet, data->nTransmitterId);
392
393 ack = (PIEEE802_11_BLOCKACK)calloc(1, sizeof* ack);
394
395 ack->FrameControl.Type = CONTROL;
396 ack->FrameControl.SubType = BlockAck;
397 ack->RA = mhdr->Address2;
398 ack->TA = MAC_COPY(DEVICE_HWADDRESS(nDeviceId,nInterfaceId));
399
400 ack->BARControl.compressedBitmap=1;
401 ack->BAStartingSequenceControl.StartingSequenceNumber=get_fragment_number(data);
402
403 switch(mac->BSSType)
404 {
405 case INFRASTRUCTURE:
406 if(MAC_COMPARE(DEVICE_HWADDRESS(nDeviceId,nInterfaceId),mac->BSSId))
407 {
408 ack->FrameControl.FromDS = 0;// Data is to AP(infra = 0 and ToDS = 1)
409 ack->FrameControl.ToDS = 1;
410 }
411 else
412 {
413 ack->FrameControl.FromDS = 1;// Data from AP
414 ack->FrameControl.ToDS = 0;
415
416 }
417 break;
418 case INDEPENDENT:
419 ack->FrameControl.FromDS = 0;// Both 0 for IBSS
420 ack->FrameControl.ToDS = 0;
421 break;
422 default:
423 break;
424 }
425
426 ptrIEEE802_11_HDR hdr = calloc(1, sizeof * hdr);
427 hdr->hdr = ack;
428 hdr->hdrType = WLAN_BlockACK;
429 hdr->sendInterfaceId = nInterfaceId;
430 hdr->recvInterfaceId = dhdr->sendInterfaceId;
431
432 packet->pstruMacData->Packet_MACProtocol = hdr;
433 packet->pstruMacData->dArrivalTime = time;
434 packet->pstruMacData->dStartTime = time;
435 packet->pstruMacData->dEndTime = time;
436 packet->pstruMacData->dOverhead = get_block_ack_size(nDeviceId,nInterfaceId);;
437 packet->pstruMacData->dPacketSize = packet->pstruMacData->dOverhead;
438 packet->pstruMacData->nMACProtocol = MAC_PROTOCOL_IEEE802_11;
439
440 return packet;
441}
442
443bool isIEEE802_11_CtrlPacket(NetSim_PACKET* packet)
444{
445 if (packet)
446 return (packet->nControlDataType / 100 == MAC_PROTOCOL_IEEE802_11);
447 else
448 return false;
449}
450
451void fn_NetSim_Process_CtrlPacket()
452{
453 NetSim_PACKET* packet = pstruEventDetails->pPacket;
454 switch(packet->nControlDataType)
455 {
456 case WLAN_ACK:
457 fn_NetSim_IEEE802_11_CSMACA_ProcessAck();
458 break;
459 case WLAN_RTS:
460 fn_NetSim_IEEE802_11_RTS_CTS_ProcessRTS();
461 break;
462 case WLAN_CTS:
463 fn_NetSim_IEEE802_11_RTS_CTS_ProcessCTS();
464 break;
465 case WLAN_BlockACK:
466 fn_NetSim_IEEE802_11_CSMACA_ProcessBlockAck();
467 break;
468 default:
469 fnNetSimError("Unknown ctrl packet %d is %s\n",packet->nControlDataType,__FUNCTION__);
470 break;
471 }
472}
473
474NetSim_PACKET* fn_NetSim_IEEE802_11_CreateRTSPacket(NetSim_PACKET* data, double duration)
475{
476 NETSIM_ID d = pstruEventDetails->nDeviceId;
477 NETSIM_ID in = pstruEventDetails->nInterfaceId;
478
479 PIEEE802_11_MAC_VAR mac=IEEE802_11_CURR_MAC;
480 NetSim_PACKET* packet=fn_NetSim_Packet_CreatePacket(MAC_LAYER);
481 PIEEE802_11_RTS rts=(PIEEE802_11_RTS)calloc(1,sizeof* rts);
482 NETSIM_ID linkid = DEVICE_PHYLAYER(pstruEventDetails->nDeviceId,pstruEventDetails->nInterfaceId)->nLinkId;
483
484 packet->dEventTime=pstruEventDetails->dEventTime;
485 packet->nControlDataType=WLAN_RTS;
486 add_dest_to_packet(packet, data->nReceiverId);
487 packet->nPacketType=PacketType_Control;
488 packet->nReceiverId=data->nReceiverId;
489 packet->nSourceId=data->nTransmitterId;
490 packet->nTransmitterId=data->nTransmitterId;
491 packet->pstruMacData->dArrivalTime=pstruEventDetails->dEventTime;
492 packet->pstruMacData->dEndTime=pstruEventDetails->dEventTime;
493 packet->pstruMacData->dOverhead=RTS_SIZE;
494 packet->pstruMacData->dPacketSize=RTS_SIZE;
495 packet->pstruMacData->dStartTime=pstruEventDetails->dEventTime;
496 packet->pstruMacData->nMACProtocol=MAC_PROTOCOL_IEEE802_11;
497 packet->pstruMacData->szDestMac=MAC_COPY(data->pstruMacData->szNextHopMac);
498 packet->pstruMacData->szNextHopMac=MAC_COPY(data->pstruMacData->szNextHopMac);
499 packet->pstruMacData->szSourceMac=MAC_COPY(data->pstruMacData->szSourceMac);
500
501 ptrIEEE802_11_HDR hdr = calloc(1, sizeof * hdr);
502 hdr->hdr = rts;
503 hdr->hdrType = WLAN_RTS;
504 hdr->sendInterfaceId = in;
505 hdr->recvInterfaceId = fn_NetSim_Stack_GetConnectedInterface(d, in, data->nReceiverId);
506 packet->pstruMacData->Packet_MACProtocol=hdr;
507
508 rts->FrameControl.Type=CONTROL;
509 rts->FrameControl.SubType=RTS;
510 rts->Duration = (UINT16)duration;
511 rts->TA=MAC_COPY(DEVICE_HWADDRESS(packet->nTransmitterId,
512 fn_NetSim_Stack_GetWirelessInterface(linkid,packet->nTransmitterId)));
513
514 rts->RA=MAC_COPY(DEVICE_HWADDRESS(packet->nReceiverId,
515 fn_NetSim_Stack_GetWirelessInterface(linkid,packet->nReceiverId)));
516
517 switch(mac->BSSType)
518 {
519 case INFRASTRUCTURE:
520 if(MAC_COMPARE(DEVICE_HWADDRESS(pstruEventDetails->nDeviceId,pstruEventDetails->nInterfaceId),mac->BSSId))
521 {
522 rts->FrameControl.FromDS = 0;// Data is to AP(infra = 0 and ToDS = 1)
523 rts->FrameControl.ToDS = 1;
524 }
525 else
526 {
527 rts->FrameControl.FromDS = 1;// Data from AP
528 rts->FrameControl.ToDS = 0;
529
530 }
531 break;
532 case INDEPENDENT:
533 rts->FrameControl.FromDS = 0;// Both 0 for IBSS
534 rts->FrameControl.ToDS = 0;
535 break;
536 default:
537 break;
538 }
539
540 return packet;
541}
542
543NetSim_PACKET* fn_NetSim_IEEE802_11_CreateCTSPacket(NetSim_PACKET* data)
544{
545 NETSIM_ID d = pstruEventDetails->nDeviceId;
546 NETSIM_ID in = pstruEventDetails->nInterfaceId;
547 d;
548
549 ptrIEEE802_11_HDR dhdr = data->pstruMacData->Packet_MACProtocol;
550
551 PIEEE802_11_MAC_VAR mac=IEEE802_11_CURR_MAC;
552 NetSim_PACKET* packet=fn_NetSim_Packet_CreatePacket(MAC_LAYER);
553 PIEEE802_11_CTS cts=(PIEEE802_11_CTS)calloc(1,sizeof* cts);
554 PIEEE802_11_RTS rts = dhdr->hdr;
555
556 packet->dEventTime=pstruEventDetails->dEventTime;
557 packet->nControlDataType=WLAN_CTS;
558 add_dest_to_packet(packet, data->nTransmitterId);
559 packet->nPacketType=PacketType_Control;
560 packet->nReceiverId=data->nTransmitterId;
561 packet->nSourceId=data->nReceiverId;
562 packet->nTransmitterId=data->nReceiverId;
563 packet->pstruMacData->dArrivalTime=pstruEventDetails->dEventTime;
564 packet->pstruMacData->dEndTime=pstruEventDetails->dEventTime;
565 packet->pstruMacData->dOverhead=CTS_SIZE;
566 packet->pstruMacData->dPacketSize=CTS_SIZE;
567 packet->pstruMacData->dStartTime=pstruEventDetails->dEventTime;
568 packet->pstruMacData->nMACProtocol=MAC_PROTOCOL_IEEE802_11;
569 packet->pstruMacData->szDestMac=MAC_COPY(data->pstruMacData->szSourceMac);
570 packet->pstruMacData->szNextHopMac=MAC_COPY(data->pstruMacData->szSourceMac);
571 packet->pstruMacData->szSourceMac=MAC_COPY(data->pstruMacData->szDestMac);
572
573 ptrIEEE802_11_HDR hdr = calloc(1, sizeof * hdr);
574 hdr->hdr = cts;
575 hdr->hdrType = WLAN_CTS;
576 hdr->sendInterfaceId = in;
577 hdr->recvInterfaceId = dhdr->sendInterfaceId;
578 packet->pstruMacData->Packet_MACProtocol = hdr;
579
580 cts->FrameControl.Type=CONTROL;
581 cts->FrameControl.SubType=CTS;
582 cts->Duration = (UINT16)calculate_CTS_duration(pstruEventDetails->nDeviceId,
583 pstruEventDetails->nInterfaceId,
584 rts->Duration);
585
586 cts->RA=MAC_COPY(rts->TA);
587
588 switch(mac->BSSType)
589 {
590 case INFRASTRUCTURE:
591 if(MAC_COMPARE(DEVICE_HWADDRESS(pstruEventDetails->nDeviceId,pstruEventDetails->nInterfaceId),mac->BSSId))
592 {
593 rts->FrameControl.FromDS = 1;// Data is to AP(infra = 0 and ToDS = 1)
594 rts->FrameControl.ToDS = 0;
595 }
596 else
597 {
598 rts->FrameControl.FromDS = 0;// Data from AP
599 rts->FrameControl.ToDS = 1;
600
601 }
602 break;
603 case INDEPENDENT:
604 rts->FrameControl.FromDS = 0;// Both 0 for IBSS
605 rts->FrameControl.ToDS = 0;
606 break;
607 default:
608 break;
609 }
610
611 return packet;
612}
613
614void set_blockack_bitmap(NetSim_PACKET* ackPacket,NetSim_PACKET* packet)
615{
616 ptrIEEE802_11_HDR hdr = ackPacket->pstruMacData->Packet_MACProtocol;
617 PIEEE802_11_BLOCKACK back = hdr->hdr;
618 UINT i=get_fragment_number(packet);
619 SET_BIT_64(back->BitMap,i-1);
620}
621
622bool is_more_fragment_coming(NetSim_PACKET* packet)
623{
624 ptrIEEE802_11_HDR hdr = packet->pstruMacData->Packet_MACProtocol;
625 PIEEE802_11_MAC_HEADER mhdr = hdr->hdr;
626 return (bool)mhdr->FrameControl.MoreFragment;
627}
628
629bool is_first_packet(NetSim_PACKET* packet)
630{
631 ptrIEEE802_11_HDR hdr = packet->pstruMacData->Packet_MACProtocol;
632 PIEEE802_11_MAC_HEADER mhdr = hdr->hdr;
633 return mhdr->SequenceControl.SequenceNumber==1;
634}
635
636static UINT get_fragment_number(NetSim_PACKET* packet)
637{
638 ptrIEEE802_11_HDR hdr = packet->pstruMacData->Packet_MACProtocol;
639 PIEEE802_11_MAC_HEADER mhdr = hdr->hdr;
640 return mhdr->SequenceControl.SequenceNumber;
641}
642
643NETSIM_ID get_send_interface_id(NetSim_PACKET* packet)
644{
645 ptrIEEE802_11_HDR hdr = packet->pstruMacData->Packet_MACProtocol;
646 if (hdr)
647 return hdr->sendInterfaceId;
648 else
649 return 0;
650}
651
652NETSIM_ID get_recv_interface_id(NetSim_PACKET* packet)
653{
654 ptrIEEE802_11_HDR hdr = packet->pstruMacData->Packet_MACProtocol;
655 if (hdr)
656 return hdr->recvInterfaceId;
657 else
658 return 0;
659}