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

55-freebsd-126-freebsd-12
Last change on this file since eeeda4b was eeeda4b, checked in by Sebastian Huber <sebastian.huber@…>, on Nov 10, 2017 at 10:17:13 AM

tests/syscall01: Update error values

FreeBSD changed the error values.

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