ReactOS 0.4.16-dev-297-gc569aee
test_udp.c File Reference
#include "test_udp.h"
#include "lwip/udp.h"
#include "lwip/stats.h"
#include "lwip/inet_chksum.h"
Include dependency graph for test_udp.c:

Go to the source code of this file.

Classes

struct  test_udp_rxdata
 

Functions

static void udp_remove_all (void)
 
static err_t default_netif_output (struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr)
 
static err_t default_netif_linkoutput (struct netif *netif, struct pbuf *p)
 
static err_t default_netif_init (struct netif *netif)
 
static void default_netif_add (void)
 
static void default_netif_remove (void)
 
static void udp_setup (void)
 
static void udp_teardown (void)
 
 START_TEST (test_udp_new_remove)
 
static END_TEST void test_recv (void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
 
static struct pbuftest_udp_create_test_packet (u16_t length, u16_t port, u32_t dst_addr)
 
 START_TEST (test_udp_broadcast_rx_with_2_netifs)
 
END_TEST START_TEST (test_udp_bind)
 
END_TEST Suite * udp_suite (void)
 

Variables

static struct netif test_netif1 test_netif2
 
static ip4_addr_t test_gw1
 
static ip4_addr_t test_ipaddr1
 
static ip4_addr_t test_netmask1
 
static ip4_addr_t test_gw2
 
static ip4_addr_t test_ipaddr2
 
static ip4_addr_t test_netmask2
 
static int output_ctr
 
static int linkoutput_ctr
 

Function Documentation

◆ default_netif_add()

static void default_netif_add ( void  )
static

Definition at line 69 of file test_udp.c.

70{
71 struct netif *n;
72
73#if LWIP_HAVE_LOOPIF
74 fail_unless(netif_list != NULL); /* the loopif */
75 fail_unless(netif_list->next == NULL);
76#else
77 fail_unless(netif_list == NULL);
78#endif
79 fail_unless(netif_default == NULL);
80
81 IP4_ADDR(&test_ipaddr1, 192,168,0,1);
82 IP4_ADDR(&test_netmask1, 255,255,255,0);
83 IP4_ADDR(&test_gw1, 192,168,0,254);
84 n = netif_add(&test_netif1, &test_ipaddr1, &test_netmask1,
86 fail_unless(n == &test_netif1);
87
88 IP4_ADDR(&test_ipaddr2, 192,168,1,1);
89 IP4_ADDR(&test_netmask2, 255,255,255,0);
90 IP4_ADDR(&test_gw2, 192,168,1,254);
93 fail_unless(n == &test_netif2);
94
95 netif_set_default(&test_netif1);
96 netif_set_up(&test_netif1);
98}
#define NULL
Definition: types.h:112
GLdouble n
Definition: glext.h:7729
struct netif * netif_add(struct netif *netif, void *state, netif_init_fn init, netif_input_fn input)
Definition: netif.c:287
void netif_set_default(struct netif *netif)
Definition: netif.c:849
void netif_set_up(struct netif *netif)
Definition: netif.c:871
struct netif * netif_list
Definition: netif.c:113
struct netif * netif_default
Definition: netif.c:115
Definition: netif.h:269
static ip4_addr_t test_gw2
Definition: test_udp.c:19
static struct netif test_netif1 test_netif2
Definition: test_udp.c:17
static err_t default_netif_init(struct netif *netif)
Definition: test_udp.c:57
static ip4_addr_t test_netmask2
Definition: test_udp.c:19
static ip4_addr_t test_ipaddr1
Definition: test_udp.c:18
static ip4_addr_t test_gw1
Definition: test_udp.c:18
static ip4_addr_t test_netmask1
Definition: test_udp.c:18
static ip4_addr_t test_ipaddr2
Definition: test_udp.c:19

Referenced by udp_setup().

◆ default_netif_init()

static err_t default_netif_init ( struct netif netif)
static

Definition at line 57 of file test_udp.c.

58{
59 fail_unless(netif != NULL);
62 netif->mtu = 1500;
64 netif->hwaddr_len = 6;
65 return ERR_OK;
66}
@ ERR_OK
Definition: err.h:55
#define NETIF_FLAG_LINK_UP
Definition: netif.h:93
#define NETIF_FLAG_ETHARP
Definition: netif.h:97
#define NETIF_FLAG_BROADCAST
Definition: netif.h:87
u8_t flags
Definition: netif.h:354
u16_t mtu
Definition: netif.h:344
netif_linkoutput_fn linkoutput
Definition: netif.h:308
u8_t hwaddr_len
Definition: netif.h:352
static err_t default_netif_linkoutput(struct netif *netif, struct pbuf *p)
Definition: test_udp.c:48
static err_t default_netif_output(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr)
Definition: test_udp.c:38

Referenced by default_netif_add().

◆ default_netif_linkoutput()

static err_t default_netif_linkoutput ( struct netif netif,
struct pbuf p 
)
static

Definition at line 48 of file test_udp.c.

49{
50 fail_unless((netif == &test_netif1) || (netif == &test_netif2));
51 fail_unless(p != NULL);
53 return ERR_OK;
54}
GLfloat GLfloat p
Definition: glext.h:8902
static int linkoutput_ctr
Definition: test_udp.c:20

Referenced by default_netif_init().

◆ default_netif_output()

static err_t default_netif_output ( struct netif netif,
struct pbuf p,
const ip4_addr_t *  ipaddr 
)
static

Definition at line 38 of file test_udp.c.

39{
40 fail_unless((netif == &test_netif1) || (netif == &test_netif2));
41 fail_unless(p != NULL);
42 fail_unless(ipaddr != NULL);
43 output_ctr++;
44 return ERR_OK;
45}
static int output_ctr
Definition: test_udp.c:20

Referenced by default_netif_init().

◆ default_netif_remove()

static void default_netif_remove ( void  )
static

Definition at line 101 of file test_udp.c.

102{
103 fail_unless(netif_default == &test_netif1);
104 netif_remove(&test_netif1);
106 fail_unless(netif_default == NULL);
107#if LWIP_HAVE_LOOPIF
108 fail_unless(netif_list != NULL); /* the loopif */
109 fail_unless(netif_list->next == NULL);
110#else
111 fail_unless(netif_list == NULL);
112#endif
113}
void netif_remove(struct netif *netif)
Definition: netif.c:764

Referenced by udp_teardown().

◆ START_TEST() [1/3]

END_TEST START_TEST ( test_udp_bind  )

Definition at line 338 of file test_udp.c.

339{
340 struct udp_pcb* pcb1;
341 struct udp_pcb* pcb2;
342 ip_addr_t ip1;
343 ip_addr_t ip2;
344 err_t err1;
345 err_t err2;
346 LWIP_UNUSED_ARG(_i);
347
348 /* bind on same port using different IP address types */
349 ip_addr_set_any_val(0, ip1);
350 ip_addr_set_any_val(1, ip2);
351
352 pcb1 = udp_new_ip_type(IPADDR_TYPE_V4);
353 pcb2 = udp_new_ip_type(IPADDR_TYPE_V6);
354
355 err1 = udp_bind(pcb1, &ip1, 2105);
356 err2 = udp_bind(pcb2, &ip2, 2105);
357
358 fail_unless(err1 == ERR_OK);
359 fail_unless(err2 == ERR_OK);
360
361 udp_remove(pcb1);
362 udp_remove(pcb2);
363
364 /* bind on same port using SAME IPv4 address type */
365 ip_addr_set_any_val(0, ip1);
366 ip_addr_set_any_val(0, ip2);
367
368 pcb1 = udp_new_ip_type(IPADDR_TYPE_V4);
369 pcb2 = udp_new_ip_type(IPADDR_TYPE_V4);
370
371 err1 = udp_bind(pcb1, &ip1, 2105);
372 err2 = udp_bind(pcb2, &ip2, 2105);
373
374 fail_unless(err1 == ERR_OK);
375 fail_unless(err2 == ERR_USE);
376
377 udp_remove(pcb1);
378 udp_remove(pcb2);
379
380 /* bind on same port using SAME IPv6 address type */
381 ip_addr_set_any_val(1, ip1);
382 ip_addr_set_any_val(1, ip2);
383
384 pcb1 = udp_new_ip_type(IPADDR_TYPE_V6);
385 pcb2 = udp_new_ip_type(IPADDR_TYPE_V6);
386
387 err1 = udp_bind(pcb1, &ip1, 2105);
388 err2 = udp_bind(pcb2, &ip2, 2105);
389
390 fail_unless(err1 == ERR_OK);
391 fail_unless(err2 == ERR_USE);
392
393 udp_remove(pcb1);
394 udp_remove(pcb2);
395
396 /* Bind with different IP address type */
397 ip_addr_set_any_val(0, ip1);
398 ip_addr_set_any_val(1, ip2);
399
400 pcb1 = udp_new_ip_type(IPADDR_TYPE_V6);
401 pcb2 = udp_new_ip_type(IPADDR_TYPE_V4);
402
403 err1 = udp_bind(pcb1, &ip1, 2105);
404 err2 = udp_bind(pcb2, &ip2, 2105);
405
406 fail_unless(err1 == ERR_OK);
407 fail_unless(err2 == ERR_OK);
408
409 udp_remove(pcb1);
410 udp_remove(pcb2);
411
412 /* Bind with different IP numbers */
413 IP_ADDR4(&ip1, 1, 2, 3, 4);
414 IP_ADDR4(&ip2, 4, 3, 2, 1);
415
416 pcb1 = udp_new_ip_type(IPADDR_TYPE_V6);
417 pcb2 = udp_new_ip_type(IPADDR_TYPE_V4);
418
419 err1 = udp_bind(pcb1, &ip1, 2105);
420 err2 = udp_bind(pcb2, &ip2, 2105);
421
422 fail_unless(err1 == ERR_OK);
423 fail_unless(err2 == ERR_OK);
424
425 udp_remove(pcb1);
426 udp_remove(pcb2);
427
428 /* Bind with same IP numbers */
429 IP_ADDR4(&ip1, 1, 2, 3, 4);
430 IP_ADDR4(&ip2, 1, 2, 3, 4);
431
432 pcb1 = udp_new_ip_type(IPADDR_TYPE_V6);
433 pcb2 = udp_new_ip_type(IPADDR_TYPE_V4);
434
435 err1 = udp_bind(pcb1, &ip1, 2105);
436 err2 = udp_bind(pcb2, &ip2, 2105);
437
438 fail_unless(err1 == ERR_OK);
439 fail_unless(err2 == ERR_USE);
440
441 udp_remove(pcb1);
442 udp_remove(pcb2);
443
444 /* bind on same port using ANY + IPv4 */
445 ip1 = *IP_ANY_TYPE;
446 IP_ADDR4(&ip2, 1, 2, 3, 4);
447
448 pcb1 = udp_new_ip_type(IPADDR_TYPE_ANY);
449 pcb2 = udp_new_ip_type(IPADDR_TYPE_V4);
450
451 err1 = udp_bind(pcb1, &ip1, 2105);
452 err2 = udp_bind(pcb2, &ip2, 2105);
453
454 fail_unless(err1 == ERR_OK);
455 fail_unless(err2 == ERR_USE);
456
457 udp_remove(pcb1);
458 udp_remove(pcb2);
459}
#define LWIP_UNUSED_ARG(x)
Definition: arch.h:373
s8_t err_t
Definition: err.h:96
@ ERR_USE
Definition: err.h:71
#define IP_ANY_TYPE
Definition: ip_addr.h:461
@ IPADDR_TYPE_V6
Definition: ip_addr.h:58
@ IPADDR_TYPE_ANY
Definition: ip_addr.h:60
@ IPADDR_TYPE_V4
Definition: ip_addr.h:56
ip6_addr_t ip_addr_t
Definition: ip_addr.h:344
#define ip_addr_set_any_val(is_ipv6, ipaddr)
Definition: ip_addr.h:289

◆ START_TEST() [2/3]

START_TEST ( test_udp_broadcast_rx_with_2_netifs  )

Definition at line 212 of file test_udp.c.

213{
214 err_t err;
215 struct udp_pcb *pcb1, *pcb2;
216 const u16_t port = 12345;
217 struct test_udp_rxdata ctr1, ctr2;
218 struct pbuf *p;
219#if SO_REUSE
220 struct udp_pcb *pcb_any;
221 struct test_udp_rxdata ctr_any;
222#endif
223 LWIP_UNUSED_ARG(_i);
224
225 pcb1 = udp_new();
226 fail_unless(pcb1 != NULL);
227 pcb2 = udp_new();
228 fail_unless(pcb2 != NULL);
229
230#if SO_REUSE
231 pcb_any = udp_new();
232 fail_unless(pcb_any != NULL);
233
237
238 err = udp_bind(pcb_any, NULL, port);
239 fail_unless(err == ERR_OK);
240 memset(&ctr_any, 0, sizeof(ctr_any));
241 ctr_any.pcb = pcb_any;
242 udp_recv(pcb_any, test_recv, &ctr_any);
243#endif
244
245 err = udp_bind(pcb1, &test_netif1.ip_addr, port);
246 fail_unless(err == ERR_OK);
247 err = udp_bind(pcb2, &test_netif2.ip_addr, port);
248 fail_unless(err == ERR_OK);
249
250 memset(&ctr1, 0, sizeof(ctr1));
251 ctr1.pcb = pcb1;
252 memset(&ctr2, 0, sizeof(ctr2));
253 ctr2.pcb = pcb2;
254
255 udp_recv(pcb1, test_recv, &ctr1);
256 udp_recv(pcb2, test_recv, &ctr2);
257
258 /* unicast to netif1 */
260 EXPECT_RET(p != NULL);
261 err = ip4_input(p, &test_netif1);
262 fail_unless(err == ERR_OK);
263 fail_unless(ctr1.rx_cnt == 1);
264 fail_unless(ctr1.rx_bytes == 16);
265 fail_unless(ctr2.rx_cnt == 0);
266#if SO_REUSE
267 fail_unless(ctr_any.rx_cnt == 0);
268#endif
269 ctr1.rx_cnt = ctr1.rx_bytes = 0;
270
271 /* unicast to netif2 */
273 EXPECT_RET(p != NULL);
274 err = ip4_input(p, &test_netif2);
275 fail_unless(err == ERR_OK);
276 fail_unless(ctr2.rx_cnt == 1);
277 fail_unless(ctr2.rx_bytes == 16);
278 fail_unless(ctr1.rx_cnt == 0);
279#if SO_REUSE
280 fail_unless(ctr_any.rx_cnt == 0);
281#endif
282 ctr2.rx_cnt = ctr2.rx_bytes = 0;
283
284 /* broadcast to netif1-broadcast, input to netif2 */
286 EXPECT_RET(p != NULL);
287 err = ip4_input(p, &test_netif2);
288 fail_unless(err == ERR_OK);
289 fail_unless(ctr1.rx_cnt == 1);
290 fail_unless(ctr1.rx_bytes == 16);
291 fail_unless(ctr2.rx_cnt == 0);
292#if SO_REUSE
293 fail_unless(ctr_any.rx_cnt == 0);
294#endif
295 ctr1.rx_cnt = ctr1.rx_bytes = 0;
296
297 /* broadcast to netif2-broadcast, input to netif1 */
299 EXPECT_RET(p != NULL);
300 err = ip4_input(p, &test_netif1);
301 fail_unless(err == ERR_OK);
302 fail_unless(ctr2.rx_cnt == 1);
303 fail_unless(ctr2.rx_bytes == 16);
304 fail_unless(ctr1.rx_cnt == 0);
305#if SO_REUSE
306 fail_unless(ctr_any.rx_cnt == 0);
307#endif
308 ctr2.rx_cnt = ctr2.rx_bytes = 0;
309
310 /* broadcast to global-broadcast, input to netif1 */
311 p = test_udp_create_test_packet(16, port, 0xffffffff);
312 EXPECT_RET(p != NULL);
313 err = ip4_input(p, &test_netif1);
314 fail_unless(err == ERR_OK);
315 fail_unless(ctr1.rx_cnt == 1);
316 fail_unless(ctr1.rx_bytes == 16);
317 fail_unless(ctr2.rx_cnt == 0);
318#if SO_REUSE
319 fail_unless(ctr_any.rx_cnt == 0);
320#endif
321 ctr1.rx_cnt = ctr1.rx_bytes = 0;
322
323 /* broadcast to global-broadcast, input to netif2 */
324 p = test_udp_create_test_packet(16, port, 0xffffffff);
325 EXPECT_RET(p != NULL);
326 err = ip4_input(p, &test_netif2);
327 fail_unless(err == ERR_OK);
328 fail_unless(ctr2.rx_cnt == 1);
329 fail_unless(ctr2.rx_bytes == 16);
330 fail_unless(ctr1.rx_cnt == 0);
331#if SO_REUSE
332 fail_unless(ctr_any.rx_cnt == 0);
333#endif
334 ctr2.rx_cnt = ctr2.rx_bytes = 0;
335}
USHORT port
Definition: uri.c:228
#define ip_set_option(pcb, opt)
Definition: ip.h:230
#define SOF_REUSEADDR
Definition: ip.h:110
uint16_t u16_t
Definition: arch.h:127
#define EXPECT_RET(x)
Definition: lwip_check.h:12
#define err(...)
#define memset(x, y, z)
Definition: compat.h:39
Definition: pbuf.h:186
static struct pbuf * test_udp_create_test_packet(u16_t length, u16_t port, u32_t dst_addr)
Definition: test_udp.c:172
static END_TEST void test_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
Definition: test_udp.c:152

◆ START_TEST() [3/3]

START_TEST ( test_udp_new_remove  )

Definition at line 135 of file test_udp.c.

136{
137 struct udp_pcb* pcb;
138 LWIP_UNUSED_ARG(_i);
139
140 fail_unless(MEMP_STATS_GET(used, MEMP_UDP_PCB) == 0);
141
142 pcb = udp_new();
143 fail_unless(pcb != NULL);
144 if (pcb != NULL) {
145 fail_unless(MEMP_STATS_GET(used, MEMP_UDP_PCB) == 1);
146 udp_remove(pcb);
147 fail_unless(MEMP_STATS_GET(used, MEMP_UDP_PCB) == 0);
148 }
149}
static int used
Definition: adh-main.c:39
#define MEMP_STATS_GET(x, i)
Definition: stats.h:409

◆ test_recv()

static END_TEST void test_recv ( void arg,
struct udp_pcb *  pcb,
struct pbuf p,
const ip_addr_t addr,
u16_t  port 
)
static

Definition at line 152 of file test_udp.c.

154{
155 struct test_udp_rxdata *ctr = (struct test_udp_rxdata *)arg;
156
159
160 fail_unless(arg != NULL);
161 fail_unless(ctr->pcb == pcb);
162
163 ctr->rx_cnt++;
164 ctr->rx_bytes += p->tot_len;
165
166 if (p != NULL) {
167 pbuf_free(p);
168 }
169}
GLenum const GLvoid * addr
Definition: glext.h:9621
u8_t pbuf_free(struct pbuf *p)
Definition: pbuf.c:727
u32_t rx_bytes
Definition: test_udp.c:13
u32_t rx_cnt
Definition: test_udp.c:12
struct udp_pcb * pcb
Definition: test_udp.c:14

Referenced by START_TEST().

◆ test_udp_create_test_packet()

static struct pbuf * test_udp_create_test_packet ( u16_t  length,
u16_t  port,
u32_t  dst_addr 
)
static

Definition at line 172 of file test_udp.c.

173{
174 err_t err;
175 u8_t ret;
176 struct udp_hdr *uh;
177 struct ip_hdr *ih;
178 struct pbuf *p;
179 const u8_t test_data[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
180
182 fail_unless(p != NULL);
183 if (p == NULL) {
184 return NULL;
185 }
186 fail_unless(p->next == NULL);
188 fail_unless(err == ERR_OK);
189
190 /* add UDP header */
191 ret = pbuf_add_header(p, sizeof(struct udp_hdr));
192 fail_unless(!ret);
193 uh = (struct udp_hdr *)p->payload;
194 uh->chksum = 0;
195 uh->dest = uh->src = lwip_htons(port);
196 uh->len = lwip_htons(p->tot_len);
197 /* add IPv4 header */
198 ret = pbuf_add_header(p, sizeof(struct ip_hdr));
199 fail_unless(!ret);
200 ih = (struct ip_hdr *)p->payload;
201 memset(ih, 0, sizeof(*ih));
202 ih->dest.addr = dst_addr;
203 ih->_len = lwip_htons(p->tot_len);
204 ih->_ttl = 32;
205 ih->_proto = IP_PROTO_UDP;
206 IPH_VHL_SET(ih, 4, sizeof(struct ip_hdr) / 4);
207 IPH_CHKSUM_SET(ih, inet_chksum(ih, sizeof(struct ip_hdr)));
208 return p;
209}
#define lwip_htons(x)
Definition: def.h:86
#define IP_PROTO_UDP
Definition: ip.h:48
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
uint8_t u8_t
Definition: arch.h:125
struct pbuf * pbuf_alloc(pbuf_layer layer, u16_t length, pbuf_type type)
Definition: pbuf.c:224
err_t pbuf_take(struct pbuf *buf, const void *dataptr, u16_t len)
Definition: pbuf.c:1227
@ PBUF_POOL
Definition: pbuf.h:167
@ PBUF_TRANSPORT
Definition: pbuf.h:93
u16_t inet_chksum(const void *dataptr, u16_t len)
Definition: inet_chksum.c:555
u8_t pbuf_add_header(struct pbuf *p, size_t header_size_increment)
Definition: pbuf.c:554
#define IPH_VHL_SET(hdr, v, hl)
Definition: ip4.h:117
#define IPH_CHKSUM_SET(hdr, chksum)
Definition: ip4.h:124
Definition: ip4.h:73
Definition: udp.h:53
int ret

Referenced by START_TEST().

◆ udp_remove_all()

static void udp_remove_all ( void  )
static

Definition at line 24 of file test_udp.c.

25{
26 struct udp_pcb *pcb = udp_pcbs;
27 struct udp_pcb *pcb2;
28
29 while(pcb != NULL) {
30 pcb2 = pcb;
31 pcb = pcb->next;
32 udp_remove(pcb2);
33 }
34 fail_unless(MEMP_STATS_GET(used, MEMP_UDP_PCB) == 0);
35}

Referenced by udp_setup(), and udp_teardown().

◆ udp_setup()

static void udp_setup ( void  )
static

Definition at line 117 of file test_udp.c.

118{
121 lwip_check_ensure_no_alloc(SKIP_POOL(MEMP_SYS_TIMEOUT));
122}
#define SKIP_POOL(x)
Definition: lwip_check.h:48
void lwip_check_ensure_no_alloc(unsigned int skip)
static void udp_remove_all(void)
Definition: test_udp.c:24
static void default_netif_add(void)
Definition: test_udp.c:69

Referenced by udp_suite().

◆ udp_suite()

END_TEST Suite * udp_suite ( void  )

Create the suite including all tests for this module

Definition at line 464 of file test_udp.c.

465{
466 testfunc tests[] = {
467 TESTFUNC(test_udp_new_remove),
468 TESTFUNC(test_udp_broadcast_rx_with_2_netifs),
469 TESTFUNC(test_udp_bind)
470 };
471 return create_suite("UDP", tests, sizeof(tests)/sizeof(testfunc), udp_setup, udp_teardown);
472}
Suite * create_suite(const char *name, testfunc *tests, size_t num_tests, SFun setup, SFun teardown)
#define TESTFUNC(x)
Definition: lwip_check.h:22
static struct test_info tests[]
static void udp_setup(void)
Definition: test_udp.c:117
static void udp_teardown(void)
Definition: test_udp.c:125

Referenced by main().

◆ udp_teardown()

static void udp_teardown ( void  )
static

Definition at line 125 of file test_udp.c.

126{
129 lwip_check_ensure_no_alloc(SKIP_POOL(MEMP_SYS_TIMEOUT));
130}
static void default_netif_remove(void)
Definition: test_udp.c:101

Referenced by udp_suite().

Variable Documentation

◆ linkoutput_ctr

int linkoutput_ctr
static

Definition at line 20 of file test_udp.c.

Referenced by default_netif_linkoutput().

◆ output_ctr

int output_ctr
static

Definition at line 20 of file test_udp.c.

Referenced by default_netif_output().

◆ test_gw1

ip4_addr_t test_gw1
static

Definition at line 18 of file test_udp.c.

Referenced by default_netif_add().

◆ test_gw2

ip4_addr_t test_gw2
static

Definition at line 19 of file test_udp.c.

Referenced by default_netif_add().

◆ test_ipaddr1

ip4_addr_t test_ipaddr1
static

Definition at line 18 of file test_udp.c.

Referenced by default_netif_add(), and START_TEST().

◆ test_ipaddr2

ip4_addr_t test_ipaddr2
static

Definition at line 19 of file test_udp.c.

Referenced by default_netif_add(), and START_TEST().

◆ test_netif2

struct netif test_netif1 test_netif2
static

◆ test_netmask1

ip4_addr_t test_netmask1
static

Definition at line 18 of file test_udp.c.

Referenced by default_netif_add(), and START_TEST().

◆ test_netmask2

ip4_addr_t test_netmask2
static

Definition at line 19 of file test_udp.c.

Referenced by default_netif_add(), and START_TEST().