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

4.1155-freebsd-126-freebsd-12freebsd-9.3
Last change on this file since 5feec90 was 5feec90, checked in by Sebastian Huber <sebastian.huber@…>, on 12/20/13 at 13:14:05

syscalls01: Include missing header file
  • Property mode set to 100644
File size: 35.6 KB
Line 
1/*
2 * Copyright (c) 2013 embedded brains GmbH.  All rights reserved.
3 *
4 *  embedded brains GmbH
5 *  Dornierstr. 4
6 *  82178 Puchheim
7 *  Germany
8 *  <rtems@embedded-brains.de>
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33#include <sys/types.h>
34#include <sys/event.h>
35#include <sys/poll.h>
36#include <sys/stat.h>
37#include <sys/select.h>
38#include <sys/socket.h>
39#include <sys/time.h>
40#include <sys/filio.h>
41#include <netinet/in.h>
42#include <arpa/inet.h>
43#include <err.h>
44
45#include <assert.h>
46#include <errno.h>
47#include <limits.h>
48#include <stdbool.h>
49#include <stdio.h>
50#include <stdlib.h>
51#include <string.h>
52#include <unistd.h>
53
54#define RTEMS_BSD_PROGRAM_NO_EXIT_WRAP
55#define RTEMS_BSD_PROGRAM_NO_PRINTF_WRAP
56#include <machine/rtems-bsd-program.h>
57
58#include <rtems.h>
59#include <rtems/libcsupport.h>
60
61#define TEST_NAME "LIBBSD SYSCALLS 1"
62
63typedef void (*no_mem_test_body)(int fd);
64
65typedef struct {
66        no_mem_test_body body;
67        int fd;
68        rtems_id master_task;
69} no_mem_test;
70
71typedef struct {
72        int domain;
73        int type;
74        int protocol;
75        int expect_errno;
76} socket_test;
77
78static socket_test socket_tests[] = {
79        { -1, SOCK_RAW, 0, EPROTONOSUPPORT },
80        { PF_UNSPEC, SOCK_DGRAM, 0, EPROTONOSUPPORT },
81        { PF_UNIX, SOCK_DGRAM, 0, EPROTONOSUPPORT },
82        { PF_INET, -1, 0, EPROTONOSUPPORT },
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, EPROTONOSUPPORT },
87        { PF_INET, SOCK_RAW, IPPROTO_3PC, 0 },
88        { PF_INET, SOCK_RAW, IPPROTO_ADFS, 0 },
89        { PF_INET, SOCK_RAW, IPPROTO_AH, EPROTONOSUPPORT },
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, EPROTONOSUPPORT },
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, EPROTONOSUPPORT },
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, EPROTONOSUPPORT },
196        { PF_PUP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
197        { PF_CHAOS, SOCK_DGRAM, 0, EPROTONOSUPPORT },
198        { PF_NETBIOS, SOCK_DGRAM, 0, EPROTONOSUPPORT },
199        { PF_ISO, SOCK_DGRAM, 0, EPROTONOSUPPORT },
200        { PF_ECMA, SOCK_DGRAM, 0, EPROTONOSUPPORT },
201        { PF_DATAKIT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
202        { PF_CCITT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
203        { PF_SNA, SOCK_DGRAM, 0, EPROTONOSUPPORT },
204        { PF_DECnet, SOCK_DGRAM, 0, EPROTONOSUPPORT },
205        { PF_DLI, SOCK_DGRAM, 0, EPROTONOSUPPORT },
206        { PF_LAT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
207        { PF_HYLINK, SOCK_DGRAM, 0, EPROTONOSUPPORT },
208        { PF_APPLETALK, SOCK_DGRAM, 0, EPROTONOSUPPORT },
209        { PF_ROUTE, SOCK_DGRAM, 0, EPROTONOSUPPORT },
210        { PF_LINK, SOCK_DGRAM, 0, EPROTONOSUPPORT },
211        { PF_XTP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
212        { PF_COIP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
213        { PF_CNT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
214        { PF_RTIP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
215        { PF_IPX, SOCK_DGRAM, 0, EPROTONOSUPPORT },
216        { PF_SIP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
217        { PF_PIP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
218        { PF_ISDN, SOCK_DGRAM, 0, EPROTONOSUPPORT },
219        { PF_KEY, SOCK_DGRAM, 0, EPROTONOSUPPORT },
220        { PF_INET6, SOCK_DGRAM, 0, 0 },
221        { PF_NATM, SOCK_DGRAM, 0, EPROTONOSUPPORT },
222        { PF_ATM, SOCK_DGRAM, 0, EPROTONOSUPPORT },
223        { pseudo_AF_HDRCMPLT, SOCK_DGRAM, 0, EPROTONOSUPPORT },
224        { PF_NETGRAPH, SOCK_DGRAM, 0, EPROTONOSUPPORT },
225        { PF_SLOW, SOCK_DGRAM, 0, EPROTONOSUPPORT },
226        { PF_SCLUSTER, SOCK_DGRAM, 0, EPROTONOSUPPORT },
227        { PF_ARP, SOCK_DGRAM, 0, EPROTONOSUPPORT },
228        { PF_BLUETOOTH, SOCK_DGRAM, 0, EPROTONOSUPPORT },
229        { AF_IEEE80211, SOCK_DGRAM, 0, EPROTONOSUPPORT }
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 stat st;
427        int sd;
428        int rv;
429
430        puts("test socket fstat and shutdown");
431
432        rtems_resource_snapshot_take(&snapshot);
433
434        sd = socket(PF_INET, SOCK_DGRAM, 0);
435        assert(sd >= 0);
436
437        do_no_mem_test(no_mem_socket_fstat, sd);
438
439        rv = fstat(sd, &st);
440        assert(rv == 0);
441        assert(st.st_mode == (S_IFSOCK | canrecv | cansend));
442
443        rv = shutdown(sd, SHUT_RD);
444        assert(rv == 0);
445
446        rv = fstat(sd, &st);
447        assert(rv == 0);
448        assert(st.st_mode == (S_IFSOCK | cansend));
449
450        rv = shutdown(sd, SHUT_WR);
451        assert(rv == 0);
452
453        rv = fstat(sd, &st);
454        assert(rv == 0);
455        assert(st.st_mode == S_IFSOCK);
456
457        errno = 0;
458        rv = shutdown(sd, ~SHUT_RDWR);
459        assert(rv == -1);
460        assert(errno == EINVAL);
461
462        rv = close(sd);
463        assert(rv == 0);
464
465        sd = socket(PF_INET, SOCK_DGRAM, 0);
466        assert(sd >= 0);
467
468        do_no_mem_test(no_mem_socket_shutdown, sd);
469
470        rv = close(sd);
471        assert(rv == 0);
472
473        errno = 0;
474        rv = shutdown(sd, SHUT_RDWR);
475        assert(rv == -1);
476        assert(errno == EBADF);
477
478        errno = 0;
479        rv = shutdown(0, SHUT_RDWR);
480        assert(rv == -1);
481        assert(errno == ENOTSOCK);
482
483        assert(rtems_resource_snapshot_check(&snapshot));
484}
485
486static void
487no_mem_socket_ioctl(int fd)
488{
489        int rv;
490        int data;
491
492        errno = 0;
493        rv = ioctl(fd, FIONREAD, &data);
494        assert(rv == -1);
495        assert(errno == ENOMEM);
496}
497
498static void
499test_socket_ioctl(void)
500{
501        rtems_resource_snapshot snapshot;
502        int sd;
503        int rv;
504        int data;
505
506        puts("test socket ioctl");
507
508        rtems_resource_snapshot_take(&snapshot);
509
510        sd = socket(PF_INET, SOCK_DGRAM, 0);
511        assert(sd >= 0);
512
513        do_no_mem_test(no_mem_socket_ioctl, sd);
514
515        errno = 0;
516        rv = ioctl(sd, 0xffffffff);
517        assert(rv == -1);
518        assert(errno == EOPNOTSUPP);
519
520        data = -1;
521        rv = ioctl(sd, FIONREAD, &data);
522        assert(rv == 0);
523        assert(data == 0);
524
525        rv = close(sd);
526        assert(rv == 0);
527
528        errno = 0;
529        rv = ioctl(sd, 0);
530        assert(rv == -1);
531        assert(errno == EBADF);
532
533        assert(rtems_resource_snapshot_check(&snapshot));
534}
535
536static void
537no_mem_socket_bind(int fd)
538{
539        struct sockaddr_in addr;
540        int rv;
541
542        errno = 0;
543        rv = bind(fd, (const struct sockaddr *) &addr, sizeof(addr));
544        assert(rv == -1);
545        assert(errno == ENOMEM);
546}
547
548static void
549test_socket_bind(void)
550{
551        rtems_resource_snapshot snapshot;
552        struct sockaddr_in addr;
553        int sd;
554        int rv;
555
556        puts("test socket bind");
557
558        rtems_resource_snapshot_take(&snapshot);
559
560        init_addr(&addr);
561
562        sd = socket(PF_INET, SOCK_DGRAM, 0);
563        assert(sd >= 0);
564
565        do_no_mem_test(no_mem_socket_bind, sd);
566
567        errno = 0;
568        rv = bind(sd, (const struct sockaddr *) &addr, SOCK_MAXADDRLEN + 1);
569        assert(rv == -1);
570        assert(errno == ENAMETOOLONG);
571
572        errno = 0;
573        rv = bind(sd, (const struct sockaddr *) &addr, 0);
574        assert(rv == -1);
575        assert(errno == EINVAL);
576
577        errno = 0;
578        rv = bind(sd, (const struct sockaddr *) &addr, sizeof(addr));
579        assert(rv == -1);
580        assert(errno == EADDRNOTAVAIL);
581
582        rv = close(sd);
583        assert(rv == 0);
584
585        errno = 0;
586        rv = bind(sd, (struct sockaddr *) &addr, sizeof(addr));
587        assert(rv == -1);
588        assert(errno == EBADF);
589
590        assert(rtems_resource_snapshot_check(&snapshot));
591}
592
593static void
594no_mem_socket_connect(int fd)
595{
596        struct sockaddr_in addr;
597        int rv;
598
599        errno = 0;
600        rv = connect(fd, (const struct sockaddr *) &addr, sizeof(addr));
601        assert(rv == -1);
602        assert(errno == ENOMEM);
603}
604
605static void
606test_socket_connect(void)
607{
608        rtems_resource_snapshot snapshot;
609        struct sockaddr_in addr;
610        int sd;
611        int rv;
612
613        puts("test socket connect");
614
615        rtems_resource_snapshot_take(&snapshot);
616
617        init_addr(&addr);
618
619        sd = socket(PF_INET, SOCK_DGRAM, 0);
620        assert(sd >= 0);
621
622        do_no_mem_test(no_mem_socket_connect, sd);
623
624        errno = 0;
625        rv = connect(sd, (const struct sockaddr *) &addr, SOCK_MAXADDRLEN + 1);
626        assert(rv == -1);
627        assert(errno == ENAMETOOLONG);
628
629        errno = 0;
630        rv = connect(sd, (const struct sockaddr *) &addr, 0);
631        assert(rv == -1);
632        assert(errno == EINVAL);
633
634        errno = 0;
635        rv = connect(sd, (const struct sockaddr *) &addr, sizeof(addr));
636        assert(rv == -1);
637        assert(errno == ENETUNREACH);
638
639        rv = close(sd);
640        assert(rv == 0);
641
642        errno = 0;
643        rv = connect(sd, (struct sockaddr *) &addr, sizeof(addr));
644        assert(rv == -1);
645        assert(errno == EBADF);
646
647        assert(rtems_resource_snapshot_check(&snapshot));
648}
649
650static void
651no_mem_socket_listen(int fd)
652{
653        int rv;
654
655        errno = 0;
656        rv = listen(fd, 0);
657        assert(rv == -1);
658        assert(errno == ENOMEM);
659}
660
661static void
662test_socket_listen(void)
663{
664        rtems_resource_snapshot snapshot;
665        int sd;
666        int rv;
667
668        puts("test socket listen");
669
670        rtems_resource_snapshot_take(&snapshot);
671
672        sd = socket(PF_INET, SOCK_DGRAM, 0);
673        assert(sd >= 0);
674
675        do_no_mem_test(no_mem_socket_listen, sd);
676
677        errno = 0;
678        rv = listen(sd, 0);
679        assert(rv == -1);
680        assert(errno == EOPNOTSUPP);
681
682        rv = close(sd);
683        assert(rv == 0);
684
685        errno = 0;
686        rv = listen(sd, 0);
687        assert(rv == -1);
688        assert(errno == EBADF);
689
690        sd = socket(PF_INET, SOCK_STREAM, 0);
691        assert(sd >= 0);
692
693        errno = 0;
694        rv = listen(sd, 0);
695        assert(rv == -1);
696        assert(errno == EADDRNOTAVAIL);
697
698        rv = close(sd);
699        assert(rv == 0);
700
701        assert(rtems_resource_snapshot_check(&snapshot));
702}
703
704static void
705no_mem_socket_accept(int fd)
706{
707        struct sockaddr_in addr;
708        socklen_t addr_len;
709        int rv;
710
711        errno = 0;
712        addr_len = sizeof(addr);
713        rv = accept(fd, (struct sockaddr *) &addr, &addr_len);
714        assert(rv == -1);
715        assert(errno == ENOMEM);
716}
717
718static void
719test_socket_accept(void)
720{
721        rtems_resource_snapshot snapshot;
722        struct sockaddr_in addr;
723        socklen_t addr_len;
724        int sd;
725        int ad;
726        int rv;
727
728        puts("test socket accept");
729
730        rtems_resource_snapshot_take(&snapshot);
731
732        sd = socket(PF_INET, SOCK_STREAM, 0);
733        assert(sd >= 0);
734
735        do_no_mem_test(no_mem_socket_accept, sd);
736
737        errno = 0;
738        addr_len = sizeof(addr);
739        ad = accept(sd, (struct sockaddr *) &addr, &addr_len);
740        assert(ad == -1);
741        assert(errno == EINVAL);
742
743        rv = close(sd);
744        assert(rv == 0);
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 == EBADF);
751
752        assert(rtems_resource_snapshot_check(&snapshot));
753}
754
755static void
756no_mem_socket_getsockopt_and_setsockopt(int fd)
757{
758        int rv;
759        int optval;
760        socklen_t optlen;
761
762        errno = 0;
763        optlen = sizeof(optval);
764        rv = getsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, &optlen);
765        assert(rv == -1);
766        assert(errno == ENOMEM);
767
768        errno = 0;
769        optlen = sizeof(optval);
770        rv = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, optlen);
771        assert(rv == -1);
772        assert(errno == ENOMEM);
773}
774
775static void
776test_socket_getsockopt_and_setsockopt(void)
777{
778        rtems_resource_snapshot snapshot;
779        int optval;
780        socklen_t optlen;
781        int sd;
782        int rv;
783
784        puts("test socket getsockopt and setsockopt");
785
786        rtems_resource_snapshot_take(&snapshot);
787
788        sd = socket(PF_INET, SOCK_STREAM, 0);
789        assert(sd >= 0);
790
791        do_no_mem_test(no_mem_socket_getsockopt_and_setsockopt, sd);
792
793        errno = 0;
794        optlen = sizeof(optval);
795        rv = getsockopt(sd, SOL_SOCKET, -1, &optval, &optlen);
796        assert(rv == -1);
797        assert(errno == ENOPROTOOPT);
798
799        errno = 0;
800        optlen = sizeof(optval);
801        rv = setsockopt(sd, SOL_SOCKET, -1, &optval, optlen);
802        assert(rv == -1);
803        assert(errno == ENOPROTOOPT);
804
805        errno = 0;
806        optlen = sizeof(optval);
807        rv = getsockopt(sd, -1, SO_REUSEADDR, &optval, &optlen);
808        assert(rv == -1);
809        assert(errno == EINVAL);
810
811        errno = 0;
812        optlen = sizeof(optval);
813        rv = setsockopt(sd, -1, SO_REUSEADDR, &optval, optlen);
814        assert(rv == -1);
815        assert(errno == EINVAL);
816
817        optval = -1;
818        optlen = sizeof(optval);
819        rv = getsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, &optlen);
820        assert(rv == 0);
821        assert(optval == 0);
822        assert(optlen == sizeof(optval));
823
824        optval = 1;
825        optlen = sizeof(optval);
826        rv = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, optlen);
827        assert(rv == 0);
828
829        optval = 0;
830        optlen = sizeof(optval);
831        rv = getsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, &optlen);
832        assert(rv == 0);
833        assert(optval != 0);
834        assert(optlen == sizeof(optval));
835
836        rv = close(sd);
837        assert(rv == 0);
838
839        errno = 0;
840        optlen = sizeof(optval);
841        rv = getsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, &optlen);
842        assert(rv == -1);
843        assert(errno == EBADF);
844
845        errno = 0;
846        optval = 0;
847        optlen = sizeof(optval);
848        rv = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, optlen);
849        assert(rv == -1);
850        assert(errno == EBADF);
851
852        assert(rtems_resource_snapshot_check(&snapshot));
853}
854
855static void
856no_mem_socket_getpeername(int fd)
857{
858        struct sockaddr_in addr;
859        socklen_t addr_len;
860        int rv;
861
862        errno = 0;
863        addr_len = sizeof(addr);
864        rv = getpeername(fd, (struct sockaddr *) &addr, &addr_len);
865        assert(rv == -1);
866        assert(errno == ENOMEM);
867}
868
869static void
870test_socket_getpeername(void)
871{
872        rtems_resource_snapshot snapshot;
873        struct sockaddr_in addr;
874        socklen_t addr_len;
875        int sd;
876        int rv;
877
878        puts("test socket getpeername");
879
880        rtems_resource_snapshot_take(&snapshot);
881
882        sd = socket(PF_INET, SOCK_STREAM, 0);
883        assert(sd >= 0);
884
885        do_no_mem_test(no_mem_socket_getpeername, sd);
886
887        errno = 0;
888        addr_len = sizeof(addr);
889        rv = getpeername(sd, (struct sockaddr *) &addr, &addr_len);
890        assert(rv == -1);
891        assert(errno == ENOTCONN);
892
893        rv = close(sd);
894        assert(rv == 0);
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 == EBADF);
901
902        assert(rtems_resource_snapshot_check(&snapshot));
903}
904
905static void
906no_mem_socket_getsockname(int fd)
907{
908        struct sockaddr_in addr;
909        socklen_t addr_len;
910        int rv;
911
912        errno = 0;
913        addr_len = sizeof(addr);
914        rv = getsockname(fd, (struct sockaddr *) &addr, &addr_len);
915        assert(rv == -1);
916        assert(errno == ENOMEM);
917}
918
919static void
920test_socket_getsockname(void)
921{
922        rtems_resource_snapshot snapshot;
923        struct sockaddr_in addr;
924        struct sockaddr_in expected_addr;
925        socklen_t addr_len;
926        int sd;
927        int rv;
928
929        puts("test socket getsockname");
930
931        rtems_resource_snapshot_take(&snapshot);
932
933        sd = socket(PF_INET, SOCK_STREAM, 0);
934        assert(sd >= 0);
935
936        do_no_mem_test(no_mem_socket_getsockname, sd);
937
938        memset(&addr, 0xff, sizeof(addr));
939        addr_len = sizeof(addr);
940        rv = getsockname(sd, (struct sockaddr *) &addr, &addr_len);
941        assert(rv == 0);
942        memset(&expected_addr, 0, sizeof(expected_addr));
943        expected_addr.sin_len = sizeof(expected_addr);
944        expected_addr.sin_family = AF_INET;
945        assert(memcmp(&addr, &expected_addr, sizeof(addr)) == 0);
946
947        rv = close(sd);
948        assert(rv == 0);
949
950        errno = 0;
951        addr_len = sizeof(addr);
952        rv = getsockname(sd, (struct sockaddr *) &addr, &addr_len);
953        assert(rv == -1);
954        assert(errno == EBADF);
955
956        assert(rtems_resource_snapshot_check(&snapshot));
957}
958
959static void
960no_mem_socket_read_and_write(int fd)
961{
962        ssize_t n;
963        char buf[1];
964
965        errno = 0;
966        n = read(fd, &buf[0], sizeof(buf));
967        assert(n == -1);
968        assert(errno == ENOMEM);
969
970        errno = 0;
971        n = write(fd, &buf[0], sizeof(buf));
972        assert(n == -1);
973        assert(errno == ENOMEM);
974}
975
976static void
977test_socket_read_and_write(void)
978{
979        rtems_resource_snapshot snapshot;
980        int sd;
981        int rv;
982        ssize_t n;
983        char buf[1];
984        int enable = 1;
985
986        puts("test socket read and write");
987
988        rtems_resource_snapshot_take(&snapshot);
989
990        sd = socket(PF_INET, SOCK_DGRAM, 0);
991        assert(sd >= 0);
992
993        rv = ioctl(sd, FIONBIO, &enable);
994        assert(rv == 0);
995
996        do_no_mem_test(no_mem_socket_read_and_write, sd);
997
998        errno = 0;
999        n = read(sd, &buf[0], sizeof(buf));
1000        assert(n == -1);
1001        assert(errno == EAGAIN);
1002
1003        errno = 0;
1004        n = write(sd, &buf[0], sizeof(buf));
1005        assert(n == -1);
1006        assert(errno == EDESTADDRREQ);
1007
1008        rv = close(sd);
1009        assert(rv == 0);
1010
1011        errno = 0;
1012        n = read(sd, &buf[0], sizeof(buf));
1013        assert(n == -1);
1014        assert(errno == EBADF);
1015
1016        errno = 0;
1017        n = write(sd, &buf[0], sizeof(buf));
1018        assert(n == -1);
1019        assert(errno == EBADF);
1020
1021        assert(rtems_resource_snapshot_check(&snapshot));
1022}
1023
1024static void
1025no_mem_socket_send_and_sendto_and_sendmsg(int fd)
1026{
1027        struct sockaddr_in addr;
1028        struct iovec iov;
1029        struct msghdr msg;
1030        ssize_t n;
1031        char buf[1];
1032
1033        init_addr(&addr);
1034        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
1035
1036        errno = 0;
1037        n = send(fd, &buf[0], sizeof(buf), 0);
1038        assert(n == -1);
1039        assert(errno == ENOMEM);
1040
1041        errno = 0;
1042        n = sendto(fd, &buf[0], sizeof(buf), 0,
1043            (const struct sockaddr *) &addr, sizeof(addr));
1044        assert(n == -1);
1045        assert(errno == ENOMEM);
1046
1047        errno = 0;
1048        n = sendmsg(fd, &msg, 0);
1049        assert(n == -1);
1050        assert(errno == ENOMEM);
1051}
1052
1053static void
1054test_socket_send_and_sendto_and_sendmsg(void)
1055{
1056        rtems_resource_snapshot snapshot;
1057        struct sockaddr_in addr;
1058        struct iovec iov;
1059        struct msghdr msg;
1060        int sd;
1061        int rv;
1062        ssize_t n;
1063        char buf[1];
1064
1065        puts("test socket send, sendto and sendmsg");
1066
1067        rtems_resource_snapshot_take(&snapshot);
1068
1069        init_addr(&addr);
1070        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
1071
1072        sd = socket(PF_INET, SOCK_DGRAM, 0);
1073        assert(sd >= 0);
1074
1075        do_no_mem_test(no_mem_socket_send_and_sendto_and_sendmsg, sd);
1076
1077        errno = 0;
1078        n = send(sd, &buf[0], sizeof(buf), 0);
1079        assert(n == -1);
1080        assert(errno == EDESTADDRREQ);
1081
1082        errno = 0;
1083        n = sendto(sd, &buf[0], sizeof(buf), 0,
1084            (const struct sockaddr *) &addr, sizeof(addr));
1085        assert(n == -1);
1086        assert(errno == ENETUNREACH);
1087
1088        errno = 0;
1089        n = sendmsg(sd, &msg, 0);
1090        assert(n == -1);
1091        assert(errno == ENETUNREACH);
1092
1093        rv = close(sd);
1094        assert(rv == 0);
1095
1096        errno = 0;
1097        n = send(sd, &buf[0], sizeof(buf), 0);
1098        assert(n == -1);
1099        assert(errno == EBADF);
1100
1101        errno = 0;
1102        n = sendto(sd, &buf[0], sizeof(buf), 0,
1103            (const struct sockaddr *) &addr, sizeof(addr));
1104        assert(n == -1);
1105        assert(errno == EBADF);
1106
1107        errno = 0;
1108        n = sendmsg(sd, &msg, 0);
1109        assert(n == -1);
1110        assert(errno == EBADF);
1111
1112        assert(rtems_resource_snapshot_check(&snapshot));
1113}
1114
1115static void
1116no_mem_socket_recv_and_recvfrom_and_recvmsg(int fd)
1117{
1118        struct sockaddr_in addr;
1119        socklen_t addr_len;
1120        struct iovec iov;
1121        struct msghdr msg;
1122        ssize_t n;
1123        char buf[1];
1124
1125        init_addr(&addr);
1126        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
1127
1128        errno = 0;
1129        n = recv(fd, &buf[0], sizeof(buf), 0);
1130        assert(n == -1);
1131        assert(errno == ENOMEM);
1132
1133        errno = 0;
1134        addr_len = sizeof(addr);
1135        n = recvfrom(fd, &buf[0], sizeof(buf), 0,
1136            (struct sockaddr *) &addr, &addr_len);
1137        assert(n == -1);
1138        assert(errno == ENOMEM);
1139
1140        errno = 0;
1141        n = recvmsg(fd, &msg, 0);
1142        assert(n == -1);
1143        assert(errno == ENOMEM);
1144}
1145
1146static void
1147test_socket_recv_and_recvfrom_and_recvmsg(void)
1148{
1149        rtems_resource_snapshot snapshot;
1150        struct sockaddr_in addr;
1151        socklen_t addr_len;
1152        struct iovec iov;
1153        struct msghdr msg;
1154        int sd;
1155        int rv;
1156        ssize_t n;
1157        char buf[1];
1158        int enable = 1;
1159
1160        puts("test socket recv, recvfrom and recvmsg");
1161
1162        rtems_resource_snapshot_take(&snapshot);
1163
1164        init_addr(&addr);
1165        init_msg(&msg, &addr, &iov, &buf[0], sizeof(buf));
1166
1167        sd = socket(PF_INET, SOCK_DGRAM, 0);
1168        assert(sd >= 0);
1169
1170        rv = ioctl(sd, FIONBIO, &enable);
1171        assert(rv == 0);
1172
1173        do_no_mem_test(no_mem_socket_recv_and_recvfrom_and_recvmsg, sd);
1174
1175        errno = 0;
1176        n = recv(sd, &buf[0], sizeof(buf), 0);
1177        assert(n == -1);
1178        assert(errno == EAGAIN);
1179
1180        errno = 0;
1181        addr_len = sizeof(addr);
1182        n = recvfrom(sd, &buf[0], sizeof(buf), 0,
1183            (struct sockaddr *) &addr, &addr_len);
1184        assert(n == -1);
1185        assert(errno == EAGAIN);
1186
1187        errno = 0;
1188        n = recvmsg(sd, &msg, 0);
1189        assert(n == -1);
1190        assert(errno == EAGAIN);
1191
1192        rv = close(sd);
1193        assert(rv == 0);
1194
1195        errno = 0;
1196        n = recv(sd, &buf[0], sizeof(buf), 0);
1197        assert(n == -1);
1198        assert(errno == EBADF);
1199
1200        errno = 0;
1201        addr_len = sizeof(addr);
1202        n = recvfrom(sd, &buf[0], sizeof(buf), 0,
1203            (struct sockaddr *) &addr, &addr_len);
1204        assert(n == -1);
1205        assert(errno == EBADF);
1206
1207        errno = 0;
1208        n = recvmsg(sd, &msg, 0);
1209        assert(n == -1);
1210        assert(errno == EBADF);
1211
1212        assert(rtems_resource_snapshot_check(&snapshot));
1213}
1214
1215static void
1216no_mem_socket_select(int fd)
1217{
1218        struct fd_set set;
1219        int nfds;
1220        int rv;
1221
1222        FD_ZERO(&set);
1223        FD_SET(fd, &set);
1224        nfds = fd + 1;
1225
1226        errno = 0;
1227        rv = select(nfds, &set, NULL, NULL, NULL);
1228        assert(rv == -1);
1229        assert(errno == ENOMEM);
1230}
1231
1232static void
1233test_socket_select(void)
1234{
1235        rtems_resource_snapshot snapshot;
1236        struct fd_set set;
1237        int nfds;
1238        int sd;
1239        int rv;
1240
1241        puts("test socket select");
1242
1243        sd = socket(PF_INET, SOCK_DGRAM, 0);
1244        assert(sd >= 0);
1245
1246        rv = close(sd);
1247        assert(rv == 0);
1248
1249        FD_ZERO(&set);
1250        FD_SET(sd, &set);
1251        nfds = sd + 1;
1252
1253        errno = 0;
1254        rv = select(nfds, &set, NULL, NULL, NULL);
1255        assert(rv == -1);
1256        assert(errno == EBADF);
1257
1258        rtems_resource_snapshot_take(&snapshot);
1259
1260        sd = socket(PF_INET, SOCK_DGRAM, 0);
1261        assert(sd >= 0);
1262
1263        do_no_mem_test(no_mem_socket_select, sd);
1264
1265        FD_ZERO(&set);
1266        nfds = -1;
1267
1268        errno = 0;
1269        rv = select(nfds, &set, NULL, NULL, NULL);
1270        assert(rv == -1);
1271        assert(errno == EINVAL);
1272
1273        rv = close(sd);
1274        assert(rv == 0);
1275
1276        FD_ZERO(&set);
1277        FD_SET(sd, &set);
1278        nfds = sd + 1;
1279
1280        errno = 0;
1281        rv = select(nfds, &set, NULL, NULL, NULL);
1282        assert(rv == -1);
1283        assert(errno == EBADF);
1284
1285        assert(rtems_resource_snapshot_check(&snapshot));
1286}
1287
1288static void
1289no_mem_socket_poll(int fd)
1290{
1291        struct pollfd pfd;
1292        int timeout = -1;
1293        int rv;
1294
1295        pfd.fd = fd;
1296        pfd.events = POLLIN;
1297        pfd.revents = 0;
1298
1299        errno = 0;
1300        rv = poll(&pfd, 1, timeout);
1301        assert(rv == -1);
1302        assert(errno == ENOMEM);
1303}
1304
1305static void
1306test_socket_poll(void)
1307{
1308        rtems_resource_snapshot snapshot;
1309        struct pollfd pfd;
1310        int timeout = -1;
1311        int sd;
1312        int rv;
1313
1314        puts("test socket poll");
1315
1316        sd = socket(PF_INET, SOCK_DGRAM, 0);
1317        assert(sd >= 0);
1318
1319        rv = close(sd);
1320        assert(rv == 0);
1321
1322        pfd.fd = sd;
1323        pfd.events = POLLIN;
1324        pfd.revents = 0;
1325
1326        rv = poll(&pfd, 1, timeout);
1327        assert(rv == 1);
1328        assert(pfd.revents == POLLNVAL);
1329
1330        rtems_resource_snapshot_take(&snapshot);
1331
1332        sd = socket(PF_INET, SOCK_DGRAM, 0);
1333        assert(sd >= 0);
1334
1335        do_no_mem_test(no_mem_socket_poll, sd);
1336
1337        pfd.fd = sd;
1338        pfd.events = POLLIN;
1339        pfd.revents = 0;
1340
1341        errno = 0;
1342        rv = poll(NULL, UINT_MAX, timeout);
1343        assert(rv == -1);
1344        assert(errno == EINVAL);
1345
1346        rv = close(sd);
1347        assert(rv == 0);
1348
1349        pfd.fd = sd;
1350        pfd.events = POLLIN;
1351        pfd.revents = 0;
1352
1353        rv = poll(&pfd, 1, timeout);
1354        assert(rv == 1);
1355        assert(pfd.revents == POLLNVAL);
1356
1357        assert(rtems_resource_snapshot_check(&snapshot));
1358}
1359
1360static void
1361test_kqueue_unsupported_ops(void)
1362{
1363        rtems_resource_snapshot snapshot;
1364        int kq;
1365        int rv;
1366        off_t off;
1367        ssize_t n;
1368        char buf[1];
1369
1370        puts("test kqueue unsupported ops");
1371
1372        rtems_resource_snapshot_take(&snapshot);
1373
1374        kq = kqueue();
1375        assert(kq >= 0);
1376
1377        errno = 0;
1378        n = read(kq, &buf[0], sizeof(buf));
1379        assert(n == -1);
1380        assert(errno == ENOTSUP);
1381
1382        errno = 0;
1383        n = write(kq, &buf[0], sizeof(buf));
1384        assert(n == -1);
1385        assert(errno == ENOTSUP);
1386
1387        errno = 0;
1388        rv = ioctl(kq, 0);
1389        assert(rv == -1);
1390        assert(errno == ENOTTY);
1391
1392        errno = 0;
1393        off = lseek(kq, 0, SEEK_CUR);
1394        assert(off == -1);
1395        assert(errno == ESPIPE);
1396
1397        errno = 0;
1398        rv = ftruncate(kq, 0);
1399        assert(rv == -1);
1400        assert(errno == EINVAL);
1401
1402        errno = 0;
1403        rv = fsync(kq);
1404        assert(rv == -1);
1405        assert(errno == EINVAL);
1406
1407        errno = 0;
1408        rv = fdatasync(kq);
1409        assert(rv == -1);
1410        assert(errno == EINVAL);
1411
1412        rv = close(kq);
1413        assert(rv == 0);
1414
1415        assert(rtems_resource_snapshot_check(&snapshot));
1416}
1417
1418static void
1419no_mem_kqueue_fstat(int fd)
1420{
1421        struct stat st;
1422        int rv;
1423
1424        rv = fstat(fd, &st);
1425        assert(rv == 0);
1426}
1427
1428static void
1429test_kqueue_fstat(void)
1430{
1431        static const struct stat expected_st = {
1432                .st_mode = S_IFIFO
1433        };
1434
1435        rtems_resource_snapshot snapshot;
1436        struct stat st;
1437        int kq;
1438        int rv;
1439
1440        puts("test kqueue fstat");
1441
1442        rtems_resource_snapshot_take(&snapshot);
1443
1444        kq = kqueue();
1445        assert(kq >= 0);
1446
1447        do_no_mem_test(no_mem_kqueue_fstat, kq);
1448
1449        rv = fstat(kq, &st);
1450        assert(rv == 0);
1451        assert(memcmp(&expected_st, &st, sizeof(st)) == 0);
1452
1453        rv = close(kq);
1454        assert(rv == 0);
1455
1456        assert(rtems_resource_snapshot_check(&snapshot));
1457}
1458
1459static void
1460no_mem_kqueue_kevent(int fd)
1461{
1462        int rv;
1463
1464        errno = 0;
1465        rv = kevent(fd, NULL, 0, NULL, 0, NULL);
1466        assert(rv == -1);
1467        assert(errno == ENOMEM);
1468}
1469
1470static void
1471test_kqueue_kevent(void)
1472{
1473        rtems_resource_snapshot snapshot;
1474        int kq;
1475        int rv;
1476
1477        puts("test kqueue kevent");
1478
1479        rtems_resource_snapshot_take(&snapshot);
1480
1481        kq = kqueue();
1482        assert(kq >= 0);
1483
1484        do_no_mem_test(no_mem_kqueue_kevent, kq);
1485
1486        rv = kevent(kq, NULL, 0, NULL, 0, NULL);
1487        assert(rv == 0);
1488
1489        rv = close(kq);
1490        assert(rv == 0);
1491
1492        errno = 0;
1493        rv = kevent(kq, NULL, 0, NULL, 0, NULL);
1494        assert(rv == -1);
1495        assert(errno == EBADF);
1496
1497        errno = 0;
1498        rv = kevent(0, NULL, 0, NULL, 0, NULL);
1499        assert(rv == -1);
1500        assert(errno == EBADF);
1501
1502        assert(rtems_resource_snapshot_check(&snapshot));
1503}
1504
1505static const char prog_name[] = "prog";
1506
1507static int
1508invalid_prog(void *ctx)
1509{
1510        (void) ctx;
1511
1512        assert(0);
1513}
1514
1515static int
1516invalid_main(int argc, char **argv)
1517{
1518        (void) argc;
1519        (void) argv;
1520
1521        assert(0);
1522}
1523
1524static void *const some_context = (void *) 0xcafe;
1525
1526static int
1527some_prog(void *ctx)
1528{
1529        assert(ctx == some_context);
1530        assert(strcmp(rtems_bsd_program_get_name(), prog_name) == 0);
1531        assert(rtems_bsd_program_get_context() == some_context);
1532        errno = 0;
1533        rtems_bsd_program_exit(456);
1534}
1535
1536static const int some_argc = 1;
1537
1538static char *some_argv[] = { "a", NULL };
1539
1540static int
1541some_main(int argc, char **argv)
1542{
1543        assert(argc == some_argc);
1544        assert(argv == some_argv);
1545        assert(strcmp(rtems_bsd_program_get_name(), prog_name) == 0);
1546        errno = 0;
1547        rtems_bsd_program_exit(789);
1548}
1549
1550static void
1551no_mem_bsd_program(int fd)
1552{
1553        (void) fd;
1554
1555        assert(rtems_bsd_program_call(prog_name, invalid_prog, NULL)
1556            == EXIT_FAILURE);
1557        assert(rtems_bsd_program_call_main(prog_name, invalid_main, some_argc,
1558            some_argv) == EXIT_FAILURE);
1559        assert(strcmp(rtems_bsd_program_get_name(), "?") == 0);
1560        assert(rtems_bsd_program_get_context() == NULL);
1561}
1562
1563static void
1564test_bsd_program(void)
1565{
1566        rtems_resource_snapshot snapshot;
1567        int exit_code;
1568        void *greedy;
1569        char *invalid_argv[2] = { "a", "b" };
1570
1571        assert(rtems_configuration_get_unified_work_area());
1572
1573        puts("test BSD program");
1574
1575        rtems_resource_snapshot_take(&snapshot);
1576
1577        do_no_mem_test(no_mem_bsd_program, -1);
1578
1579        greedy = rtems_workspace_greedy_allocate(NULL, 0);
1580        no_mem_bsd_program(-1);
1581        rtems_workspace_greedy_free(greedy);
1582
1583        errno = 0;
1584        exit_code = rtems_bsd_program_call_main(prog_name, NULL, 1, invalid_argv);
1585        assert(errno == EFAULT);
1586        assert(exit_code == EXIT_FAILURE);
1587
1588        errno = EINVAL;
1589        exit_code = rtems_bsd_program_call(prog_name, some_prog, some_context);
1590        assert(errno == 0);
1591        assert(exit_code == 456);
1592        assert(strcmp(rtems_bsd_program_get_name(), "?") == 0);
1593        assert(rtems_bsd_program_get_context() == NULL);
1594
1595        errno = EINVAL;
1596        exit_code = rtems_bsd_program_call_main(prog_name, some_main,
1597            some_argc, some_argv);
1598        assert(errno == 0);
1599        assert(exit_code == 789);
1600        assert(strcmp(rtems_bsd_program_get_name(), "?") == 0);
1601        assert(rtems_bsd_program_get_context() == NULL);
1602
1603        assert(rtems_resource_snapshot_check(&snapshot));
1604}
1605
1606static void
1607test_warn(void)
1608{
1609        puts("test warn");
1610
1611        errno = EAGAIN;
1612        warn("%s", "warn");
1613
1614        errno = ENAMETOOLONG;
1615        warn(NULL);
1616
1617        errno = 0;
1618        warnc(EDOM, "%s", "warnc");
1619
1620        errno = 0;
1621        warnc(ERANGE, NULL);
1622
1623        warnx("%s", "warnx");
1624
1625        warnx(NULL);
1626}
1627
1628static int
1629call_err(void *ctx)
1630{
1631        errno = EAGAIN;
1632        err(10, "%s", "call_err");
1633}
1634
1635static int
1636call_err_null(void *ctx)
1637{
1638        errno = ENAMETOOLONG;
1639        err(11, NULL);
1640}
1641
1642static int
1643call_errc(void *ctx)
1644{
1645        errc(12, EDOM, "%s", "call_errc");
1646}
1647
1648static int
1649call_errc_null(void *ctx)
1650{
1651        errc(13, ERANGE, NULL);
1652}
1653
1654static int
1655call_errx(void *ctx)
1656{
1657        errx(14, "%s", "call_errx");
1658}
1659
1660static int
1661call_errx_null(void *ctx)
1662{
1663        errx(15, NULL);
1664}
1665
1666static void
1667test_err(void)
1668{
1669        int exit_code;
1670
1671        puts("test err");
1672
1673        exit_code = rtems_bsd_program_call("err", call_err, NULL);
1674        assert(exit_code == 10);
1675
1676        exit_code = rtems_bsd_program_call("err", call_err_null, NULL);
1677        assert(exit_code == 11);
1678
1679        exit_code = rtems_bsd_program_call("errc", call_errc, NULL);
1680        assert(exit_code == 12);
1681
1682        exit_code = rtems_bsd_program_call("errc", call_errc_null, NULL);
1683        assert(exit_code == 13);
1684
1685        exit_code = rtems_bsd_program_call("errx", call_errx, NULL);
1686        assert(exit_code == 14);
1687
1688        exit_code = rtems_bsd_program_call("errx", call_errx_null, NULL);
1689        assert(exit_code == 15);
1690}
1691
1692static void
1693test_main(void)
1694{
1695        /* Must be first test to ensure resource checks work */
1696        test_sockets();
1697
1698        test_socket_unsupported_ops();
1699        test_socket_fstat_and_shutdown();
1700        test_socket_ioctl();
1701        test_socket_bind();
1702        test_socket_connect();
1703        test_socket_listen();
1704        test_socket_accept();
1705        test_socket_getsockopt_and_setsockopt();
1706        test_socket_getpeername();
1707        test_socket_getsockname();
1708        test_socket_read_and_write();
1709        test_socket_send_and_sendto_and_sendmsg();
1710        test_socket_recv_and_recvfrom_and_recvmsg();
1711        test_socket_select();
1712        test_socket_poll();
1713
1714        test_kqueue_unsupported_ops();
1715        test_kqueue_fstat();
1716        test_kqueue_kevent();
1717
1718        test_bsd_program();
1719        test_warn();
1720        test_err();
1721
1722        exit(0);
1723}
1724
1725#include <rtems/bsd/test/default-init.h>
Note: See TracBrowser for help on using the repository browser.