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

55-freebsd-126-freebsd-12freebsd-9.3
Last change on this file since dd96574 was dd96574, checked in by Sebastian Huber <sebastian.huber@…>, on Nov 16, 2015 at 8:51:44 AM

SOCKETPAIR(2): Port to RTEMS

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