Outline ![]()
Files ![]()
loading...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** NetX Component */
/** */
/** Internet Protocol (IP) */
/** */
/**************************************************************************/
/**************************************************************************/
#define NX_SOURCE_CODE
/* Include necessary system files. */
#include "nx_api.h"
#include "nx_ip.h"
#include "nx_packet.h"
#ifndef NX_DISABLE_IPV4
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _nx_ip_driver_packet_send PORTABLE C */
/* 6.1 */
/* AUTHOR */
/* */
/* Yuxin Zhou, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function sends an IP packet to the appropriate link driver. */
/* */
/* INPUT */
/* */
/* ip_ptr Pointer to IP control block */
/* packet_ptr Pointer to packet to send */
/* destination_ip Destination IP address */
/* fragment Don't fragment bit */
/* next_hop_address Next Hop address */
/* */
/* OUTPUT */
/* */
/* None */
/* */
/* CALLS */
/* */
/* (_nx_arp_entry_allocate) ARP entry allocate service */
/* (_nx_arp_packet_send) Send an ARP packet */
/* _nx_ip_packet_deferred_receive Receive loopback packet */
/* _nx_packet_copy Copy packet to input packet */
/* _nx_packet_transmit_release Release transmit packet */
/* (nx_ip_fragment_processing) Fragment processing */
/* (ip_link_driver) User supplied link driver */
/* _nx_ip_packet_checksum_compute Compute checksum */
/* */
/* CALLED BY */
/* */
/* NetX Source Code */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 05-19-2020 Yuxin Zhou Initial Version 6.0 */
/* 09-30-2020 Yuxin Zhou Modified comment(s), */
/* resulting in version 6.1 */
/* */
/**************************************************************************/
VOID _nx_ip_driver_packet_send(NX_IP *ip_ptr, NX_PACKET *packet_ptr, ULONG destination_ip, ULONG fragment, ULONG next_hop_address)
{
TX_INTERRUPT_SAVE_AREA
NX_IP_DRIVER driver_request;
UINT index;
ULONG network_mask;
ULONG network;
UCHAR loopback = NX_FALSE;
NX_ARP *arp_ptr;
NX_PACKET *last_packet;
NX_PACKET *remove_packet;
NX_PACKET *packet_copy;
UINT queued_count;
/* Add debug information. */
NX_PACKET_DEBUG(__FILE__, __LINE__, packet_ptr);
/* Initialize the driver request. */
driver_request.nx_ip_driver_ptr = ip_ptr;
driver_request.nx_ip_driver_packet = packet_ptr;
driver_request.nx_ip_driver_interface = packet_ptr -> nx_packet_address.nx_packet_interface_ptr;
driver_request.nx_ip_driver_command = NX_LINK_PACKET_SEND;
/* Determine if physical mapping is needed by the link driver. */
if (packet_ptr -> nx_packet_address.nx_packet_interface_ptr -> nx_interface_address_mapping_needed)
{
/* Get the network and network mask.*/
network_mask = packet_ptr -> nx_packet_address.nx_packet_interface_ptr -> nx_interface_ip_network_mask;
network = packet_ptr -> nx_packet_address.nx_packet_interface_ptr -> nx_interface_ip_network;
/* Determine if an IP limited or directed broadcast is requested. */
if ((destination_ip == NX_IP_LIMITED_BROADCAST) ||
(((destination_ip & network_mask) == network) &&
((destination_ip & ~network_mask) == ~network_mask)))
{
/* Build the driver request. */
driver_request.nx_ip_driver_command = NX_LINK_PACKET_BROADCAST;
driver_request.nx_ip_driver_physical_address_msw = 0xFFFFUL;
driver_request.nx_ip_driver_physical_address_lsw = 0xFFFFFFFFUL;
}
/* Determine if we have a loopback address. */
else if (destination_ip == packet_ptr -> nx_packet_address.nx_packet_interface_ptr -> nx_interface_ip_address)
{
loopback = NX_TRUE;
driver_request.nx_ip_driver_interface = NX_NULL;
}
/* Determine if we have a class D multicast address. */
else if ((destination_ip & NX_IP_CLASS_D_MASK) == NX_IP_CLASS_D_TYPE)
{
/* Yes, we have a class D multicast address. Derive the physical mapping from
the class D address. */
/* Determine if the group address has been joined in this IP instance. */
index = 0;
while (index < NX_MAX_MULTICAST_GROUPS)
{
/* Determine if the destination address matches the requested address. */
if (ip_ptr -> nx_ipv4_multicast_entry[index].nx_ipv4_multicast_join_list == destination_ip)
{
/* Yes, break the loop! */
break;
}
/* Increment the join list index. */
index++;
}
/* Determine if the group was joined by this IP instance. */
if (index < NX_MAX_MULTICAST_GROUPS)
{
/* Determine if the group has loopback enabled. */
if (ip_ptr -> nx_ipv4_multicast_entry[index].nx_ipv4_multicast_loopback_enable)
{
loopback = NX_TRUE;
}
}
/* Build the driver request. Derive the physical mapping from
the class D address. */
driver_request.nx_ip_driver_physical_address_msw = NX_IP_MULTICAST_UPPER;
driver_request.nx_ip_driver_physical_address_lsw = NX_IP_MULTICAST_LOWER | (destination_ip & NX_IP_MULTICAST_MASK);
}
else
{
NX_PARAMETER_NOT_USED(fragment);
/* Look into the ARP Routing Table to derive the physical address. */
/* If we get here, the packet destination is a unicast address. */
destination_ip = next_hop_address;
/* Calculate the hash index for the destination IP address. */
index = (UINT)((destination_ip + (destination_ip >> 8)) & NX_ARP_TABLE_MASK);
/* Determine if there is an entry for this IP address. */
arp_ptr = ip_ptr -> nx_ip_arp_table[index];
/* Loop to look for an ARP match. */
while (arp_ptr)
{
/* Determine if this arp entry matches the destination IP address. */
if (arp_ptr -> nx_arp_ip_address == destination_ip)
{
/* Yes, we found a match. Get out of the loop! */
break;
}
/* Move to the next active ARP entry. */
arp_ptr = arp_ptr -> nx_arp_active_next;
/* Determine if we are at the end of the ARP list. */
if (arp_ptr == ip_ptr -> nx_ip_arp_table[index])
{
/* Clear the ARP pointer. */
arp_ptr = NX_NULL;
break;
}
}
/* Determine if we actually found a matching and effective ARP entry. */
if ((arp_ptr) && (arp_ptr -> nx_arp_physical_address_msw | arp_ptr -> nx_arp_physical_address_lsw))
{
/* Disable interrupts temporarily. */
TX_DISABLE
/* Yes, we have a physical mapping. Copy the physical address into the driver
request structure. */
driver_request.nx_ip_driver_physical_address_msw = arp_ptr -> nx_arp_physical_address_msw;
driver_request.nx_ip_driver_physical_address_lsw = arp_ptr -> nx_arp_physical_address_lsw;
/* Move this ARP entry to the head of the list. */
ip_ptr -> nx_ip_arp_table[index] = arp_ptr;
/* Restore interrupts. */
TX_RESTORE
}
else
{
/* Determine if fragmentation is needed before queue the packet on the ARP waiting queue. */
if (packet_ptr -> nx_packet_length > packet_ptr -> nx_packet_address.nx_packet_interface_ptr -> nx_interface_ip_mtu_size)
{
#ifndef NX_DISABLE_FRAGMENTATION
/* Check the DF bit flag. */
if ((ip_ptr -> nx_ip_fragment_processing == NX_NULL) || (fragment != NX_FRAGMENT_OKAY))
#endif
{
#ifndef NX_DISABLE_IP_INFO
/* Increment the IP send packets dropped count. */
ip_ptr -> nx_ip_send_packets_dropped++;
#endif
/* Just release the packet. */
_nx_packet_transmit_release(packet_ptr);
/* Return... nothing more can be done! */
return;
}
}
/* Determine if we actually found a matching ARP entry. */
if (arp_ptr)
{
/* Yes, we have an existing ARP mapping entry. */
/* Disable interrupts temporarily. */
TX_DISABLE
/* Ensure the current packet's queue next pointer to NULL. */
packet_ptr -> nx_packet_queue_next = NX_NULL;
/* Determine if the queue is empty. */
if (arp_ptr -> nx_arp_packets_waiting == NX_NULL)
{
/* Yes, we have an empty ARP packet queue. Simply place the
packet at the head of the list. */
arp_ptr -> nx_arp_packets_waiting = packet_ptr;
/* Add debug information. */
NX_PACKET_DEBUG(NX_PACKET_ARP_WAITING_QUEUE, __LINE__, packet_ptr);
/* Restore interrupts. */
TX_RESTORE
}
else
{
/* Determine how many packets are on the ARP entry's packet
queue and remember the last packet in the queue. We know
there is at least one on the queue and another that is
going to be queued. */
last_packet = arp_ptr -> nx_arp_packets_waiting;
queued_count = 1;
while (last_packet -> nx_packet_queue_next)
{
/* Increment the queued count. */
queued_count++;
/* Move to the next packet in the queue. */
last_packet = last_packet -> nx_packet_queue_next;
}
/* Add debug information. */
NX_PACKET_DEBUG(NX_PACKET_ARP_WAITING_QUEUE, __LINE__, packet_ptr);
/* Place the packet at the end of the list. */
last_packet -> nx_packet_queue_next = packet_ptr;
/* Default the remove packet pointer to NULL. */
remove_packet = NX_NULL;
/* Determine if the packets queued has exceeded the queue
depth. */
if (queued_count >= NX_ARP_MAX_QUEUE_DEPTH)
{
/* Save the packet pointer at the head of the list. */
remove_packet = arp_ptr -> nx_arp_packets_waiting;
/* Remove the packet from the ARP queue. */
arp_ptr -> nx_arp_packets_waiting = remove_packet -> nx_packet_queue_next;
/* Clear the remove packet queue next pointer. */
remove_packet -> nx_packet_queue_next = NX_NULL;
#ifndef NX_DISABLE_IP_INFO
/* Increment the IP transmit resource error count. */
ip_ptr -> nx_ip_transmit_resource_errors++;
/* Increment the IP send packets dropped count. */
ip_ptr -> nx_ip_send_packets_dropped++;
#endif
}
/* Restore interrupts. */
TX_RESTORE
/* Determine if there is a packet to remove. */
if (remove_packet)
{
/* Yes, the packet queue depth for this ARP entry was exceeded
so release the packet that was removed from the queue. */
_nx_packet_transmit_release(remove_packet);
}
}
}
else
{
/* No ARP entry was found. We need to allocate a new ARP entry, populate it, and
initiate an ARP request to get the specific physical mapping. */
/* Allocate a new ARP entry. */
if ((!ip_ptr -> nx_ip_arp_allocate) ||
((ip_ptr -> nx_ip_arp_allocate)(ip_ptr, &(ip_ptr -> nx_ip_arp_table[index]), NX_FALSE)))
{
/* Error, release the protection and the packet. */
#ifndef NX_DISABLE_IP_INFO
/* Increment the IP transmit resource error count. */
ip_ptr -> nx_ip_transmit_resource_errors++;
/* Increment the IP send packets dropped count. */
ip_ptr -> nx_ip_send_packets_dropped++;
#endif
/* Release the packet. */
_nx_packet_transmit_release(packet_ptr);
/* Just return! */
return;
}
/* Otherwise, setup a pointer to the new ARP entry. */
arp_ptr = (ip_ptr -> nx_ip_arp_table[index]) -> nx_arp_active_previous;
/* Setup the IP address and clear the physical mapping. */
arp_ptr -> nx_arp_ip_address = destination_ip;
arp_ptr -> nx_arp_physical_address_msw = 0;
arp_ptr -> nx_arp_physical_address_lsw = 0;
arp_ptr -> nx_arp_entry_next_update = NX_ARP_UPDATE_RATE;
arp_ptr -> nx_arp_retries = 0;
arp_ptr -> nx_arp_ip_interface = packet_ptr -> nx_packet_address.nx_packet_interface_ptr;
/* Ensure the queue next pointer is NULL for the packet before it
is placed on the ARP waiting queue. */
packet_ptr -> nx_packet_queue_next = NX_NULL;
/* Add debug information. */
NX_PACKET_DEBUG(NX_PACKET_ARP_WAITING_QUEUE, __LINE__, packet_ptr);
/* Queue the packet for output. */
arp_ptr -> nx_arp_packets_waiting = packet_ptr;
/* Call ARP send to send an ARP request. */
(ip_ptr -> nx_ip_arp_packet_send)(ip_ptr, destination_ip, packet_ptr -> nx_packet_address.nx_packet_interface_ptr);
}
/* Just return! */
return;
}
}
}
else
{
/* This IP instance does not require any IP-to-physical mapping. */
/* Determine if we have a loopback address. */
if ((((destination_ip >= NX_IP_LOOPBACK_FIRST) &&
(destination_ip <= NX_IP_LOOPBACK_LAST))) ||
(destination_ip == packet_ptr -> nx_packet_address.nx_packet_interface_ptr -> nx_interface_ip_address))
{
/* Yes, we have an internal loopback address. */
loopback = NX_TRUE;
driver_request.nx_ip_driver_interface = NX_NULL;
}
}
/* Check whether the packet should be loop back. */
if (loopback == NX_TRUE)
{
/* Copy the packet so it can be enqueued properly by the receive
processing. */
if (_nx_packet_copy(packet_ptr, &packet_copy, ip_ptr -> nx_ip_default_packet_pool, NX_NO_WAIT) == NX_SUCCESS)
{
#ifdef NX_ENABLE_INTERFACE_CAPABILITY
/* Compute checksum for upper layer protocol. */
/*lint --e{644} suppress variable might not be initialized, since "packet_copy" was initialized as long as return value is NX_SUCCESS. */
if (packet_copy -> nx_packet_interface_capability_flag)
{
_nx_ip_packet_checksum_compute(packet_copy);
}
#endif /* NX_ENABLE_INTERFACE_CAPABILITY */
#ifndef NX_DISABLE_IP_INFO
/* Increment the IP packet sent count. */
ip_ptr -> nx_ip_total_packets_sent++;
/* Increment the IP bytes sent count. */
ip_ptr -> nx_ip_total_bytes_sent += packet_ptr -> nx_packet_length - (ULONG)sizeof(NX_IPV4_HEADER);
#endif
#ifdef NX_IPSEC_ENABLE
/* Clear the ipsec sa pointer. */
packet_copy -> nx_packet_ipsec_sa_ptr = NX_NULL;
#endif /* NX_IPSEC_ENABLE */
/* Add debug information. */
/*lint --e{644} suppress variable might not be initialized, since "packet_copy" was initialized as long as return value is NX_SUCCESS. */
NX_PACKET_DEBUG(__FILE__, __LINE__, packet_copy);
/* Send the packet to this IP's receive processing like it came in from the
driver. */
_nx_ip_packet_deferred_receive(ip_ptr, packet_copy);
}
#ifndef NX_DISABLE_IP_INFO
else
{
/* Increment the IP send packets dropped count. */
ip_ptr -> nx_ip_send_packets_dropped++;
/* Increment the IP transmit resource error count. */
ip_ptr -> nx_ip_transmit_resource_errors++;
}
#endif
}
/* Check whether the packet should be sent through driver. */
if (driver_request.nx_ip_driver_interface)
{
/* Determine if fragmentation is needed. */
if (packet_ptr -> nx_packet_length > packet_ptr -> nx_packet_address.nx_packet_interface_ptr -> nx_interface_ip_mtu_size)
{
#ifndef NX_DISABLE_FRAGMENTATION
/* Check the DF bit flag. */
if ((ip_ptr -> nx_ip_fragment_processing) && (fragment != NX_DONT_FRAGMENT))
{
/* Fragmentation is needed, call the IP fragment processing routine. */
(ip_ptr -> nx_ip_fragment_processing)(&driver_request);
}
else
#endif /* NX_DISABLE_FRAGMENTATION */
{
#ifndef NX_DISABLE_IP_INFO
/* Increment the IP send packets dropped count. */
ip_ptr -> nx_ip_send_packets_dropped++;
#endif
/* Just release the packet. */
_nx_packet_transmit_release(packet_ptr);
}
/* In either case, this packet send is complete, just return. */
return;
}
#ifndef NX_DISABLE_IP_INFO
/* Increment the IP packet sent count. */
ip_ptr -> nx_ip_total_packets_sent++;
/* Increment the IP bytes sent count. */
ip_ptr -> nx_ip_total_bytes_sent += packet_ptr -> nx_packet_length - (ULONG)sizeof(NX_IPV4_HEADER);
#endif
/* If trace is enabled, insert this event into the trace buffer. */
NX_TRACE_IN_LINE_INSERT(NX_TRACE_INTERNAL_IO_DRIVER_PACKET_SEND, ip_ptr, packet_ptr, packet_ptr -> nx_packet_length, 0, NX_TRACE_INTERNAL_EVENTS, 0, 0);
/* Add debug information. */
NX_PACKET_DEBUG(__FILE__, __LINE__, packet_ptr);
/* Driver entry must not be NULL. */
NX_ASSERT(packet_ptr -> nx_packet_address.nx_packet_interface_ptr -> nx_interface_link_driver_entry != NX_NULL);
/* Broadcast packet. */
(packet_ptr -> nx_packet_address.nx_packet_interface_ptr -> nx_interface_link_driver_entry)(&driver_request);
}
else
{
/* Release the transmit packet. */
_nx_packet_transmit_release(packet_ptr);
}
}
#endif /* !NX_DISABLE_IPV4 */
Details ![]()
Show: from Types: Columns: ![]( "Show Project Names")
![]( "Show Locations")
![]( "Show Referring Symbols")
![]( "Show Scope")
This file uses the notable symbols shown below. Click anywhere in the file to view more details.