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

4.115-freebsd-12freebsd-9.3
Last change on this file since facf9dc was facf9dc, checked in by Sebastian Huber <sebastian.huber@…>, on Oct 23, 2013 at 2:10:26 PM

Use select() from FreeBSD

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