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
/**************************************************************************/
/* */
/* 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 "tx_thread.h"
#include "nx_ip.h"
#include "nx_icmp.h"
#include "nx_arp.h"
#ifdef FEATURE_NX_IPV6
#include "nx_nd_cache.h"
#endif /* FEATURE_NX_IPV6 */
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _nx_ip_delete PORTABLE C */
/* 6.1 */
/* AUTHOR */
/* */
/* Yuxin Zhou, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function deletes an Internet Protocol instance, including */
/* calling the associated driver with a link disable request. */
/* */
/* INPUT */
/* */
/* ip_ptr Pointer to IP control block */
/* */
/* OUTPUT */
/* */
/* status Completion status */
/* */
/* CALLS */
/* */
/* _nx_ip_delete_queue_clear Clear a packet queue */
/* _nx_ip_raw_packet_cleanup Cleanup raw packet suspension */
/* _nx_icmp_cleanup Cleanup for ICMP packets */
/* _nx_ip_fragment_disable Disable fragment processing */
/* tx_mutex_delete Delete IP protection mutex */
/* tx_mutex_get Get protection mutex */
/* tx_mutex_put Put protection mutex */
/* tx_thread_terminate Terminate IP helper thread */
/* tx_event_flags_delete Delete IP event flags */
/* tx_thread_delete Delete IP helper thread */
/* _tx_thread_system_preempt_check Check for preemption */
/* tx_timer_deactivate Deactivate IP-ARP timer */
/* tx_timer_delete Delete IP-ARP timer */
/* (ip_link_driver) User supplied link driver */
/* */
/* CALLED BY */
/* */
/* Application */
/* */
/* 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 */
/* */
/**************************************************************************/
UINT _nx_ip_delete(NX_IP *ip_ptr)
{
TX_INTERRUPT_SAVE_AREA
UINT i;
NX_IP_DRIVER driver_request;
NX_PACKET *raw_packet_head;
NX_PACKET *deferred_head;
NX_PACKET *icmp_queue_head;
NX_PACKET *tcp_queue_head;
#ifndef NX_DISABLE_IPV4
NX_PACKET *arp_queue_head;
NX_PACKET *rarp_queue_head;
NX_PACKET *igmp_queue_head;
#endif /* !NX_DISABLE_IPV4 */
/* If trace is enabled, insert this event into the trace buffer. */
NX_TRACE_IN_LINE_INSERT(NX_TRACE_IP_DELETE, ip_ptr, 0, 0, 0, NX_TRACE_IP_EVENTS, 0, 0);
/* Get mutex protection. */
tx_mutex_get(&(ip_ptr -> nx_ip_protection), TX_WAIT_FOREVER);
/* Determine if the IP instance has any sockets bound to it. */
if ((ip_ptr -> nx_ip_udp_created_sockets_count) || (ip_ptr -> nx_ip_tcp_created_sockets_count))
{
/* Still sockets bound to this IP instance. They must all be deleted prior
to deleting the IP instance. Release the mutex and return
an error code. */
tx_mutex_put(&(ip_ptr -> nx_ip_protection));
return(NX_SOCKETS_BOUND);
}
/* Call through every link driver to disable the link. */
for (i = 0; i < NX_MAX_PHYSICAL_INTERFACES; i++)
{
/* Skip the invalid entries. */
if (!(ip_ptr -> nx_ip_interface[i].nx_interface_valid))
{
continue;
}
driver_request.nx_ip_driver_ptr = ip_ptr;
driver_request.nx_ip_driver_command = NX_LINK_DISABLE;
driver_request.nx_ip_driver_interface = &(ip_ptr -> nx_ip_interface[i]);
/* If trace is enabled, insert this event into the trace buffer. */
NX_TRACE_IN_LINE_INSERT(NX_TRACE_INTERNAL_IO_DRIVER_LINK_DISABLE, ip_ptr, 0, 0, 0, NX_TRACE_INTERNAL_EVENTS, 0, 0);
/* Send the driver LINK DISABLE request. */
(ip_ptr -> nx_ip_interface[i].nx_interface_link_driver_entry)(&driver_request);
/* Call the link driver to uninitialize. */
driver_request.nx_ip_driver_ptr = ip_ptr;
driver_request.nx_ip_driver_command = NX_LINK_UNINITIALIZE;
/* If trace is enabled, insert this event into the trace buffer. */
NX_TRACE_IN_LINE_INSERT(NX_TRACE_INTERNAL_IO_DRIVER_UNINITIALIZE, ip_ptr, 0, 0, 0, NX_TRACE_INTERNAL_EVENTS, 0, 0);
/* Send the driver UNITIALIZE request. */
(ip_ptr -> nx_ip_interface[i].nx_interface_link_driver_entry)(&driver_request);
}
/* Disable interrupts. */
TX_DISABLE
/* Remove the IP instance from the created list. */
/* See if the IP instance is the only one on the list. */
if (ip_ptr == ip_ptr -> nx_ip_created_next)
{
/* Only created IP instance, just set the created list to NULL. */
_nx_ip_created_ptr = TX_NULL;
}
else
{
/* Otherwise, not the only created IP, link-up the neighbors. */
(ip_ptr -> nx_ip_created_next) -> nx_ip_created_previous =
ip_ptr -> nx_ip_created_previous;
(ip_ptr -> nx_ip_created_previous) -> nx_ip_created_next =
ip_ptr -> nx_ip_created_next;
/* See if we have to update the created list head pointer. */
if (_nx_ip_created_ptr == ip_ptr)
{
/* Yes, move the head pointer to the next link. */
_nx_ip_created_ptr = ip_ptr -> nx_ip_created_next;
}
}
/* Decrement the IP created counter. */
_nx_ip_created_count--;
/* Temporarily disable preemption. */
_tx_thread_preempt_disable++;
/* Release any raw packets queued up. */
raw_packet_head = ip_ptr -> nx_ip_raw_received_packet_head;
ip_ptr -> nx_ip_raw_received_packet_head = NX_NULL;
ip_ptr -> nx_ip_raw_received_packet_tail = NX_NULL;
ip_ptr -> nx_ip_raw_received_packet_count = 0;
/* Release all deferred IP packets. */
deferred_head = ip_ptr -> nx_ip_deferred_received_packet_head;
ip_ptr -> nx_ip_deferred_received_packet_head = NX_NULL;
ip_ptr -> nx_ip_deferred_received_packet_tail = NX_NULL;
/* Release all queued ICMP packets. */
icmp_queue_head = ip_ptr -> nx_ip_icmp_queue_head;
ip_ptr -> nx_ip_icmp_queue_head = NX_NULL;
#ifndef NX_DISABLE_IPV4
/* Release all queued IGMP packets. */
igmp_queue_head = ip_ptr -> nx_ip_igmp_queue_head;
ip_ptr -> nx_ip_igmp_queue_head = NX_NULL;
/* Release all queued ARP packets. */
arp_queue_head = ip_ptr -> nx_ip_arp_deferred_received_packet_head;
ip_ptr -> nx_ip_arp_deferred_received_packet_head = NX_NULL;
ip_ptr -> nx_ip_arp_deferred_received_packet_tail = NX_NULL;
/* Release all queued RARP packets. */
rarp_queue_head = ip_ptr -> nx_ip_rarp_deferred_received_packet_head;
ip_ptr -> nx_ip_rarp_deferred_received_packet_head = NX_NULL;
ip_ptr -> nx_ip_rarp_deferred_received_packet_tail = NX_NULL;
#endif /* !NX_DISABLE_IPV4 */
/* Release all queued TCP packets. */
tcp_queue_head = ip_ptr -> nx_ip_tcp_queue_head;
ip_ptr -> nx_ip_tcp_queue_head = NX_NULL;
ip_ptr -> nx_ip_tcp_queue_tail = NX_NULL;
/* Restore interrupts. */
TX_RESTORE
/* Release mutex protection. */
tx_mutex_put(&(ip_ptr -> nx_ip_protection));
/* Deactivate and delete the IP periodic timer. */
tx_timer_deactivate(&(ip_ptr -> nx_ip_periodic_timer));
tx_timer_delete(&(ip_ptr -> nx_ip_periodic_timer));
/* Determine if the fast timer has been created. */
if (ip_ptr -> nx_ip_fast_periodic_timer_created)
{
/* Yes. Deactivate and delete the IP fast periodic timer. */
tx_timer_deactivate(&(ip_ptr -> nx_ip_fast_periodic_timer));
tx_timer_delete(&(ip_ptr -> nx_ip_fast_periodic_timer));
ip_ptr -> nx_ip_fast_periodic_timer_created = 0;
}
/* Terminate the internal IP thread. */
tx_thread_terminate(&(ip_ptr -> nx_ip_thread));
/* Delete the internal IP protection mutex. */
tx_mutex_delete(&(ip_ptr -> nx_ip_protection));
/* Delete the internal IP event flag object. */
tx_event_flags_delete(&(ip_ptr -> nx_ip_events));
/* Delete the internal IP thread for handling more processing intensive
duties. */
tx_thread_delete(&(ip_ptr -> nx_ip_thread));
/* Release any raw packets queued up. */
if (raw_packet_head)
{
_nx_ip_delete_queue_clear(raw_packet_head);
}
/* Release any deferred IP packets. */
if (deferred_head)
{
_nx_ip_delete_queue_clear(deferred_head);
}
/* Release any queued ICMP packets. */
if (icmp_queue_head)
{
_nx_ip_delete_queue_clear(icmp_queue_head);
}
/* Release any queued TCP packets. */
if (tcp_queue_head)
{
_nx_ip_delete_queue_clear(tcp_queue_head);
}
#ifndef NX_DISABLE_IPV4
/* Release any queued ARP packets. */
if (arp_queue_head)
{
_nx_ip_delete_queue_clear(arp_queue_head);
}
/* Release any queued RARP packets. */
if (rarp_queue_head)
{
_nx_ip_delete_queue_clear(rarp_queue_head);
}
/* Release any queued IGMP packets. */
if (igmp_queue_head)
{
_nx_ip_delete_queue_clear(igmp_queue_head);
}
#endif /* !NX_DISABLE_IPV4 */
/* Lift any suspension on RAW IP packet receives. */
while (ip_ptr -> nx_ip_raw_packet_suspension_list)
{
/* Release the suspended thread. */
_nx_ip_raw_packet_cleanup(ip_ptr -> nx_ip_raw_packet_suspension_list NX_CLEANUP_ARGUMENT);
}
/* Lift any suspension on ICMP ping requests. */
while (ip_ptr -> nx_ip_icmp_ping_suspension_list)
{
/* Release the suspended thread. */
_nx_icmp_cleanup(ip_ptr -> nx_ip_icmp_ping_suspension_list NX_CLEANUP_ARGUMENT);
}
/* Determine if fragment processing was enabled. */
if (ip_ptr -> nx_ip_fragment_processing)
{
/* Yes, disable fragment processing, which will release all outstanding
fragmented packets. */
_nx_ip_fragment_disable(ip_ptr);
}
#ifndef NX_DISABLE_IPV4
/* Invalidate dynamic ARP entries. */
_nx_arp_dynamic_entries_invalidate(ip_ptr);
#endif /* !NX_DISABLE_IPV4 */
#ifdef FEATURE_NX_IPV6
/* Invalidate ND cache. */
_nxd_nd_cache_invalidate(ip_ptr);
#endif /* FEATURE_NX_IPV6 */
/* Clear the IP ID to make it invalid. */
ip_ptr -> nx_ip_id = 0;
/* Disable interrupts. */
TX_DISABLE
/* Restore preemption. */
_tx_thread_preempt_disable--;
/* Restore interrupts. */
TX_RESTORE
/* Check for preemption. */
_tx_thread_system_preempt_check();
/* Return success to the caller. */
return(NX_SUCCESS);
}
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.