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

55-freebsd-126-freebsd-12
Last change on this file since e6f6b5e was a1e4757, checked in by Sebastian Huber <sebastian.huber@…>, on 07/02/18 at 07:16:14

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