source: rtems-libbsd/testsuite/syscalls01/test_main.c @ d01564c

4.1155-freebsd-126-freebsd-12freebsd-9.3
Last change on this file since d01564c was d01564c, checked in by Sebastian Huber <sebastian.huber@…>, on 10/17/13 at 08:38:34

Move program control to thread structure
  • Property mode set to 100644
File size: 30.9 KB
Line 
1/*
2 * Copyright (c) 2013 embedded brains GmbH.  All rights reserved.
3 *
4 *  embedded brains GmbH
5 *  Dornierstr. 4
6 *  82178 Puchheim
7 *  Germany
8 *  <rtems@embedded-brains.de>
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33#include <sys/types.h>
34#include <sys/stat.h>
35#include <sys/socket.h>
36#include <sys/filio.h>
37#include <netinet/in.h>
38#include <arpa/inet.h>
39#include <err.h>
40
41#include <assert.h>
42#include <errno.h>
43#include <stdbool.h>
44#include <stdio.h>
45#include <stdlib.h>
46#include <string.h>
47#include <unistd.h>
48
49#define RTEMS_BSD_PROGRAM_NO_EXIT_WRAP
50#define RTEMS_BSD_PROGRAM_NO_PRINTF_WRAP
51#include <machine/rtems-bsd-program.h>
52
53#include <rtems/libcsupport.h>
54
55#define TEST_NAME "LIBBSD SYSCALLS 1"
56
57typedef void (*no_mem_test_body)(int fd);
58
59typedef struct {
60        no_mem_test_body body;
61        int fd;
62        rtems_id master_task;
63} no_mem_test;
64
65typedef struct {
66        int domain;
67        int type;
68        int protocol;
69        int expect_errno;
70} socket_test;
71
72static socket_test socket_tests[] = {
73        { -1, SOCK_RAW, 0, EPROTONOSUPPORT },
74        { PF_UNSPEC, SOCK_DGRAM, 0, EPROTONOSUPPORT },
75        { PF_UNIX, SOCK_DGRAM, 0, EPROTONOSUPPORT },
76        { PF_INET, -1, 0, EPROTONOSUPPORT },
77        { PF_INET, SOCK_RAW, -1, EPROTONOSUPPORT },
78        { PF_INET, SOCK_STREAM, 0, 0 },
79        { PF_INET, SOCK_DGRAM, 0, 0 },
80        { PF_INET, SOCK_SEQPACKET, 0, EPROTONOSUPPORT },
81        { PF_INET, SOCK_RAW, IPPROTO_3PC, 0 },
82        { PF_INET, SOCK_RAW, IPPROTO_ADFS, 0 },
83        { PF_INET, SOCK_RAW, IPPROTO_AH, EPROTONOSUPPORT },
84        { PF_INET, SOCK_RAW, IPPROTO_AHIP, 0 },
85        { PF_INET, SOCK_RAW, IPPROTO_APES, 0 },
86        { PF_INET, SOCK_RAW, IPPROTO_ARGUS, 0 },
87        { PF_INET, SOCK_RAW, IPPROTO_AX25, 0 },
88        { PF_INET, SOCK_RAW, IPPROTO_BHA, 0 },
89        { PF_INET, SOCK_RAW, IPPROTO_BLT, 0 },
90        { PF_INET, SOCK_RAW, IPPROTO_BRSATMON, 0 },
91        { PF_INET, SOCK_RAW, IPPROTO_CARP, 0 },
92        { PF_INET, SOCK_RAW, IPPROTO_CFTP, 0 },
93        { PF_INET, SOCK_RAW, IPPROTO_CHAOS, 0 },
94        { PF_INET, SOCK_RAW, IPPROTO_CMTP, 0 },
95        { PF_INET, SOCK_RAW, IPPROTO_CPHB, 0 },
96        { PF_INET, SOCK_RAW, IPPROTO_CPNX, 0 },
97        { PF_INET, SOCK_RAW, IPPROTO_DDP, 0 },
98        { PF_INET, SOCK_RAW, IPPROTO_DGP, 0 },
99        { PF_INET, SOCK_RAW, IPPROTO_DSTOPTS, 0 },
100        { PF_INET, SOCK_RAW, IPPROTO_EGP, 0 },
101        { PF_INET, SOCK_RAW, IPPROTO_EMCON, 0 },
102        { PF_INET, SOCK_RAW, IPPROTO_ENCAP, 0 },
103        { PF_INET, SOCK_RAW, IPPROTO_EON, 0 },
104        { PF_INET, SOCK_RAW, IPPROTO_ESP, EPROTONOSUPPORT },
105        { PF_INET, SOCK_RAW, IPPROTO_ETHERIP, 0 },
106        { PF_INET, SOCK_RAW, IPPROTO_FRAGMENT, 0 },
107        { PF_INET, SOCK_RAW, IPPROTO_GGP, 0 },
108        { PF_INET, SOCK_RAW, IPPROTO_GMTP, 0 },
109        { PF_INET, SOCK_RAW, IPPROTO_GRE, 0 },
110        { PF_INET, SOCK_RAW, IPPROTO_HELLO, 0 },
111        { PF_INET, SOCK_RAW, IPPROTO_HMP, 0 },
112        { PF_INET, SOCK_RAW, IPPROTO_ICMP, 0 },
113        { PF_INET, SOCK_RAW, IPPROTO_ICMPV6, 0 },
114        { PF_INET, SOCK_RAW, IPPROTO_IDP, 0 },
115        { PF_INET, SOCK_RAW, IPPROTO_IDPR, 0 },
116        { PF_INET, SOCK_RAW, IPPROTO_IDRP, 0 },
117        { PF_INET, SOCK_RAW, IPPROTO_IGMP, 0 },
118        { PF_INET, SOCK_RAW, IPPROTO_IGP, 0 },
119        { PF_INET, SOCK_RAW, IPPROTO_IGRP, 0 },
120        { PF_INET, SOCK_RAW, IPPROTO_IL, 0 },
121        { PF_INET, SOCK_RAW, IPPROTO_INLSP, 0 },
122        { PF_INET, SOCK_RAW, IPPROTO_INP, 0 },
123        { PF_INET, SOCK_RAW, IPPROTO_IP, 0 },
124        { PF_INET, SOCK_RAW, IPPROTO_IPCOMP, EPROTONOSUPPORT },
125        { PF_INET, SOCK_RAW, IPPROTO_IPCV, 0 },
126        { PF_INET, SOCK_RAW, IPPROTO_IPEIP, 0 },
127        { PF_INET, SOCK_RAW, IPPROTO_IPIP, 0 },
128        { PF_INET, SOCK_RAW, IPPROTO_IPPC, 0 },
129        { PF_INET, SOCK_RAW, IPPROTO_IPV4, 0 },
130        { PF_INET, SOCK_RAW, IPPROTO_IPV6, 0 },
131        { PF_INET, SOCK_RAW, IPPROTO_IRTP, 0 },
132        { PF_INET, SOCK_RAW, IPPROTO_KRYPTOLAN, 0 },
133        { PF_INET, SOCK_RAW, IPPROTO_LARP, 0 },
134        { PF_INET, SOCK_RAW, IPPROTO_LEAF1, 0 },
135        { PF_INET, SOCK_RAW, IPPROTO_LEAF2, 0 },
136        { PF_INET, SOCK_RAW, IPPROTO_MEAS, 0 },
137        { PF_INET, SOCK_RAW, IPPROTO_MHRP, 0 },
138        { PF_INET, SOCK_RAW, IPPROTO_MICP, 0 },
139        { PF_INET, SOCK_RAW, IPPROTO_MOBILE, 0 },
140        { PF_INET, SOCK_RAW, IPPROTO_MTP, 0 },
141        { PF_INET, SOCK_RAW, IPPROTO_MUX, 0 },
142        { PF_INET, SOCK_RAW, IPPROTO_ND, 0 },
143        { PF_INET, SOCK_RAW, IPPROTO_NHRP, 0 },
144        { PF_INET, SOCK_RAW, IPPROTO_NONE, 0 },
145        { PF_INET, SOCK_RAW, IPPROTO_NSP, 0 },
146        { PF_INET, SOCK_RAW, IPPROTO_NVPII, 0 },
147        { PF_INET, SOCK_RAW, IPPROTO_OLD_DIVERT, 0 },
148        { PF_INET, SOCK_RAW, IPPROTO_OSPFIGP, 0 },
149        { PF_INET, SOCK_RAW, IPPROTO_PFSYNC, 0 },
150        { PF_INET, SOCK_RAW, IPPROTO_PGM, 0 },
151        { PF_INET, SOCK_RAW, IPPROTO_PIGP, 0 },
152        { PF_INET, SOCK_RAW, IPPROTO_PIM, 0 },
153        { PF_INET, SOCK_RAW, IPPROTO_PRM, 0 },
154        { PF_INET, SOCK_RAW, IPPROTO_PUP, 0 },
155        { PF_INET, SOCK_RAW, IPPROTO_PVP, 0 },
156        { PF_INET, SOCK_RAW, IPPROTO_RCCMON, 0 },
157        { PF_INET, SOCK_RAW, IPPROTO_RDP, 0 },
158        { PF_INET, SOCK_RAW, IPPROTO_ROUTING, 0 },
159        { PF_INET, SOCK_RAW, IPPROTO_RSVP, 0 },
160        { PF_INET, SOCK_RAW, IPPROTO_RVD, 0 },
161        { PF_INET, SOCK_RAW, IPPROTO_SATEXPAK, 0 },
162        { PF_INET, SOCK_RAW, IPPROTO_SATMON, 0 },
163        { PF_INET, SOCK_RAW, IPPROTO_SCCSP, 0 },
164        { PF_INET, SOCK_RAW, IPPROTO_SCTP, 0 },
165        { PF_INET, SOCK_RAW, IPPROTO_SDRP, 0 },
166        { PF_INET, SOCK_RAW, IPPROTO_SEP, 0 },
167        { PF_INET, SOCK_RAW, IPPROTO_SKIP, 0 },
168        { PF_INET, SOCK_RAW, IPPROTO_SRPC, 0 },
169        { PF_INET, SOCK_RAW, IPPROTO_ST, 0 },
170        { PF_INET, SOCK_RAW, IPPROTO_SVMTP, 0 },
171        { PF_INET, SOCK_RAW, IPPROTO_SWIPE, 0 },
172        { PF_INET, SOCK_RAW, IPPROTO_TCF, 0 },
173        { PF_INET, SOCK_RAW, IPPROTO_TCP, 0 },
174        { PF_INET, SOCK_RAW, IPPROTO_TLSP, 0 },
175        { PF_INET, SOCK_RAW, IPPROTO_TP, 0 },
176        { PF_INET, SOCK_RAW, IPPROTO_TPXX, 0 },
177        { PF_INET, SOCK_RAW, IPPROTO_TRUNK1, 0 },
178        { PF_INET, SOCK_RAW, IPPROTO_TRUNK2, 0 },
179        { PF_INET, SOCK_RAW, IPPROTO_TTP, 0 },
180        { PF_INET, SOCK_RAW, IPPROTO_UDP, 0 },
181        { PF_INET, SOCK_RAW, IPPROTO_VINES, 0 },
182        { PF_INET, SOCK_RAW, IPPROTO_VISA, 0 },
183        { PF_INET, SOCK_RAW, IPPROTO_VMTP, 0 },
184        { PF_INET, SOCK_RAW, IPPROTO_WBEXPAK, 0 },
185        { PF_INET, SOCK_RAW, IPPROTO_WBMON, 0 },
186        { PF_INET, SOCK_RAW, IPPROTO_WSN, 0 },
187        { PF_INET, SOCK_RAW, IPPROTO_XNET, 0 },
188        { PF_INET, SOCK_RAW, IPPROTO_XTP, 0 },
189        { PF_IMPLINK, SOCK_DGRAM, 0, EPROTONOSUPPORT },
190        { PF_PUP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
191        { PF_CHAOS, SOCK_DGRAM, 0, EPROTONOSUPPORT },
192        { PF_NETBIOS, SOCK_DGRAM, 0, EPROTONOSUPPORT },
193        { PF_ISO, SOCK_DGRAM, 0, EPROTONOSUPPORT },
194        { PF_ECMA, SOCK_DGRAM, 0, EPROTONOSUPPORT },
195        { PF_DATAKIT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
196        { PF_CCITT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
197        { PF_SNA, SOCK_DGRAM, 0, EPROTONOSUPPORT },
198        { PF_DECnet, SOCK_DGRAM, 0, EPROTONOSUPPORT },
199        { PF_DLI, SOCK_DGRAM, 0, EPROTONOSUPPORT },
200        { PF_LAT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
201        { PF_HYLINK, SOCK_DGRAM, 0, EPROTONOSUPPORT },
202        { PF_APPLETALK, SOCK_DGRAM, 0, EPROTONOSUPPORT },
203        { PF_ROUTE, SOCK_DGRAM, 0, EPROTONOSUPPORT },
204        { PF_LINK, SOCK_DGRAM, 0, EPROTONOSUPPORT },
205        { PF_XTP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
206        { PF_COIP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
207        { PF_CNT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
208        { PF_RTIP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
209        { PF_IPX, SOCK_DGRAM, 0, EPROTONOSUPPORT },
210        { PF_SIP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
211        { PF_PIP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
212        { PF_ISDN, SOCK_DGRAM, 0, EPROTONOSUPPORT },
213        { PF_KEY, SOCK_DGRAM, 0, EPROTONOSUPPORT },
214        { PF_INET6, SOCK_DGRAM, 0, EPROTONOSUPPORT },
215        { PF_NATM, SOCK_DGRAM, 0, EPROTONOSUPPORT },
216        { PF_ATM, SOCK_DGRAM, 0, EPROTONOSUPPORT },
217        { pseudo_AF_HDRCMPLT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
218        { PF_NETGRAPH, SOCK_DGRAM, 0, EPROTONOSUPPORT },
219        { PF_SLOW, SOCK_DGRAM, 0, EPROTONOSUPPORT },
220        { PF_SCLUSTER, SOCK_DGRAM, 0, EPROTONOSUPPORT },
221        { PF_ARP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
222        { PF_BLUETOOTH, SOCK_DGRAM, 0, EPROTONOSUPPORT },
223        { AF_IEEE80211, SOCK_DGRAM, 0, EPROTONOSUPPORT }
224};
225
226static void
227init_addr(struct sockaddr_in *addr)
228{
229        int ok;
230
231        memset(addr, 0, sizeof(*addr));
232        addr->sin_family = AF_INET;
233        addr->sin_port = htons(1234);
234        ok = inet_aton("127.0.0.1", &addr->sin_addr);
235        assert(ok != 0);
236}
237
238static void
239init_msg(struct msghdr *msg, struct sockaddr_in *addr, struct iovec *iov,
240    void *buf, size_t n)
241{
242        memset(msg, 0, sizeof(*msg));
243        memset(iov, 0, sizeof(*iov));
244        iov->iov_base = buf;
245        iov->iov_len = n;
246        msg->msg_name = addr;
247        msg->msg_namelen = sizeof(*addr);
248        msg->msg_iov = iov;
249        msg->msg_iovlen = 1;
250}
251
252static void
253no_mem_task(rtems_task_argument arg)
254{
255        const no_mem_test *self = (const no_mem_test *) arg;
256        rtems_status_code sc;
257        void *greedy;
258
259        assert(rtems_configuration_get_unified_work_area());
260
261        greedy = rtems_workspace_greedy_allocate(NULL, 0);
262        (*self->body)(self->fd);
263        rtems_workspace_greedy_free(greedy);
264
265        sc = rtems_event_transient_send(self->master_task);
266        assert(sc == RTEMS_SUCCESSFUL);
267
268        sc = rtems_task_suspend(RTEMS_SELF);
269        assert(sc == RTEMS_SUCCESSFUL);
270}
271
272static void
273do_no_mem_test(no_mem_test_body body, int fd)
274{
275        no_mem_test test = {
276                .body = body,
277                .fd = fd,
278                .master_task = rtems_task_self()
279        };
280        rtems_status_code sc;
281        rtems_id id;
282        rtems_resource_snapshot snapshot;
283
284        rtems_resource_snapshot_take(&snapshot);
285
286        sc = rtems_task_create(
287                rtems_build_name('N', 'M', 'E', 'M'),
288                RTEMS_MINIMUM_PRIORITY,
289                RTEMS_MINIMUM_STACK_SIZE,
290                RTEMS_DEFAULT_MODES,
291                RTEMS_DEFAULT_ATTRIBUTES,
292                &id
293        );
294        assert(sc == RTEMS_SUCCESSFUL);
295
296        sc = rtems_task_start(id, no_mem_task, (rtems_task_argument) &test);
297        assert(sc == RTEMS_SUCCESSFUL);
298
299        sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
300        assert(sc == RTEMS_SUCCESSFUL);
301
302        sc = rtems_task_delete(id);
303        assert(sc == RTEMS_SUCCESSFUL);
304
305        assert(rtems_resource_snapshot_check(&snapshot));
306}
307
308static void
309test_socket(const socket_test *st)
310{
311        int sd;
312        int rv;
313
314        errno = 0;
315        sd = socket(st->domain, st->type, st->protocol);
316        if (st->expect_errno == 0) {
317                assert(sd >= 0);
318
319                rv = close(sd);
320                assert(rv == 0);
321        } else {
322                assert(st->expect_errno == errno);
323        }
324}
325
326static void
327test_sockets(void)
328{
329        size_t n = sizeof(socket_tests) / sizeof(socket_tests[0]);
330        size_t i;
331
332        puts("test sockets");
333
334        for (i = 0; i < n; ++i) {
335                const socket_test *st = &socket_tests[i];
336
337                test_socket(st);
338        }
339
340        puts("test sockets and check resources");
341
342        for (i = 0; i < n; ++i) {
343                const socket_test *st = &socket_tests[i];
344                rtems_resource_snapshot snapshot;
345
346                rtems_resource_snapshot_take(&snapshot);
347
348                test_socket(st);
349
350                assert(rtems_resource_snapshot_check(&snapshot));
351        }
352}
353
354static void
355test_socket_unsupported_ops(void)
356{
357        rtems_resource_snapshot snapshot;
358        int sd;
359        int rv;
360        off_t off;
361
362        puts("test socket unsupported ops");
363
364        rtems_resource_snapshot_take(&snapshot);
365
366        sd = socket(PF_INET, SOCK_DGRAM, 0);
367        assert(sd >= 0);
368
369        errno = 0;
370        off = lseek(sd, 0, SEEK_CUR);
371        assert(off == -1);
372        assert(errno == ESPIPE);
373
374        errno = 0;
375        rv = ftruncate(sd, 0);
376        assert(rv == -1);
377        assert(errno == EINVAL);
378
379        errno = 0;
380        rv = fsync(sd);
381        assert(rv == -1);
382        assert(errno == EINVAL);
383
384        errno = 0;
385        rv = fdatasync(sd);
386        assert(rv == -1);
387        assert(errno == EINVAL);
388
389        rv = close(sd);
390        assert(rv == 0);
391
392        assert(rtems_resource_snapshot_check(&snapshot));
393}
394
395static void
396no_mem_socket_fstat(int fd)
397{
398        struct stat st;
399        int rv;
400
401        rv = fstat(fd, &st);
402        assert(rv == 0);
403}
404
405static void
406no_mem_socket_shutdown(int fd)
407{
408        int rv;
409
410        rv = shutdown(fd, SHUT_RDWR);
411        assert(rv == 0);
412}
413
414static void
415test_socket_fstat_and_shutdown(void)
416{
417        mode_t canrecv = S_IRUSR | S_IRGRP | S_IROTH;
418        mode_t cansend = S_IWUSR | S_IWGRP | S_IWOTH;
419        rtems_resource_snapshot snapshot;
420        struct stat st;
421        int sd;
422        int rv;
423
424        puts("test socket fstat and shutdown");
425
426        rtems_resource_snapshot_take(&snapshot);
427
428        sd = socket(PF_INET, SOCK_DGRAM, 0);
429        assert(sd >= 0);
430
431        do_no_mem_test(no_mem_socket_fstat, sd);
432
433        rv = fstat(sd, &st);
434        assert(rv == 0);
435        assert(st.st_mode == (S_IFSOCK | canrecv | cansend));
436
437        rv = shutdown(sd, SHUT_RD);
438        assert(rv == 0);
439
440        rv = fstat(sd, &st);
441        assert(rv == 0);
442        assert(st.st_mode == (S_IFSOCK | cansend));
443
444        rv = shutdown(sd, SHUT_WR);
445        assert(rv == 0);
446
447        rv = fstat(sd, &st);
448        assert(rv == 0);
449        assert(st.st_mode == S_IFSOCK);
450
451        errno = 0;
452        rv = shutdown(sd, ~SHUT_RDWR);
453        assert(rv == -1);
454        assert(errno == EINVAL);
455
456        rv = close(sd);
457        assert(rv == 0);
458
459        sd = socket(PF_INET, SOCK_DGRAM, 0);
460        assert(sd >= 0);
461
462        do_no_mem_test(no_mem_socket_shutdown, sd);
463
464        rv = close(sd);
465        assert(rv == 0);
466
467        errno = 0;
468        rv = shutdown(sd, SHUT_RDWR);
469        assert(rv == -1);
470        assert(errno == EBADF);
471
472        errno = 0;
473        rv = shutdown(0, SHUT_RDWR);
474        assert(rv == -1);
475        assert(errno == ENOTSOCK);
476
477        assert(rtems_resource_snapshot_check(&snapshot));
478}
479
480static void
481no_mem_socket_ioctl(int fd)
482{
483        int rv;
484        int data;
485
486        errno = 0;
487        rv = ioctl(fd, FIONREAD, &data);
488        assert(rv == -1);
489        assert(errno == ENOMEM);
490}
491
492static void
493test_socket_ioctl(void)
494{
495        rtems_resource_snapshot snapshot;
496        int sd;
497        int rv;
498        int data;
499
500        puts("test socket ioctl");
501
502        rtems_resource_snapshot_take(&snapshot);
503
504        sd = socket(PF_INET, SOCK_DGRAM, 0);
505        assert(sd >= 0);
506
507        do_no_mem_test(no_mem_socket_ioctl, sd);
508
509        errno = 0;
510        rv = ioctl(sd, 0xffffffff);
511        assert(rv == -1);
512        assert(errno == EOPNOTSUPP);
513
514        data = -1;
515        rv = ioctl(sd, FIONREAD, &data);
516        assert(rv == 0);
517        assert(data == 0);
518
519        rv = close(sd);
520        assert(rv == 0);
521
522        errno = 0;
523        rv = ioctl(sd, 0);
524        assert(rv == -1);
525        assert(errno == EBADF);
526
527        assert(rtems_resource_snapshot_check(&snapshot));
528}
529
530static void
531no_mem_socket_bind(int fd)
532{
533        struct sockaddr_in addr;
534        int rv;
535
536        errno = 0;
537        rv = bind(fd, (const struct sockaddr *) &addr, sizeof(addr));
538        assert(rv == -1);
539        assert(errno == ENOMEM);
540}
541
542static void
543test_socket_bind(void)
544{
545        rtems_resource_snapshot snapshot;
546        struct sockaddr_in addr;
547        int sd;
548        int rv;
549
550        puts("test socket bind");
551
552        rtems_resource_snapshot_take(&snapshot);
553
554        init_addr(&addr);
555
556        sd = socket(PF_INET, SOCK_DGRAM, 0);
557        assert(sd >= 0);
558
559        do_no_mem_test(no_mem_socket_bind, sd);
560
561        errno = 0;
562        rv = bind(sd, (const struct sockaddr *) &addr, SOCK_MAXADDRLEN + 1);
563        assert(rv == -1);
564        assert(errno == ENAMETOOLONG);
565
566        errno = 0;
567        rv = bind(sd, (const struct sockaddr *) &addr, 0);
568        assert(rv == -1);
569        assert(errno == EINVAL);
570
571        errno = 0;
572        rv = bind(sd, (const struct sockaddr *) &addr, sizeof(addr));
573        assert(rv == -1);
574        assert(errno == EADDRNOTAVAIL);
575
576        rv = close(sd);
577        assert(rv == 0);
578
579        errno = 0;
580        rv = bind(sd, (struct sockaddr *) &addr, sizeof(addr));
581        assert(rv == -1);
582        assert(errno == EBADF);
583
584        assert(rtems_resource_snapshot_check(&snapshot));
585}
586
587static void
588no_mem_socket_connect(int fd)
589{
590        struct sockaddr_in addr;
591        int rv;
592
593        errno = 0;
594        rv = connect(fd, (const struct sockaddr *) &addr, sizeof(addr));
595        assert(rv == -1);
596        assert(errno == ENOMEM);
597}
598
599static void
600test_socket_connect(void)
601{
602        rtems_resource_snapshot snapshot;
603        struct sockaddr_in addr;
604        int sd;
605        int rv;
606
607        puts("test socket connect");
608
609        rtems_resource_snapshot_take(&snapshot);
610
611        init_addr(&addr);
612
613        sd = socket(PF_INET, SOCK_DGRAM, 0);
614        assert(sd >= 0);
615
616        do_no_mem_test(no_mem_socket_connect, sd);
617
618        errno = 0;
619        rv = connect(sd, (const struct sockaddr *) &addr, SOCK_MAXADDRLEN + 1);
620        assert(rv == -1);
621        assert(errno == ENAMETOOLONG);
622
623        errno = 0;
624        rv = connect(sd, (const struct sockaddr *) &addr, 0);
625        assert(rv == -1);
626        assert(errno == EINVAL);
627
628        errno = 0;
629        rv = connect(sd, (const struct sockaddr *) &addr, sizeof(addr));
630        assert(rv == -1);
631        assert(errno == ENETUNREACH);
632
633        rv = close(sd);
634        assert(rv == 0);
635
636        errno = 0;
637        rv = connect(sd, (struct sockaddr *) &addr, sizeof(addr));
638        assert(rv == -1);
639        assert(errno == EBADF);
640
641        assert(rtems_resource_snapshot_check(&snapshot));
642}
643
644static void
645no_mem_socket_listen(int fd)
646{
647        int rv;
648
649        errno = 0;
650        rv = listen(fd, 0);
651        assert(rv == -1);
652        assert(errno == ENOMEM);
653}
654
655static void
656test_socket_listen(void)
657{
658        rtems_resource_snapshot snapshot;
659        int sd;
660        int rv;
661
662        puts("test socket listen");
663
664        rtems_resource_snapshot_take(&snapshot);
665
666        sd = socket(PF_INET, SOCK_DGRAM, 0);
667        assert(sd >= 0);
668
669        do_no_mem_test(no_mem_socket_listen, sd);
670
671        errno = 0;
672        rv = listen(sd, 0);
673        assert(rv == -1);
674        assert(errno == EOPNOTSUPP);
675
676        rv = close(sd);
677        assert(rv == 0);
678
679        errno = 0;
680        rv = listen(sd, 0);
681        assert(rv == -1);
682        assert(errno == EBADF);
683
684        sd = socket(PF_INET, SOCK_STREAM, 0);
685        assert(sd >= 0);
686
687        errno = 0;
688        rv = listen(sd, 0);
689        assert(rv == -1);
690        assert(errno == EADDRNOTAVAIL);
691
692        rv = close(sd);
693        assert(rv == 0);
694
695        assert(rtems_resource_snapshot_check(&snapshot));
696}
697
698static void
699no_mem_socket_accept(int fd)
700{
701        struct sockaddr_in addr;
702        socklen_t addr_len;
703        int rv;
704
705        errno = 0;
706        addr_len = sizeof(addr);
707        rv = accept(fd, (struct sockaddr *) &addr, &addr_len);
708        assert(rv == -1);
709        assert(errno == ENOMEM);
710}
711
712static void
713test_socket_accept(void)
714{
715        rtems_resource_snapshot snapshot;
716        struct sockaddr_in addr;
717        socklen_t addr_len;
718        int sd;
719        int ad;
720        int rv;
721
722        puts("test socket accept");
723
724        rtems_resource_snapshot_take(&snapshot);
725
726        sd = socket(PF_INET, SOCK_STREAM, 0);
727        assert(sd >= 0);
728
729        do_no_mem_test(no_mem_socket_accept, sd);
730
731        errno = 0;
732        addr_len = sizeof(addr);
733        ad = accept(sd, (struct sockaddr *) &addr, &addr_len);
734        assert(ad == -1);
735        assert(errno == EINVAL);
736
737        rv = close(sd);
738        assert(rv == 0);
739
740        errno = 0;
741        addr_len = sizeof(addr);
742        ad = accept(sd, (struct sockaddr *) &addr, &addr_len);
743        assert(ad == -1);
744        assert(errno == EBADF);
745
746        assert(rtems_resource_snapshot_check(&snapshot));
747}
748
749static void
750no_mem_socket_getsockopt_and_setsockopt(int fd)
751{
752        int rv;
753        int optval;
754        socklen_t optlen;
755
756        errno = 0;
757        optlen = sizeof(optval);
758        rv = getsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, &optlen);
759        assert(rv == -1);
760        assert(errno == ENOMEM);
761
762        errno = 0;
763        optlen = sizeof(optval);
764        rv = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, optlen);
765        assert(rv == -1);
766        assert(errno == ENOMEM);
767}
768
769static void
770test_socket_getsockopt_and_setsockopt(void)
771{
772        rtems_resource_snapshot snapshot;
773        int optval;
774        socklen_t optlen;
775        int sd;
776        int rv;
777
778        puts("test socket getsockopt and setsockopt");
779
780        rtems_resource_snapshot_take(&snapshot);
781
782        sd = socket(PF_INET, SOCK_STREAM, 0);
783        assert(sd >= 0);
784
785        do_no_mem_test(no_mem_socket_getsockopt_and_setsockopt, sd);
786
787        errno = 0;
788        optlen = sizeof(optval);
789        rv = getsockopt(sd, SOL_SOCKET, -1, &optval, &optlen);
790        assert(rv == -1);
791        assert(errno == ENOPROTOOPT);
792
793        errno = 0;
794        optlen = sizeof(optval);
795        rv = setsockopt(sd, SOL_SOCKET, -1, &optval, optlen);
796        assert(rv == -1);
797        assert(errno == ENOPROTOOPT);
798
799        errno = 0;
800        optlen = sizeof(optval);
801        rv = getsockopt(sd, -1, SO_REUSEADDR, &optval, &optlen);
802        assert(rv == -1);
803        assert(errno == EINVAL);
804
805        errno = 0;
806        optlen = sizeof(optval);
807        rv = setsockopt(sd, -1, SO_REUSEADDR, &optval, optlen);
808        assert(rv == -1);
809        assert(errno == EINVAL);
810
811        optval = -1;
812        optlen = sizeof(optval);
813        rv = getsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, &optlen);
814        assert(rv == 0);
815        assert(optval == 0);
816        assert(optlen == sizeof(optval));
817
818        optval = 1;
819        optlen = sizeof(optval);
820        rv = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, optlen);
821        assert(rv == 0);
822
823        optval = 0;
824        optlen = sizeof(optval);
825        rv = getsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, &optlen);
826        assert(rv == 0);
827        assert(optval != 0);
828        assert(optlen == sizeof(optval));
829
830        rv = close(sd);
831        assert(rv == 0);
832
833        errno = 0;
834        optlen = sizeof(optval);
835        rv = getsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, &optlen);
836        assert(rv == -1);
837        assert(errno == EBADF);
838
839        errno = 0;
840        optval = 0;
841        optlen = sizeof(optval);
842        rv = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, optlen);
843        assert(rv == -1);
844        assert(errno == EBADF);
845
846        assert(rtems_resource_snapshot_check(&snapshot));
847}
848
849static void
850no_mem_socket_getpeername(int fd)
851{
852        struct sockaddr_in addr;
853        socklen_t addr_len;
854        int rv;
855
856        errno = 0;
857        addr_len = sizeof(addr);
858        rv = getpeername(fd, (struct sockaddr *) &addr, &addr_len);
859        assert(rv == -1);
860        assert(errno == ENOMEM);
861}
862
863static void
864test_socket_getpeername(void)
865{
866        rtems_resource_snapshot snapshot;
867        struct sockaddr_in addr;
868        socklen_t addr_len;
869        int sd;
870        int rv;
871
872        puts("test socket getpeername");
873
874        rtems_resource_snapshot_take(&snapshot);
875
876        sd = socket(PF_INET, SOCK_STREAM, 0);
877        assert(sd >= 0);
878
879        do_no_mem_test(no_mem_socket_getpeername, sd);
880
881        errno = 0;
882        addr_len = sizeof(addr);
883        rv = getpeername(sd, (struct sockaddr *) &addr, &addr_len);
884        assert(rv == -1);
885        assert(errno == ENOTCONN);
886
887        rv = close(sd);
888        assert(rv == 0);
889
890        errno = 0;
891        addr_len = sizeof(addr);
892        rv = getpeername(sd, (struct sockaddr *) &addr, &addr_len);
893        assert(rv == -1);
894        assert(errno == EBADF);
895
896        assert(rtems_resource_snapshot_check(&snapshot));
897}
898
899static void
900no_mem_socket_getsockname(int fd)
901{
902        struct sockaddr_in addr;
903        socklen_t addr_len;
904        int rv;
905
906        errno = 0;
907        addr_len = sizeof(addr);
908        rv = getsockname(fd, (struct sockaddr *) &addr, &addr_len);
909        assert(rv == -1);
910        assert(errno == ENOMEM);
911}
912
913static void
914test_socket_getsockname(void)
915{
916        rtems_resource_snapshot snapshot;
917        struct sockaddr_in addr;
918        struct sockaddr_in expected_addr;
919        socklen_t addr_len;
920        int sd;
921        int rv;
922
923        puts("test socket getsockname");
924
925        rtems_resource_snapshot_take(&snapshot);
926
927        sd = socket(PF_INET, SOCK_STREAM, 0);
928        assert(sd >= 0);
929
930        do_no_mem_test(no_mem_socket_getsockname, sd);
931
932        memset(&addr, 0xff, sizeof(addr));
933        addr_len = sizeof(addr);
934        rv = getsockname(sd, (struct sockaddr *) &addr, &addr_len);
935        assert(rv == 0);
936        memset(&expected_addr, 0, sizeof(expected_addr));
937        expected_addr.sin_len = sizeof(expected_addr);
938        expected_addr.sin_family = AF_INET;
939        assert(memcmp(&addr, &expected_addr, sizeof(addr)) == 0);
940
941        rv = close(sd);
942        assert(rv == 0);
943
944        errno = 0;
945        addr_len = sizeof(addr);
946        rv = getsockname(sd, (struct sockaddr *) &addr, &addr_len);
947        assert(rv == -1);
948        assert(errno == EBADF);
949
950        assert(rtems_resource_snapshot_check(&snapshot));
951}
952
953static void
954no_mem_socket_read_and_write(int fd)
955{
956        ssize_t n;
957        char buf[1];
958
959        errno = 0;
960        n = read(fd, &buf[0], sizeof(buf));
961        assert(n == -1);
962        assert(errno == ENOMEM);
963
964        errno = 0;
965        n = write(fd, &buf[0], sizeof(buf));
966        assert(n == -1);
967        assert(errno == ENOMEM);
968}
969
970static void
971test_socket_read_and_write(void)
972{
973        rtems_resource_snapshot snapshot;
974        int sd;
975        int rv;
976        ssize_t n;
977        char buf[1];
978        int enable = 1;
979
980        puts("test socket read and write");
981
982        rtems_resource_snapshot_take(&snapshot);
983
984        sd = socket(PF_INET, SOCK_DGRAM, 0);
985        assert(sd >= 0);
986
987        rv = ioctl(sd, FIONBIO, &enable);
988        assert(rv == 0);
989
990        do_no_mem_test(no_mem_socket_read_and_write, sd);
991
992        errno = 0;
993        n = read(sd, &buf[0], sizeof(buf));
994        assert(n == -1);
995        assert(errno == EAGAIN);
996
997        errno = 0;
998        n = write(sd, &buf[0], sizeof(buf));
999        assert(n == -1);
1000        assert(errno == EDESTADDRREQ);
1001
1002        rv = close(sd);
1003        assert(rv == 0);
1004
1005        errno = 0;
1006        n = read(sd, &buf[0], sizeof(buf));
1007        assert(n == -1);
1008        assert(errno == EBADF);
1009
1010        errno = 0;
1011        n = write(sd, &buf[0], sizeof(buf));
1012        assert(n == -1);
1013        assert(errno == EBADF);
1014
1015        assert(rtems_resource_snapshot_check(&snapshot));
1016}
1017
1018static void
1019no_mem_socket_send_and_sendto_and_sendmsg(int fd)
1020{
1021        struct sockaddr_in addr;
1022        struct iovec iov;
1023        struct msghdr msg;
1024        ssize_t n;
1025        char buf[1];
1026
1027        init_addr(&addr);
1028        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
1029
1030        errno = 0;
1031        n = send(fd, &buf[0], sizeof(buf), 0);
1032        assert(n == -1);
1033        assert(errno == ENOMEM);
1034
1035        errno = 0;
1036        n = sendto(fd, &buf[0], sizeof(buf), 0,
1037            (const struct sockaddr *) &addr, sizeof(addr));
1038        assert(n == -1);
1039        assert(errno == ENOMEM);
1040
1041        errno = 0;
1042        n = sendmsg(fd, &msg, 0);
1043        assert(n == -1);
1044        assert(errno == ENOMEM);
1045}
1046
1047static void
1048test_socket_send_and_sendto_and_sendmsg(void)
1049{
1050        rtems_resource_snapshot snapshot;
1051        struct sockaddr_in addr;
1052        struct iovec iov;
1053        struct msghdr msg;
1054        int sd;
1055        int rv;
1056        ssize_t n;
1057        char buf[1];
1058
1059        puts("test socket send, sendto and sendmsg");
1060
1061        rtems_resource_snapshot_take(&snapshot);
1062
1063        init_addr(&addr);
1064        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
1065
1066        sd = socket(PF_INET, SOCK_DGRAM, 0);
1067        assert(sd >= 0);
1068
1069        do_no_mem_test(no_mem_socket_send_and_sendto_and_sendmsg, sd);
1070
1071        errno = 0;
1072        n = send(sd, &buf[0], sizeof(buf), 0);
1073        assert(n == -1);
1074        assert(errno == EDESTADDRREQ);
1075
1076        errno = 0;
1077        n = sendto(sd, &buf[0], sizeof(buf), 0,
1078            (const struct sockaddr *) &addr, sizeof(addr));
1079        assert(n == -1);
1080        assert(errno == ENETUNREACH);
1081
1082        errno = 0;
1083        n = sendmsg(sd, &msg, 0);
1084        assert(n == -1);
1085        assert(errno == ENETUNREACH);
1086
1087        rv = close(sd);
1088        assert(rv == 0);
1089
1090        errno = 0;
1091        n = send(sd, &buf[0], sizeof(buf), 0);
1092        assert(n == -1);
1093        assert(errno == EBADF);
1094
1095        errno = 0;
1096        n = sendto(sd, &buf[0], sizeof(buf), 0,
1097            (const struct sockaddr *) &addr, sizeof(addr));
1098        assert(n == -1);
1099        assert(errno == EBADF);
1100
1101        errno = 0;
1102        n = sendmsg(sd, &msg, 0);
1103        assert(n == -1);
1104        assert(errno == EBADF);
1105
1106        assert(rtems_resource_snapshot_check(&snapshot));
1107}
1108
1109static void
1110no_mem_socket_recv_and_recvfrom_and_recvmsg(int fd)
1111{
1112        struct sockaddr_in addr;
1113        socklen_t addr_len;
1114        struct iovec iov;
1115        struct msghdr msg;
1116        ssize_t n;
1117        char buf[1];
1118
1119        init_addr(&addr);
1120        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
1121
1122        errno = 0;
1123        n = recv(fd, &buf[0], sizeof(buf), 0);
1124        assert(n == -1);
1125        assert(errno == ENOMEM);
1126
1127        errno = 0;
1128        addr_len = sizeof(addr);
1129        n = recvfrom(fd, &buf[0], sizeof(buf), 0,
1130            (struct sockaddr *) &addr, &addr_len);
1131        assert(n == -1);
1132        assert(errno == ENOMEM);
1133
1134        errno = 0;
1135        n = recvmsg(fd, &msg, 0);
1136        assert(n == -1);
1137        assert(errno == ENOMEM);
1138}
1139
1140static void
1141test_socket_recv_and_recvfrom_and_recvmsg(void)
1142{
1143        rtems_resource_snapshot snapshot;
1144        struct sockaddr_in addr;
1145        socklen_t addr_len;
1146        struct iovec iov;
1147        struct msghdr msg;
1148        int sd;
1149        int rv;
1150        ssize_t n;
1151        char buf[1];
1152        int enable = 1;
1153
1154        puts("test socket recv, recvfrom and recvmsg");
1155
1156        rtems_resource_snapshot_take(&snapshot);
1157
1158        init_addr(&addr);
1159        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
1160
1161        sd = socket(PF_INET, SOCK_DGRAM, 0);
1162        assert(sd >= 0);
1163
1164        rv = ioctl(sd, FIONBIO, &enable);
1165        assert(rv == 0);
1166
1167        do_no_mem_test(no_mem_socket_recv_and_recvfrom_and_recvmsg, sd);
1168
1169        errno = 0;
1170        n = recv(sd, &buf[0], sizeof(buf), 0);
1171        assert(n == -1);
1172        assert(errno == EAGAIN);
1173
1174        errno = 0;
1175        addr_len = sizeof(addr);
1176        n = recvfrom(sd, &buf[0], sizeof(buf), 0,
1177            (struct sockaddr *) &addr, &addr_len);
1178        assert(n == -1);
1179        assert(errno == EAGAIN);
1180
1181        errno = 0;
1182        n = recvmsg(sd, &msg, 0);
1183        assert(n == -1);
1184        assert(errno == EAGAIN);
1185
1186        rv = close(sd);
1187        assert(rv == 0);
1188
1189        errno = 0;
1190        n = recv(sd, &buf[0], sizeof(buf), 0);
1191        assert(n == -1);
1192        assert(errno == EBADF);
1193
1194        errno = 0;
1195        addr_len = sizeof(addr);
1196        n = recvfrom(sd, &buf[0], sizeof(buf), 0,
1197            (struct sockaddr *) &addr, &addr_len);
1198        assert(n == -1);
1199        assert(errno == EBADF);
1200
1201        errno = 0;
1202        n = recvmsg(sd, &msg, 0);
1203        assert(n == -1);
1204        assert(errno == EBADF);
1205
1206        assert(rtems_resource_snapshot_check(&snapshot));
1207}
1208
1209static const char prog_name[] = "prog";
1210
1211static int
1212invalid_prog(void *ctx)
1213{
1214        (void) ctx;
1215
1216        assert(0);
1217}
1218
1219static int
1220invalid_main(int argc, char **argv)
1221{
1222        (void) argc;
1223        (void) argv;
1224
1225        assert(0);
1226}
1227
1228static void *const some_context = (void *) 0xcafe;
1229
1230static int
1231some_prog(void *ctx)
1232{
1233        assert(ctx == some_context);
1234        assert(strcmp(rtems_bsd_program_get_name(), prog_name) == 0);
1235        assert(rtems_bsd_program_get_context() == some_context);
1236        errno = 0;
1237        rtems_bsd_program_exit(456);
1238}
1239
1240static const int some_argc = 1;
1241
1242static char *some_argv[] = { "a", NULL };
1243
1244static int
1245some_main(int argc, char **argv)
1246{
1247        assert(argc == some_argc);
1248        assert(argv == some_argv);
1249        assert(strcmp(rtems_bsd_program_get_name(), prog_name) == 0);
1250        errno = 0;
1251        rtems_bsd_program_exit(789);
1252}
1253
1254static void
1255no_mem_bsd_program(int fd)
1256{
1257        (void) fd;
1258
1259        assert(rtems_bsd_program_call(prog_name, invalid_prog, NULL)
1260            == EXIT_FAILURE);
1261        assert(rtems_bsd_program_call_main(prog_name, invalid_main, some_argc,
1262            some_argv) == EXIT_FAILURE);
1263        assert(strcmp(rtems_bsd_program_get_name(), "?") == 0);
1264        assert(rtems_bsd_program_get_context() == NULL);
1265}
1266
1267static void
1268test_bsd_program(void)
1269{
1270        rtems_resource_snapshot snapshot;
1271        int exit_code;
1272        void *greedy;
1273        char *invalid_argv[2] = { "a", "b" };
1274
1275        assert(rtems_configuration_get_unified_work_area());
1276
1277        puts("test BSD program");
1278
1279        rtems_resource_snapshot_take(&snapshot);
1280
1281        do_no_mem_test(no_mem_bsd_program, -1);
1282
1283        greedy = rtems_workspace_greedy_allocate(NULL, 0);
1284        no_mem_bsd_program(-1);
1285        rtems_workspace_greedy_free(greedy);
1286
1287        errno = 0;
1288        exit_code = rtems_bsd_program_call_main(prog_name, NULL, 1, invalid_argv);
1289        assert(errno == EFAULT);
1290        assert(exit_code == EXIT_FAILURE);
1291
1292        errno = EINVAL;
1293        exit_code = rtems_bsd_program_call(prog_name, some_prog, some_context);
1294        assert(errno == 0);
1295        assert(exit_code == 456);
1296        assert(strcmp(rtems_bsd_program_get_name(), "?") == 0);
1297        assert(rtems_bsd_program_get_context() == NULL);
1298
1299        errno = EINVAL;
1300        exit_code = rtems_bsd_program_call_main(prog_name, some_main,
1301            some_argc, some_argv);
1302        assert(errno == 0);
1303        assert(exit_code == 789);
1304        assert(strcmp(rtems_bsd_program_get_name(), "?") == 0);
1305        assert(rtems_bsd_program_get_context() == NULL);
1306
1307        assert(rtems_resource_snapshot_check(&snapshot));
1308}
1309
1310static void
1311test_warn(void)
1312{
1313        puts("test warn");
1314
1315        errno = EAGAIN;
1316        warn("%s", "warn");
1317
1318        errno = ENAMETOOLONG;
1319        warn(NULL);
1320
1321        errno = 0;
1322        warnc(EDOM, "%s", "warnc");
1323
1324        errno = 0;
1325        warnc(ERANGE, NULL);
1326
1327        warnx("%s", "warnx");
1328
1329        warnx(NULL);
1330}
1331
1332static int
1333call_err(void *ctx)
1334{
1335        errno = EAGAIN;
1336        err(10, "%s", "call_err");
1337}
1338
1339static int
1340call_err_null(void *ctx)
1341{
1342        errno = ENAMETOOLONG;
1343        err(11, NULL);
1344}
1345
1346static int
1347call_errc(void *ctx)
1348{
1349        errc(12, EDOM, "%s", "call_errc");
1350}
1351
1352static int
1353call_errc_null(void *ctx)
1354{
1355        errc(13, ERANGE, NULL);
1356}
1357
1358static int
1359call_errx(void *ctx)
1360{
1361        errx(14, "%s", "call_errx");
1362}
1363
1364static int
1365call_errx_null(void *ctx)
1366{
1367        errx(15, NULL);
1368}
1369
1370static void
1371test_err(void)
1372{
1373        int exit_code;
1374
1375        puts("test err");
1376
1377        exit_code = rtems_bsd_program_call("err", call_err, NULL);
1378        assert(exit_code == 10);
1379
1380        exit_code = rtems_bsd_program_call("err", call_err_null, NULL);
1381        assert(exit_code == 11);
1382
1383        exit_code = rtems_bsd_program_call("errc", call_errc, NULL);
1384        assert(exit_code == 12);
1385
1386        exit_code = rtems_bsd_program_call("errc", call_errc_null, NULL);
1387        assert(exit_code == 13);
1388
1389        exit_code = rtems_bsd_program_call("errx", call_errx, NULL);
1390        assert(exit_code == 14);
1391
1392        exit_code = rtems_bsd_program_call("errx", call_errx_null, NULL);
1393        assert(exit_code == 15);
1394}
1395
1396static void
1397test_main(void)
1398{
1399        /* Must be first test to ensure resource checks work */
1400        test_sockets();
1401
1402        test_socket_unsupported_ops();
1403        test_socket_fstat_and_shutdown();
1404        test_socket_ioctl();
1405        test_socket_bind();
1406        test_socket_connect();
1407        test_socket_listen();
1408        test_socket_accept();
1409        test_socket_getsockopt_and_setsockopt();
1410        test_socket_getpeername();
1411        test_socket_getsockname();
1412        test_socket_read_and_write();
1413        test_socket_send_and_sendto_and_sendmsg();
1414        test_socket_recv_and_recvfrom_and_recvmsg();
1415
1416        test_bsd_program();
1417        test_warn();
1418        test_err();
1419
1420        puts("*** END OF " TEST_NAME " TEST ***");
1421        exit(0);
1422}
1423
1424#include <rtems/bsd/test/default-init.h>
Note: See TracBrowser for help on using the repository browser.