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

5-freebsd-12
Last change on this file since 6fb003f was 6fb003f, checked in by Sebastian Huber <sebastian.huber@…>, on Jul 26, 2018 at 10:03:45 AM

Fix sporadic test failures via uma_timeout()

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