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

5-freebsd-12
Last change on this file was 43a39b7, checked in by Sebastian Huber <sebastian.huber@…>, on Aug 28, 2018 at 10:51:49 AM

syscalls01: Fix for IPSEC enabled

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