oneechanhax/phunix
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
phunix/minix/tests/test90.c
David van Moolenbroek baa5830f28 tests: add advanced UDS tests (test90) 
Change-Id: Ib4b81d441368fd9b7e7c7b9cab802bb01fa04065
2017-03-09 23:39:56 +00:00

4186 lines
99 KiB
C
Raw Permalink Blame History

/* Advanced tests for UNIX Domain Sockets - by D.C. van Moolenbroek */
/*
* This is a somewhat random collection of in-depth tests, complementing the
* more general functionality tests in test56. The overall test set is still
* by no means expected to be "complete." The subtests are in random order.
*/
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/ioctl.h>
#include <sys/sysctl.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
#include <stddef.h>
#include <assert.h>
#include "common.h"
#include "socklib.h"
#define ITERATIONS 1
#define SOCK_PATH_A "sock_a"
#define SOCK_PATH_B "sock_b"
#define SOCK_PATH_C "sock_c"
#define SOCK_PATH_D "sock_d"
#define SOCK_PATH_A_X ".//sock_a"
#define SOCK_PATH_A_Y "./././sock_a"
#define PRINT_STATS 0
/*
* Check that the given returned socket address matches the given path. A NULL
* path may be passed in to indicate the result should be for an unbound
* socket.
*/
static void
check_addr(struct sockaddr_un * sun, socklen_t len, const char * path)
{
if (len < offsetof(struct sockaddr_un, sun_path)) e(0);
if (sun->sun_family != AF_UNIX) e(0);
if (sun->sun_len != len - ((path != NULL) ? 1 : 0)) e(0);
len -= offsetof(struct sockaddr_un, sun_path);
if (path != NULL) {
if (len != strlen(path) + 1) e(0);
if (sun->sun_path[len - 1] != '\0') e(0);
if (strcmp(sun->sun_path, path)) e(0);
} else
if (len != 0) e(0);
}
/*
* Get a socket of the given type, bound to the given path. Return the file
* descriptor, as well as the bound addres in 'sun'.
*/
static int
get_bound_socket(int type, const char * path, struct sockaddr_un * sun)
{
int fd;
if ((fd = socket(AF_UNIX, type, 0)) < 0) e(0);
(void)unlink(path);
memset(sun, 0, sizeof(*sun));
sun->sun_family = AF_UNIX;
strlcpy(sun->sun_path, path, sizeof(sun->sun_path));
if (bind(fd, (struct sockaddr *)sun, sizeof(*sun)) != 0) e(0);
return fd;
}
/*
* Get a pair of connected sockets.
*/
static void
get_socket_pair(int type, int fd[2])
{
struct sockaddr_un sunA, sunB;
if ((type & ~SOCK_FLAGS_MASK) == SOCK_DGRAM) {
fd[0] = get_bound_socket(type, SOCK_PATH_A, &sunA);
fd[1] = get_bound_socket(type, SOCK_PATH_B, &sunB);
if (connect(fd[0], (struct sockaddr *)&sunB,
sizeof(sunB)) != 0) e(0);
if (connect(fd[1], (struct sockaddr *)&sunA,
sizeof(sunA)) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
if (unlink(SOCK_PATH_B) != 0) e(0);
} else
if (socketpair(AF_UNIX, type, 0, fd) != 0) e(0);
}
/*
* Return the receive buffer size of the given socket.
*/
static int
get_rcvbuf_len(int fd)
{
socklen_t len;
int val;
len = sizeof(val);
if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &val, &len) != 0) e(0);
if (len != sizeof(val)) e(0);
if (val <= 0) e(0);
return val;
}
static const enum state unix_connect_states[] = {
S_NEW, S_N_SHUT_R, S_N_SHUT_W, S_N_SHUT_RW,
S_BOUND, S_LISTENING, S_L_SHUT_R, S_L_SHUT_W,
S_L_SHUT_RW, S_CONNECTING, S_CONNECTED, S_ACCEPTED,
S_SHUT_R, S_SHUT_W, S_SHUT_RW, S_RSHUT_R,
S_RSHUT_W, S_RSHUT_RW, S_SHUT2_R, S_SHUT2_W,
S_SHUT2_RW, S_PRE_EOF, S_AT_EOF, S_POST_EOF,
S_PRE_SHUT_R, S_EOF_SHUT_R, S_POST_SHUT_R, S_PRE_SHUT_W,
S_EOF_SHUT_W, S_POST_SHUT_W, S_PRE_SHUT_RW, S_EOF_SHUT_RW,
S_POST_SHUT_RW, S_AT_RESET, S_POST_RESET, S_POST_FAILED
/*
* It is impossible to generate the S_PRE_RESET state: we can
* only generate a reset on a connected socket for which the
* other end is pending acceptance, by closing the listening
* socket. That means we cannot send data to the connected end
* (from the listening socket) before triggering the reset.
*
* It is impossible to generate the S_FAILED state: even a non-
* blocking connect will always fail immediately when it cannot
* connect to the target.
*/
};
static const int unix_connect_results[][__arraycount(unix_connect_states)] = {
[C_ACCEPT] = {
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EAGAIN, -ECONNABORTED, -ECONNABORTED,
-ECONNABORTED, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
},
[C_BIND] = {
0, 0, 0, 0,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, 0, 0, -EINVAL,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_CONNECT] = {
0, 0, 0, 0,
0, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP,
-EOPNOTSUPP, -EALREADY, -EISCONN, -EISCONN,
-EISCONN, -EISCONN, -EISCONN, -EISCONN,
-EISCONN, -EISCONN, -EISCONN, -EISCONN,
-EISCONN, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_GETPEERNAME] = {
-ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN,
-ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN,
-ENOTCONN, -ENOTCONN, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, -ENOTCONN, -ENOTCONN, -ENOTCONN,
-ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN,
-ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN,
-ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN,
},
[C_GETSOCKNAME] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_GETSOCKOPT_ERR] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, -ECONNRESET, 0, 0,
},
[C_GETSOCKOPT_KA] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_GETSOCKOPT_RB] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_IOCTL_NREAD] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 1, 0, 0,
0, 0, 0, 1,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_LISTEN] = {
-EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ,
0, 0, 0, 0,
0, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ,
-EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ,
-EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ,
-EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ, -EDESTADDRREQ,
},
[C_RECV] = {
-ENOTCONN, 0, -ENOTCONN, 0,
-ENOTCONN, -ENOTCONN, 0, -ENOTCONN,
0, -EAGAIN, -EAGAIN, -EAGAIN,
0, -EAGAIN, 0, -EAGAIN,
0, 0, 0, 0,
0, 1, 0, 0,
0, 0, 0, 1,
0, 0, 0, 0,
0, -ECONNRESET, 0, -ENOTCONN,
},
[C_RECVFROM] = {
-ENOTCONN, 0, -ENOTCONN, 0,
-ENOTCONN, -ENOTCONN, 0, -ENOTCONN,
0, -EAGAIN, -EAGAIN, -EAGAIN,
0, -EAGAIN, 0, -EAGAIN,
0, 0, 0, 0,
0, 1, 0, 0,
0, 0, 0, 1,
0, 0, 0, 0,
0, -ECONNRESET, 0, -ENOTCONN,
},
[C_SEND] = {
-ENOTCONN, -ENOTCONN, -EPIPE, -EPIPE,
-ENOTCONN, -ENOTCONN, -ENOTCONN, -EPIPE,
-EPIPE, -EAGAIN, 1, 1,
1, -EPIPE, -EPIPE, -EPIPE,
1, -EPIPE, -EPIPE, -EPIPE,
-EPIPE, -EPIPE, -EPIPE, -EPIPE,
-EPIPE, -EPIPE, -EPIPE, -EPIPE,
-EPIPE, -EPIPE, -EPIPE, -EPIPE,
-EPIPE, -ECONNRESET, -EPIPE, -ENOTCONN,
},
[C_SENDTO] = {
-ENOTCONN, -ENOTCONN, -EPIPE, -EPIPE,
-ENOTCONN, -ENOTCONN, -ENOTCONN, -EPIPE,
-EPIPE, -EAGAIN, 1, 1,
1, -EPIPE, -EPIPE, -EPIPE,
1, -EPIPE, -EPIPE, -EPIPE,
-EPIPE, -EPIPE, -EPIPE, -EPIPE,
-EPIPE, -EPIPE, -EPIPE, -EPIPE,
-EPIPE, -EPIPE, -EPIPE, -EPIPE,
-EPIPE, -ECONNRESET, -EPIPE, -ENOTCONN,
},
[C_SELECT_R] = {
1, 1, 1, 1,
1, 0, 1, 1,
1, 0, 0, 0,
1, 0, 1, 0,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
},
[C_SELECT_W] = {
1, 1, 1, 1,
1, 1, 1, 1,
1, 0, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
},
[C_SELECT_X] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_SETSOCKOPT_BC] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_SETSOCKOPT_KA] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_SETSOCKOPT_L] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_SETSOCKOPT_RA] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_SHUTDOWN_R] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_SHUTDOWN_RW] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
[C_SHUTDOWN_W] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
},
};
/*
* Set up a connection-oriented socket file descriptor in the requested state
* and pass it to socklib_sweep_call() along with local and remote addresses
* and their length.
*/
static int
unix_connect_sweep(int domain, int type, int protocol __unused,
enum state state, enum call call)
{
struct sockaddr_un sunA, sunB, sunC;
char buf[1];
socklen_t len;
fd_set fds;
int r, fd, fd2, fd3, tmpfd, val, fl;
(void)unlink(SOCK_PATH_A);
(void)unlink(SOCK_PATH_B);
(void)unlink(SOCK_PATH_C);
memset(&sunA, 0, sizeof(sunA));
sunA.sun_family = AF_UNIX;
strlcpy(sunA.sun_path, SOCK_PATH_A, sizeof(sunA.sun_path));
fd = fd3 = -1;
fd2 = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_B, &sunB);
if (listen(fd2, 1) == -1) e(0);
switch (state) {
case S_NEW:
case S_N_SHUT_R:
case S_N_SHUT_W:
case S_N_SHUT_RW:
if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
switch (state) {
case S_N_SHUT_R: if (shutdown(fd, SHUT_RD)) e(0); break;
case S_N_SHUT_W: if (shutdown(fd, SHUT_WR)) e(0); break;
case S_N_SHUT_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break;
default: break;
}
break;
case S_BOUND:
case S_LISTENING:
case S_L_SHUT_R:
case S_L_SHUT_W:
case S_L_SHUT_RW:
fd = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_A,
&sunA);
if (state == S_BOUND)
break;
if (listen(fd, 1) == -1) e(0);
switch (state) {
case S_L_SHUT_R: if (shutdown(fd, SHUT_RD)) e(0); break;
case S_L_SHUT_W: if (shutdown(fd, SHUT_WR)) e(0); break;
case S_L_SHUT_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break;
default: break;
}
break;
case S_CONNECTING:
/*
* The following block is nonportable. On NetBSD, the
* LOCAL_CONNWAIT socket option is present but seems somewhat..
* under-tested. On Linux, it is not possible to put a UNIX
* domain socket in a connecting state.
*/
if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
val = 1;
if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0)
e(0);
if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != -1)
e(0);
if (errno != EINPROGRESS) e(0);
break;
case S_CONNECTED:
case S_ACCEPTED:
case S_SHUT_R:
case S_SHUT_W:
case S_SHUT_RW:
case S_RSHUT_R:
case S_RSHUT_W:
case S_RSHUT_RW:
case S_SHUT2_R:
case S_SHUT2_W:
case S_SHUT2_RW:
if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0)
e(0);
len = sizeof(sunC);
if ((fd3 = accept(fd2, (struct sockaddr *)&sunC, &len)) < 0)
e(0);
if ((fl = fcntl(fd3, F_GETFL)) == -1) e(0);
if (fcntl(fd3, F_SETFL, fl | O_NONBLOCK) != 0) e(0);
/* Just to make sure, wait for the socket to be connected. */
FD_ZERO(&fds);
FD_SET(fd, &fds);
if (select(fd + 1, NULL, &fds, NULL, NULL) != 1) e(0);
switch (state) {
case S_SHUT_R:
case S_SHUT2_R: if (shutdown(fd, SHUT_RD)) e(0); break;
case S_SHUT_W:
case S_SHUT2_W: if (shutdown(fd, SHUT_WR)) e(0); break;
case S_SHUT_RW:
case S_SHUT2_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break;
default: break;
}
switch (state) {
case S_RSHUT_R:
case S_SHUT2_R: if (shutdown(fd3, SHUT_RD)) e(0); break;
case S_RSHUT_W:
case S_SHUT2_W: if (shutdown(fd3, SHUT_WR)) e(0); break;
case S_RSHUT_RW:
case S_SHUT2_RW: if (shutdown(fd3, SHUT_RDWR)) e(0); break;
default: break;
}
if (state == S_ACCEPTED) {
tmpfd = fd;
fd = fd3;
fd3 = tmpfd;
}
break;
case S_PRE_EOF:
case S_AT_EOF:
case S_POST_EOF:
case S_PRE_SHUT_R:
case S_EOF_SHUT_R:
case S_POST_SHUT_R:
case S_PRE_SHUT_W:
case S_EOF_SHUT_W:
case S_POST_SHUT_W:
case S_PRE_SHUT_RW:
case S_EOF_SHUT_RW:
case S_POST_SHUT_RW:
if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0)
e(0);
len = sizeof(sunC);
if ((fd3 = accept(fd2, (struct sockaddr *)&sunC, &len)) < 0)
e(0);
if ((fl = fcntl(fd3, F_GETFL)) == -1) e(0);
if (fcntl(fd3, F_SETFL, fl | O_NONBLOCK) != 0) e(0);
if (send(fd3, "", 1, 0) != 1) e(0);
if (close(fd3) != 0) e(0);
fd3 = -1;
FD_ZERO(&fds);
FD_SET(fd, &fds);
if (select(fd + 1, &fds, NULL, NULL, NULL) != 1) e(0);
switch (state) {
case S_AT_EOF:
case S_EOF_SHUT_R:
case S_EOF_SHUT_W:
case S_EOF_SHUT_RW:
if (recv(fd, buf, sizeof(buf), 0) != 1) e(0);
break;
case S_POST_EOF:
case S_POST_SHUT_R:
case S_POST_SHUT_W:
case S_POST_SHUT_RW:
if (recv(fd, buf, sizeof(buf), 0) != 1) e(0);
if (recv(fd, buf, sizeof(buf), 0) != 0) e(0);
break;
default:
break;
}
switch (state) {
case S_PRE_SHUT_R:
case S_EOF_SHUT_R:
case S_POST_SHUT_R: if (shutdown(fd, SHUT_RD)) e(0); break;
case S_PRE_SHUT_W:
case S_EOF_SHUT_W:
case S_POST_SHUT_W: if (shutdown(fd, SHUT_WR)) e(0); break;
case S_PRE_SHUT_RW:
case S_EOF_SHUT_RW:
case S_POST_SHUT_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break;
default: break;
}
break;
case S_AT_RESET:
case S_POST_RESET:
if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0)
e(0);
/*
* Closing the listening socket before the connection has been
* accepted should generate ECONNRESET on the connected socket.
* Well, should.. we choose to do that. So does Linux. NetBSD
* just returns EOF for that case. There are really no strong
* arguments for either behavior.
*/
if (close(fd2) != 0) e(0);
if (state == S_POST_RESET)
(void)recv(fd, buf, sizeof(buf), 0);
/* Recreate the listening socket just for consistency. */
fd2 = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_B,
&sunB);
if (listen(fd2, 1) == -1) e(0);
break;
case S_POST_FAILED:
if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
memset(&sunC, 0, sizeof(sunC));
sunC.sun_family = AF_UNIX;
strlcpy(sunC.sun_path, SOCK_PATH_C, sizeof(sunC.sun_path));
r = connect(fd, (struct sockaddr *)&sunC, sizeof(sunC));
if (r != -1 || errno != ENOENT)
e(0);
break;
default:
e(0);
}
r = socklib_sweep_call(call, fd, (struct sockaddr *)&sunA,
(struct sockaddr *)&sunB, sizeof(struct sockaddr_un));
if (fd >= 0 && close(fd) != 0) e(0);
if (fd2 >= 0 && close(fd2) != 0) e(0);
if (fd3 >= 0 && close(fd3) != 0) e(0);
(void)unlink(SOCK_PATH_A);
(void)unlink(SOCK_PATH_B);
return r;
}
static const enum state unix_dgram_states[] = {
S_NEW, S_N_SHUT_R, S_N_SHUT_W, S_N_SHUT_RW,
S_BOUND, S_CONNECTED, S_SHUT_R, S_SHUT_W,
S_SHUT_RW, S_RSHUT_R, S_RSHUT_W, S_RSHUT_RW,
S_SHUT2_R, S_SHUT2_W, S_SHUT2_RW, S_PRE_RESET,
S_AT_RESET, S_POST_RESET
};
static const int unix_dgram_results[][__arraycount(unix_dgram_states)] = {
[C_ACCEPT] = {
-EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP,
-EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP,
-EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP,
-EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP,
-EOPNOTSUPP, -EOPNOTSUPP,
},
[C_BIND] = {
0, 0, 0, 0,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL, -EINVAL, -EINVAL,
-EINVAL, -EINVAL,
},
[C_CONNECT] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, -ECONNREFUSED,
-ECONNREFUSED, -ECONNREFUSED,
},
[C_GETPEERNAME] = {
-ENOTCONN, -ENOTCONN, -ENOTCONN, -ENOTCONN,
-ENOTCONN, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, -ENOTCONN,
-ENOTCONN, -ENOTCONN,
},
[C_GETSOCKNAME] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_GETSOCKOPT_ERR] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, -ECONNRESET,
-ECONNRESET, 0,
},
[C_GETSOCKOPT_KA] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_GETSOCKOPT_RB] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_IOCTL_NREAD] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 1,
0, 0,
},
[C_LISTEN] = {
-EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP,
-EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP,
-EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP,
-EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP, -EOPNOTSUPP,
-EOPNOTSUPP, -EOPNOTSUPP,
},
[C_RECV] = {
-EAGAIN, 0, -EAGAIN, 0,
-EAGAIN, -EAGAIN, 0, -EAGAIN,
0, -EAGAIN, -EAGAIN, -EAGAIN,
0, -EAGAIN, 0, 1,
-ECONNRESET, -EAGAIN,
},
[C_RECVFROM] = {
-EAGAIN, 0, -EAGAIN, 0,
-EAGAIN, -EAGAIN, 0, -EAGAIN,
0, -EAGAIN, -EAGAIN, -EAGAIN,
0, -EAGAIN, 0, 1,
-ECONNRESET, -EAGAIN,
},
[C_SEND] = {
-EDESTADDRREQ, -EDESTADDRREQ, -EPIPE, -EPIPE,
-EDESTADDRREQ, 1, 1, -EPIPE,
-EPIPE, -ENOBUFS, 1, -ENOBUFS,
-ENOBUFS, -EPIPE, -EPIPE, -ECONNRESET,
-ECONNRESET, -EDESTADDRREQ,
},
[C_SENDTO] = {
1, 1, -EPIPE, -EPIPE,
1, 1, 1, -EPIPE,
-EPIPE, -ENOBUFS, 1, -ENOBUFS,
-ENOBUFS, -EPIPE, -EPIPE, -ECONNRESET,
-ECONNRESET, -ECONNREFUSED,
},
[C_SELECT_R] = {
0, 1, 0, 1,
0, 0, 1, 0,
1, 0, 0, 0,
1, 0, 1, 1,
1, 0,
},
[C_SELECT_W] = {
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1,
},
[C_SELECT_X] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_SETSOCKOPT_BC] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_SETSOCKOPT_KA] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_SETSOCKOPT_L] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_SETSOCKOPT_RA] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_SHUTDOWN_R] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_SHUTDOWN_RW] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
[C_SHUTDOWN_W] = {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0,
},
};
/*
* Set up a datagram socket file descriptor in the requested state and pass it
* to socklib_sweep_call() along with local and remote addresses and their
* length.
*/
static int
unix_dgram_sweep(int domain __unused, int type, int protocol __unused,
enum state state, enum call call)
{
struct sockaddr_un sunA, sunB;
char buf[1];
int r, fd, fd2;
(void)unlink(SOCK_PATH_A);
(void)unlink(SOCK_PATH_B);
/* Create a bound remote socket. */
fd2 = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_B, &sunB);
switch (state) {
case S_NEW:
case S_N_SHUT_R:
case S_N_SHUT_W:
case S_N_SHUT_RW:
memset(&sunA, 0, sizeof(sunA));
sunA.sun_family = AF_UNIX;
strlcpy(sunA.sun_path, SOCK_PATH_A, sizeof(sunA.sun_path));
if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0)
e(0);
switch (state) {
case S_N_SHUT_R: if (shutdown(fd, SHUT_RD)) e(0); break;
case S_N_SHUT_W: if (shutdown(fd, SHUT_WR)) e(0); break;
case S_N_SHUT_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break;
default: break;
}
break;
case S_BOUND:
case S_CONNECTED:
case S_SHUT_R:
case S_SHUT_W:
case S_SHUT_RW:
case S_RSHUT_R:
case S_RSHUT_W:
case S_RSHUT_RW:
case S_SHUT2_R:
case S_SHUT2_W:
case S_SHUT2_RW:
case S_PRE_RESET:
case S_AT_RESET:
case S_POST_RESET:
fd = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_A,
&sunA);
if (state == S_BOUND)
break;
if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0)
e(0);
switch (state) {
case S_SHUT_R:
case S_SHUT2_R: if (shutdown(fd, SHUT_RD)) e(0); break;
case S_SHUT_W:
case S_SHUT2_W: if (shutdown(fd, SHUT_WR)) e(0); break;
case S_SHUT_RW:
case S_SHUT2_RW: if (shutdown(fd, SHUT_RDWR)) e(0); break;
default: break;
}
switch (state) {
case S_RSHUT_R:
case S_SHUT2_R: if (shutdown(fd2, SHUT_RD)) e(0); break;
case S_RSHUT_W:
case S_SHUT2_W: if (shutdown(fd2, SHUT_WR)) e(0); break;
case S_RSHUT_RW:
case S_SHUT2_RW: if (shutdown(fd2, SHUT_RDWR)) e(0); break;
case S_PRE_RESET:
case S_AT_RESET:
case S_POST_RESET:
if (sendto(fd2, "", 1, 0, (struct sockaddr *)&sunA,
sizeof(sunA)) != 1) e(0);
if (close(fd2) != 0) e(0);
fd2 = -1;
if (state != S_PRE_RESET) {
if (recv(fd, buf, sizeof(buf), 0) != 1) e(0);
}
if (state == S_POST_RESET) {
(void)recv(fd, buf, sizeof(buf), 0);
}
default:
break;
}
break;
default:
fd = -1;
e(0);
}
r = socklib_sweep_call(call, fd, (struct sockaddr *)&sunA,
(struct sockaddr *)&sunB, sizeof(struct sockaddr_un));
if (close(fd) != 0) e(0);
if (fd2 != -1 && close(fd2) != 0) e(0);
(void)unlink(SOCK_PATH_A);
(void)unlink(SOCK_PATH_B);
return r;
}
/*
* Sweep test for socket calls versus socket states of all socket types.
*/
static void
test90a(void)
{
subtest = 1;
socklib_sweep(AF_UNIX, SOCK_STREAM, 0, unix_connect_states,
__arraycount(unix_connect_states),
(const int *)unix_connect_results, unix_connect_sweep);
socklib_sweep(AF_UNIX, SOCK_SEQPACKET, 0, unix_connect_states,
__arraycount(unix_connect_states),
(const int *)unix_connect_results, unix_connect_sweep);
socklib_sweep(AF_UNIX, SOCK_DGRAM, 0, unix_dgram_states,
__arraycount(unix_dgram_states), (const int *)unix_dgram_results,
unix_dgram_sweep);
}
/*
* Test for large sends and receives with MSG_WAITALL.
*/
static void
test90b(void)
{
int fd[2];
subtest = 2;
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0);
socklib_large_transfers(fd);
}
/*
* A randomized producer-consumer test for datagram sockets.
*/
static void
sub90c(int type)
{
char *buf;
time_t t;
socklen_t len, size;
ssize_t r;
pid_t pid;
unsigned int count;
int i, fd[2], rcvlen, status, exp, flags, num, stat[2] = { 0, 0 };
get_socket_pair(type, fd);
size = rcvlen = get_rcvbuf_len(fd[0]);
if ((buf = malloc(size)) == NULL) e(0);
t = time(NULL);
/*
* We vary small versus large (random) send and receive sizes,
* splitting the entire transfer in four phases along those lines.
*
* In theory, the use of an extra system call and the use of MSG_PEEK
* both contribute to the expectation that the consumer side will fall
* behind the producer. In this case, we cannot vary receive sizes to
* compensate. This not appear to be a major problem here, though.
*/
#define NR_PACKETS (256 * 1024)
pid = fork();
switch (pid) {
case 0:
errct = 0;
if (close(fd[0]) != 0) e(0);
srand48(t + 1);
for (count = 0; count < NR_PACKETS; ) {
if (count < NR_PACKETS / 2)
len = lrand48() % 64;
else
len = lrand48() % size;
num = lrand48() % 16;
flags = 0;
if (num & 1) flags |= MSG_PEEK;
if (num & 2) flags |= MSG_WAITALL;
if (num & 4) flags |= MSG_DONTWAIT;
if (num & 8) {
/*
* Obviously there are race conditions here but
* the returned number should be accurate if
* not zero. Hopefully it's not always zero.
*/
if (ioctl(fd[1], FIONREAD, &exp) != 0) e(0);
if (exp < 0 || exp > rcvlen) e(0);
} else
exp = 0;
stat[0]++;
/*
* A lame approach to preventing unbounded spinning on
* ENOBUFS on the producer side.
*/
if (type == SOCK_DGRAM)
(void)send(fd[1], "", 1, MSG_DONTWAIT);
if ((r = recv(fd[1], buf, len, flags)) == -1) {
if (errno != EWOULDBLOCK) e(0);
if (exp > 0) e(0);
stat[1]++;
continue;
}
if (exp != 0) {
if (r == len && exp < r) e(0);
else if (r < len && exp != r) e(0);
}
if (r >= 2 &&
r > ((size_t)(unsigned char)buf[0] << 8) +
(size_t)(unsigned char)buf[1]) e(0);
for (i = 2; i < r; i++)
if (buf[i] != (char)i) e(0);
if (!(flags & MSG_PEEK))
count++;
}
#if PRINT_STATS
/*
* The second and third numbers should ideally be a large but
* non-dominating fraction of the first one.
*/
printf("RECV: total %d again %d\n", stat[0], stat[1]);
#endif
if (close(fd[1]) != 0) e(0);
exit(errct);
case -1:
e(0);
}
if (close(fd[1]) != 0) e(0);
srand48(t);
for (count = 0; count < NR_PACKETS; ) {
if (count < NR_PACKETS / 4 ||
(count >= NR_PACKETS / 2 && count < NR_PACKETS * 3 / 4))
len = lrand48() % 64;
else
len = lrand48() % size;
buf[0] = (len >> 8) & 0xff;
buf[1] = len & 0xff;
for (i = 2; i < len; i++)
buf[i] = i;
flags = (lrand48() % 2) ? MSG_DONTWAIT : 0;
r = send(fd[0], buf, len, flags);
if (r != len) {
if (r != -1) e(0);
if (errno != EMSGSIZE && errno != EWOULDBLOCK &&
errno != ENOBUFS) e(0);
if (errno == ENOBUFS || errno == EWOULDBLOCK) {
/*
* As stated above: lame. Ideally we would
* continue only when the receiver side drains
* the queue, but it may block once it has done
* so. Instead, by going through consumer
* "tokens" we will ultimately block here and
* let the receiver catch up.
*/
if (type == SOCK_DGRAM && errno == ENOBUFS)
(void)recv(fd[0], buf, 1, 0);
stat[0]++;
stat[1]++;
}
continue;
} else
stat[0]++;
if (count % (NR_PACKETS / 4) == 0)
sleep(1);
count++;
}
#if PRINT_STATS
/*
* The second number should ideally be a large but non-dominating
* fraction of the first one.
*/
printf("SEND: total %d again %d\n", stat[0], stat[1]);
#endif
free(buf);
if (close(fd[0]) != 0) e(0);
if (waitpid(pid, &status, 0) != pid) e(0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0);
}
/*
* A randomized producer-consumer test. As part of this, we also perform very
* basic bulk functionality tests of FIONREAD, MSG_PEEK, MSG_DONTWAIT, and
* MSG_WAITALL.
*/
static void
test90c(void)
{
int fd[2];
subtest = 4;
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0);
socklib_producer_consumer(fd);
sub90c(SOCK_SEQPACKET);
sub90c(SOCK_DGRAM);
}
/*
* Test that immediately accepted non-blocking connect requests to a listening
* socket with LOCAL_CONNWAIT turned on, return OK rather than EINPROGRESS.
* This requires a hack in libsockevent.
*/
static void
test90d(void)
{
struct sockaddr_un sunA, sunB;
socklen_t len;
pid_t pid;
int fd, fd2, fd3, val, status;
subtest = 4;
/*
* First ensure that a non-blocking connect to a listening socket that
* does not have a accept call blocked on it, fails with EINPROGRESS.
*/
fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sunA);
val = 1;
if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0);
if (listen(fd, 1) != 0) e(0);
if ((fd2 = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != -1) e(0);
if (errno != EINPROGRESS) e(0);
len = sizeof(sunB);
if ((fd3 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) e(0);
check_addr(&sunB, len, NULL);
if (close(fd) != 0) e(0);
if (close(fd2) != 0) e(0);
if (close(fd3) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
/*
* Second, ensure that a blocking connect eventually does return
* success if an accept call is made later on.
*/
fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sunA);
val = 1;
if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0);
if (listen(fd, 1) != 0) e(0);
pid = fork();
switch (pid) {
case 0:
errct = 0;
sleep(1);
len = sizeof(sunB);
if ((fd2 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0)
e(0);
check_addr(&sunB, len, NULL);
exit(errct);
case -1:
e(0);
}
if (close(fd) != 0) e(0);
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) e(0);
if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (close(fd) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
if (waitpid(pid, &status, 0) != pid) e(0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0);
/*
* Finally, test the most implementation-complex case: a non-blocking
* connect should succeed (i.e., yield return code 0) immediately if
* there is a accept call blocked on it.
*/
fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sunA);
val = 1;
if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0);
if (listen(fd, 1) != 0) e(0);
pid = fork();
switch (pid) {
case 0:
errct = 0;
len = sizeof(sunB);
if ((fd2 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0)
e(0);
check_addr(&sunB, len, SOCK_PATH_B);
exit(errct);
case -1:
e(0);
}
if (close(fd) != 0) e(0);
sleep(1);
fd = get_bound_socket(SOCK_STREAM | SOCK_NONBLOCK, SOCK_PATH_B, &sunB);
if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (close(fd) != 0) e(0);
if (waitpid(pid, &status, 0) != pid) e(0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
if (unlink(SOCK_PATH_B) != 0) e(0);
}
/*
* Test self-connecting datagram sockets.
*/
static void
test90e(void)
{
struct sockaddr_un sunA, sunB, sunC;
socklen_t len;
char buf[3];
pid_t pid;
int fdA, fdB, val, status;
subtest = 5;
fdA = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sunA);
fdB = get_bound_socket(SOCK_DGRAM, SOCK_PATH_B, &sunB);
/* Connect the socket to itself, and attempt to communicate. */
if (connect(fdA, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (send(fdA, "abc", 3, 0) != 3) e(0);
if (recv(fdA, buf, sizeof(buf), 0) != 3) e(0);
if (strncmp(buf, "abc", 3)) e(0);
/* Reconnect the socket to another target. */
if (connect(fdA, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) e(0);
len = sizeof(val);
if (getsockopt(fdA, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0);
if (val != 0) e(0);
if (send(fdA, "def", 3, 0) != 3) e(0);
memset(&sunC, 0, sizeof(sunC));
len = sizeof(sunC);
if (recvfrom(fdB, buf, sizeof(buf), 0, (struct sockaddr *)&sunC,
&len) != 3) e(0);
check_addr(&sunC, len, SOCK_PATH_A);
if (strncmp(buf, "def", 3)) e(0);
/* Reconnect the socket to itself again. */
if (connect(fdA, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
len = sizeof(val);
if (getsockopt(fdA, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0);
if (val != 0) e(0);
pid = fork();
switch (pid) {
case 0:
errct = 0;
if (recv(fdA, buf, sizeof(buf), 0) != 3) e(0);
if (strncmp(buf, "ghi", 3)) e(0);
exit(errct);
case -1:
e(0);
}
sleep(1);
if (send(fdA, "ghi", 3, 0) != 3) e(0);
if (waitpid(pid, &status, 0) != pid) e(0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0);
if (close(fdA) != 0) e(0);
if (close(fdB) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
if (unlink(SOCK_PATH_B) != 0) e(0);
}
/*
* Test multiple blocked calls getting resumed (or not) upon connect(2) success
* or failure. This test uses LOCAL_CONNWAIT. TODO: rewrite this to use
* interprocess communication rather than the current carefully arranged and
* rather brittle timing approach.
*/
static void
sub90f(unsigned int test)
{
struct sockaddr_un sun;
pid_t pid[4], apid;
char buf[1];
unsigned int i;
socklen_t len;
int r, fd, fd2, fl, val, status;
fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sun);
val = 1;
if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0);
if (listen(fd, 1) != 0) e(0);
apid = fork();
switch (apid) {
case 0:
errct = 0;
sleep(3);
if (test < 2) {
len = sizeof(sun);
if ((fd2 = accept(fd, (struct sockaddr *)&sun,
&len)) < 0) e(0);
sleep(2);
if (close(fd2) != 0) e(0);
}
if (close(fd) != 0) e(0);
exit(errct);
case -1:
e(0);
}
if (close(fd) != 0) e(0);
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) e(0);
for (i = 0; i < __arraycount(pid); i++) {
pid[i] = fork();
switch (pid[i]) {
case 0:
errct = 0;
sleep((i == 0) ? 1 : 2);
if ((i & 1) == 0) {
r = send(fd, "", 1, 0);
switch (test) {
case 0:
case 1:
if (r != 1) e(0);
break;
case 3:
if (i == 0) {
if (r != -1) e(0);
if (errno != ECONNRESET) e(0);
break;
}
/* FALLTHROUGH */
case 2:
if (r != -1) e(0);
if (errno != ENOTCONN) e(0);
}
} else {
r = recv(fd, buf, sizeof(buf), 0);
if (test >= 2) {
if (r != -1) e(0);
if (errno != ENOTCONN) e(0);
} else
if (r != 0) e(0);
}
exit(errct);
case -1:
e(0);
}
}
if (test & 1) {
if ((fl = fcntl(fd, F_GETFL)) == -1) e(0);
if (fcntl(fd, F_SETFL, fl | O_NONBLOCK) != 0) e(0);
}
r = connect(fd, (struct sockaddr *)&sun, sizeof(sun));
if (test & 1) {
if (r != -1) e(0);
if (errno != EINPROGRESS) e(0);
if (fcntl(fd, F_SETFL, fl) != 0) e(0);
sleep(4);
} else {
if (test >= 2) {
if (r != -1) e(0);
if (errno != ECONNRESET) e(0);
} else
if (r != 0) e(0);
sleep(1);
}
/*
* If the connect failed, collect the senders and receivers.
* Otherwise, collect just the senders.
*/
for (i = 0; i < __arraycount(pid); i++) {
r = waitpid(pid[i], &status, WNOHANG);
if (r == pid[i]) {
if (test < 2 && (i & 1)) e(0);
if (!WIFEXITED(status)) e(0);
if (WEXITSTATUS(status) != 0) e(0);
} else if (r == 0) {
if (test >= 2 || !(i & 1)) e(0);
} else
e(0);
}
if (close(fd) != 0) e(0);
/* Wait for, and collect the accepting child. */
if (waitpid(apid, &status, 0) != apid) e(0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0);
/*
* If the connect succeeded, collect the receivers, which will
* terminate once the accepting child closes the accepted socket.
*/
if (test < 2) {
if (waitpid(pid[1], &status, 0) != pid[1]) e(0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0);
if (waitpid(pid[3], &status, 0) != pid[3]) e(0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0);
}
if (unlink(SOCK_PATH_A) != 0) e(0);
}
/*
* Test multiple blocked calls getting resumed (or not) upon connect(2) success
* or failure. In particular, ensure that the error code ends up with the
* right call.
*/
static void
test90f(void)
{
subtest = 6;
/* If a connect succeeds, sends continue but reads block until EOF. */
sub90f(0); /* blocking connect */
sub90f(1); /* non-blocking connect */
/* If a blocking connect fails, the connect call gets the error. */
sub90f(2);
/* If a non-blocking connect fails, the first blocked call gets it. */
sub90f(3);
}
/*
* Test whether various calls all return the same expected error code.
*/
static void
sub90g(struct sockaddr_un * sun, int err)
{
int fd;
if ((fd = socket(AF_UNIX, SOCK_SEQPACKET, 0)) < 0) e(0);
if (connect(fd, (struct sockaddr *)sun, sizeof(*sun)) != -1) e(0);
if (errno != err) e(0);
if (close(fd) != 0) e(0);
if ((fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) e(0);
if (sendto(fd, "", 1, 0, (struct sockaddr *)sun, sizeof(*sun)) != -1)
e(0);
if (errno != err) e(0);
if (connect(fd, (struct sockaddr *)sun, sizeof(*sun)) != -1) e(0);
if (errno != err) e(0);
if (close(fd) != 0) e(0);
}
/*
* Test for error codes thrown by connect(2) and sendto(2) with problematic
* destinations. In particular, we verify that the errors for sendto(2) are
* the same as for connect(2), just like on NetBSD and Linux, even though
* POSIX does not document all of these under sendto(2).
*/
static void
test90g(void)
{
struct sockaddr_un sun;
int fd;
subtest = 7;
fd = get_bound_socket(SOCK_STREAM, SOCK_PATH_A, &sun);
sub90g(&sun, EPROTOTYPE);
if (listen(fd, 1) != 0) e(0);
sub90g(&sun, EPROTOTYPE);
if (close(fd) != 0) e(0);
sub90g(&sun, ECONNREFUSED);
if (unlink(SOCK_PATH_A) != 0) e(0);
sub90g(&sun, ENOENT);
}
/*
* Test addresses returned for unbound connection-type sockets by various
* calls.
*/
static void
sub90h(int type)
{
struct sockaddr_un sun;
socklen_t len;
char buf[1];
int fd, fd2, fd3;
fd = get_bound_socket(type, SOCK_PATH_A, &sun);
if (listen(fd, 5) != 0) e(0);
if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0);
/* Test for accept(2), which returns an empty address. */
memset(&sun, 0, sizeof(sun));
len = sizeof(sun);
if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0);
check_addr(&sun, len, NULL);
/* Test for recvfrom(2), which ignores the address pointer. */
if (send(fd2, "", 1, 0) != 1) e(0);
memset(&sun, 0, sizeof(sun));
len = sizeof(sun);
if (recvfrom(fd3, buf, sizeof(buf), 0, (struct sockaddr *)&sun,
&len) != 1) e(0);
if (len != 0) e(0);
if (sun.sun_family != 0) e(0);
if (sun.sun_len != 0) e(0);
/* Test for getsockname(2), which returns an empty address. */
memset(&sun, 0, sizeof(sun));
len = sizeof(sun);
if (getsockname(fd2, (struct sockaddr *)&sun, &len) != 0) e(0);
check_addr(&sun, len, NULL);
/* Test for getpeername(2), which returns an empty address. */
memset(&sun, 0, sizeof(sun));
len = sizeof(sun);
if (getpeername(fd3, (struct sockaddr *)&sun, &len) != 0) e(0);
check_addr(&sun, len, NULL);
if (close(fd) != 0) e(0);
if (close(fd2) != 0) e(0);
if (close(fd3) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
}
/*
* Test addresses returned for unbound sockets by various calls.
*/
static void
test90h(void)
{
struct sockaddr_un sun;
socklen_t len;
char buf[1];
int fd, fd2;
subtest = 8;
/* Connection-type socket tests. */
sub90h(SOCK_STREAM);
sub90h(SOCK_SEQPACKET);
/* Datagram socket tests. */
fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sun);
if ((fd2 = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) e(0);
if (sendto(fd2, "", 1, 0, (struct sockaddr *)&sun, sizeof(sun)) != 1)
e(0);
/*
* Datagram test for recvfrom(2), which returns no address. This is
* the one result in this subtest that is not specified by POSIX and
* (not so coincidentally) is different between NetBSD and Linux.
* MINIX3 happens to follow Linux behavior for now, but this may be
* changed in the future.
*/
memset(&sun, 0, sizeof(sun));
len = sizeof(sun);
if (recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *)&sun,
&len) != 1) e(0);
if (len != 0) e(0);
if (sun.sun_family != 0) e(0);
if (sun.sun_len != 0) e(0);
/* Datagram test for getsockname(2), which returns an empty address. */
memset(&sun, 0, sizeof(sun));
len = sizeof(sun);
if (getsockname(fd2, (struct sockaddr *)&sun, &len) != 0) e(0);
check_addr(&sun, len, NULL);
if (close(fd) != 0) e(0);
if (close(fd2) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
}
#define MAX_FDS 7
/*
* Send anywhere from zero to MAX_FDS file descriptors onto a socket, possibly
* along with regular data. Return the result of the sendmsg(2) call, with
* errno preserved. Written to be reusable outside this test set.
*/
static int
send_fds(int fd, const char * data, size_t len, int flags,
struct sockaddr * addr, socklen_t addr_len, int * fds, int nfds)
{
union {
char buf[CMSG_SPACE(MAX_FDS * sizeof(int))];
struct cmsghdr cmsg;
} control;
struct msghdr msg;
struct iovec iov;
assert(nfds >= 0 && nfds <= MAX_FDS);
iov.iov_base = __UNCONST(data);
iov.iov_len = len;
memset(&control.cmsg, 0, sizeof(control.cmsg));
control.cmsg.cmsg_len = CMSG_LEN(nfds * sizeof(int));
control.cmsg.cmsg_level = SOL_SOCKET;
control.cmsg.cmsg_type = SCM_RIGHTS;
memcpy(CMSG_DATA(&control.cmsg), fds, nfds * sizeof(int));
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = &control;
msg.msg_controllen = control.cmsg.cmsg_len;
msg.msg_name = addr;
msg.msg_namelen = addr_len;
return sendmsg(fd, &msg, flags);
}
/*
* Receive anywhere from zero to up to MAX_FDS file descriptors from a socket,
* possibly along with regular data. The 'nfds' parameter must point to the
* maximum number of file descriptors to be received. Return the result of the
* recvmsg(2) call, with errno preserved. On success, return the received
* flags in 'rflags', the received file descriptors stored in 'fds' and their
* number stored in 'nfds'. Written to be (somewhat) reusable.
*/
static int
recv_fds(int fd, char * buf, size_t size, int flags, int * rflags, int * fds,
int * nfds)
{
union {
char buf[CMSG_SPACE(MAX_FDS * sizeof(int))];
struct cmsghdr cmsg;
} control;
struct msghdr msg;
struct iovec iov;
size_t len;
int r, rnfds;
assert(*nfds >= 0 && *nfds <= MAX_FDS);
iov.iov_base = buf;
iov.iov_len = size;
memset(&control.cmsg, 0, sizeof(control.cmsg));
control.cmsg.cmsg_len = CMSG_LEN(*nfds * sizeof(int));
control.cmsg.cmsg_level = SOL_SOCKET;
control.cmsg.cmsg_type = SCM_RIGHTS;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = &control;
msg.msg_controllen = control.cmsg.cmsg_len;
if ((r = recvmsg(fd, &msg, flags)) < 0)
return r;
if (msg.msg_controllen > 0) {
assert(msg.msg_controllen <= sizeof(control));
assert(msg.msg_controllen >= sizeof(control.cmsg));
len = control.cmsg.cmsg_len - CMSG_LEN(0);
assert(len % sizeof(int) == 0);
rnfds = len / sizeof(int);
assert(rnfds <= *nfds);
memcpy(fds, CMSG_DATA(&control.cmsg), rnfds * sizeof(int));
} else
rnfds = 0;
*rflags = msg.msg_flags;
*nfds = rnfds;
return r;
}
/*
* Generate and send zero or more file descriptors onto a socket, possibly
* along with regular data. Return the result of the sendmsg(2) call, with
* errno preserved. Also return a set of peer FDs for each of the sent file
* descriptors, which should later be used in a call to close_test_fds().
*/
static int
send_test_fds(int fd, const char * data, size_t len, int flags, int * peers,
int nfds)
{
int i, r, saved_errno, fds[MAX_FDS], pfd[2];
if (nfds > MAX_FDS) e(0);
for (i = 0; i < nfds; i++) {
if (pipe2(pfd, O_NONBLOCK) != 0) e(0);
peers[i] = pfd[0];
fds[i] = pfd[1];
}
r = send_fds(fd, data, len, flags, NULL, 0, fds, nfds);
saved_errno = errno;
for (i = 0; i < nfds; i++)
if (close(fds[i]) != 0) e(0);
errno = saved_errno;
return r;
}
/*
* Given an array of peer file descriptors as returned from a call to
* send_test_fds(), test if the original file descriptors have correctly been
* closed, and close all peer file descriptors. The ultimate goal here is to
* detect any possible file descriptor leaks in the UDS service.
*/
static void
close_test_fds(int * peers, int nfds)
{
char buf[1];
unsigned int i;
int fd;
for (i = 0; i < nfds; i++) {
fd = peers[i];
/* If the other side is still open, we would get EAGAIN. */
if (read(fd, buf, sizeof(buf)) != 0) e(0);
if (close(peers[i]) != 0) e(0);
}
}
/*
* Receive and close zero or more file descriptors from a socket, possibly
* along with regular data. Return the result of the recvmsg(2) call, with
* errno preserved.
*/
static int
recv_test_fds(int fd, char * buf, size_t size, int flags, int * rflags,
int * nfds)
{
int i, r, saved_errno, fds[MAX_FDS];
if (*nfds > MAX_FDS) e(0);
if ((r = recv_fds(fd, buf, size, flags, rflags, fds, nfds)) < 0)
return r;
saved_errno = errno;
for (i = 0; i < *nfds; i++)
if (close(fds[i]) != 0) e(0);
errno = saved_errno;
return r;
}
/*
* Test receive requests on various socket states and in various forms.
* Following this function requires a very close look at what is in the
* receive queue versus what is being received.
*/
static void
sub90i_recv(int fd, int type, int state, int test, int sub, int sentfds)
{
struct msghdr msg;
struct iovec iov;
char data[4];
unsigned int i;
int res, err, nfds, rflags;
memset(data, 0, sizeof(data));
if (sub & 2) {
rflags = 0;
nfds = sentfds;
res = recv_test_fds(fd, data, (sub & 1) ? 0 : sizeof(data), 0,
&rflags, &nfds);
if (rflags & MSG_CTRUNC) e(0);
if (nfds != 0 && nfds != sentfds) e(0);
if ((type == SOCK_STREAM) && (rflags & MSG_TRUNC)) e(0);
} else {
iov.iov_base = data;
iov.iov_len = (sub & 1) ? 0 : sizeof(data);
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
res = recvmsg(fd, &msg, 0);
if (res >= 0)
rflags = msg.msg_flags;
else
rflags = 0;
nfds = 0;
}
err = errno;
if (res < -1 || res > (int)sizeof(data)) e(0);
if (type == SOCK_STREAM) {
if (sub & 1) {
/*
* Zero-size requests should receive no regular data
* and no control data, even if the tail segment is
* zero-sized and terminated. This policy is in place
* for simplicity reasons.
*/
if (res != 0) e(0);
if (nfds != 0) e(0);
if (rflags & MSG_CTRUNC) e(0);
/*
* Since nothing happened yet, do another, now non-
* zero receive call immediately, and continue as if
* that was the first call.
*/
sub = (sub & ~1) | 2;
nfds = sentfds;
rflags = 0;
res = recv_test_fds(fd, data, sizeof(data), 0, &rflags,
&nfds);
if (rflags & (MSG_TRUNC | MSG_CTRUNC)) e(0);
if (nfds != 0 && nfds != sentfds) e(0);
err = errno;
if (res < -1 || res > (int)sizeof(data)) e(0);
}
if (state == 0 && !(test & 1) && !(sub & 13)) {
/*
* There are no regular data bytes to be received, and
* the current segment may still be extended (i.e.,
* there is no EOF condition), and we are trying to
* receive at least one data byte. This is the
* SO_RCVLOWAT test.
*/
if (res != -1) e(0);
if (err != EWOULDBLOCK) e(0);
if (test == 4) {
/*
* There are still pending file descriptors but
* we cannot get them, due to the SO_RCVLOWAT
* test. This is proper behavior but somewhat
* annoying, because we want to see if UDS
* forgot to close any file descriptors. So,
* we let it force-close them here.
*/
if (shutdown(fd, SHUT_RD) != 0) e(0);
sub |= 8;
}
} else {
i = 0;
if (state == 1) {
if (res < 1) e(0);
if (data[i] != 'A') e(0);
i++;
}
if ((state == 0 && (test & 1)) ||
(state == 1 && (test == 1 || test == 3))) {
if (res < i + 1) e(0);
if (data[i] != 'B') e(0);
i++;
}
if ((sub & 4) && (state != 1 || test < 4)) {
if (res < i + 1) e(0);
if (data[i] != 'C') e(0);
i++;
}
if (i != res) e(0);
if (state == 0 && test >= 4) {
if (sub & 2) {
if (nfds != sentfds) e(0);
} else
if (!(rflags & MSG_CTRUNC)) e(0);
}
}
if (state == 1 && test >= 4) {
/*
* We just read the first segment, but there is a
* second segment with ancillary data. Read it too.
*/
nfds = sentfds;
rflags = 0;
res = recv_test_fds(fd, data, sizeof(data), 0, &rflags,
&nfds);
if (rflags & (MSG_TRUNC | MSG_CTRUNC)) e(0);
if (nfds != sentfds) e(0); /* untouched on failure */
if (res < -1 || res > (int)sizeof(data)) e(0);
if (test != 5 && !(sub & 12)) {
if (res != -1) e(0);
if (errno != EWOULDBLOCK) e(0);
/* As above. */
if (shutdown(fd, SHUT_RD) != 0) e(0);
sub |= 8;
} else {
if (res != (test == 5) + !!(sub & 4)) e(0);
if (test == 5 && data[0] != 'B') e(0);
if ((sub & 4) && data[res - 1] != 'C') e(0);
}
}
} else {
if (res != ((state == 1 || (test & 1)) && !(sub & 1))) e(0);
if (state == 0 && test >= 4) {
if (sub & 2) {
if (nfds != sentfds) e(0);
} else
if (!(rflags & MSG_CTRUNC)) e(0);
}
if (res > 0 && data[0] != ((state == 1) ? 'A' : 'B')) e(0);
if (state == 1) {
nfds = sentfds;
rflags = 0;
res = recv_test_fds(fd, data, sizeof(data), 0, &rflags,
&nfds);
if (res != (test & 1)) e(0);
if (res > 0 && data[0] != 'B') e(0);
if (nfds != ((test >= 4) ? sentfds : 0)) e(0);
}
if (sub & 4) {
nfds = sentfds;
rflags = 0;
res = recv_test_fds(fd, data, sizeof(data), 0, &rflags,
&nfds);
if (res != 1) e(0);
if (data[0] != 'C') e(0);
if (nfds != 0) e(0);
}
}
/*
* At this point, there is nothing to receive. Depending on
* whether we closed the socket, we expect EOF or EWOULDBLOCK.
*/
res = recv(fd, data, sizeof(data), 0);
if (type == SOCK_DGRAM || !(sub & 8)) {
if (res != -1) e(0);
if (errno != EWOULDBLOCK) e(0);
} else
if (res != 0) e(0);
}
/*
* Test send requests on various socket states and in various forms.
*/
static void
sub90i_send(int type, int state, int test, int sub)
{
char *buf;
int r, res, err, fd[2], peers[2], rcvlen;
get_socket_pair(type | SOCK_NONBLOCK, fd);
/*
* State 0: an empty buffer.
* State 1: a non-empty, non-full buffer.
* State 2: a full buffer.
*/
if (state == 2) {
if (type == SOCK_STREAM) {
rcvlen = get_rcvbuf_len(fd[0]);
if ((buf = malloc(rcvlen)) == NULL) e(0);
memset(buf, 'A', rcvlen);
if (send(fd[0], buf, rcvlen, 0) != rcvlen) e(0);
free(buf);
} else {
while ((r = send(fd[0], "A", 1, 0)) == 1);
if (r != -1) e(0);
if (errno !=
((type == SOCK_SEQPACKET) ? EAGAIN : ENOBUFS))
e(0);
}
} else if (state == 1)
if (send(fd[0], "A", 1, 0) != 1) e(0);
/*
* Test 0: no data, no control data.
* Test 1: data, no control data.
* Test 2: no data, empty control data.
* Test 3: data, empty control data.
* Test 4: no data, control data with a file descriptor.
* Test 5: data, control data with a file descriptor.
*/
switch (test) {
case 0:
case 1:
res = send(fd[0], "B", test % 2, 0);
err = errno;
break;
case 2:
case 3:
res = send_test_fds(fd[0], "B", test % 2, 0, NULL, 0);
err = errno;
break;
case 4:
case 5:
res = send_test_fds(fd[0], "B", test % 2, 0, peers,
__arraycount(peers));
err = errno;
break;
default:
res = -1;
err = EINVAL;
e(0);
}
if (res < -1 || res > 1) e(0);
switch (state) {
case 0:
case 1:
if (res != (test % 2)) e(0);
/*
* Subtest bit 0x1: try a zero-size receive first.
* Subtest bit 0x2: try receiving control data.
* Subtest bit 0x4: send an extra segment with no control data.
* Subtest bit 0x8: after completing receives, expect EOF.
*/
if (sub & 4)
if (send(fd[0], "C", 1, 0) != 1) e(0);
if (sub & 8)
if (shutdown(fd[0], SHUT_WR) != 0) e(0);
/*
* Assuming (sub&4), which means there is an extra "C"..
*
* For stream sockets, we should now receive:
* - state 0:
* - test 0, 2: "C"
* - test 1, 3: "BC"
* - test 4: "C" (w/fds)
* - test 5: "BC" (w/fds)
* - state 1:
* - test 0, 2: "AC"
* - test 1, 3: "ABC"
* - test 4: "A", "C" (w/fds)
* - test 5: "A", "BC" (w/fds)
*
* For packet sockets, we should now receive:
* - state 1:
* - all tests: "A", followed by..
* - state 0, 1:
* - test 0, 2: "" (no fds), "C"
* - test 1, 3: "B" (no fds), "C"
* - test 4: "" (w/fds), "C"
* - test 5: "B" (w/fds), "C"
*/
sub90i_recv(fd[1], type, state, test, sub,
__arraycount(peers));
break;
case 2:
/*
* Alright, the results are a bit tricky to interpret here,
* because UDS's current strict send admission control prevents
* the receive buffer from being fully utilized. We therefore
* only test the following aspects:
*
* - if we sent no regular or control data to a stream socket,
* the call should have succeeded (note that the presence of
* empty control data may cause the call to fail);
* - if we sent either regular or control data to a stream
* socket, the call should have failed with EWOULDBLOCK;
* - if the call failed, the error should have been EWOULDBLOCK
* for connection-type sockets and ENOBUFS for connectionless
* sockets.
*
* Everything else gets a pass; we can't even be sure that for
* packet-oriented sockets we completely filled up the buffer.
*/
if (res == -1) {
if (type == SOCK_STREAM && test == 0) e(0);
if (type != SOCK_DGRAM && err != EWOULDBLOCK) e(0);
if (type == SOCK_DGRAM && err != ENOBUFS) e(0);
} else
if (type == SOCK_STREAM && test != 0) e(0);
break;
}
/*
* Make sure there are no more in-flight file descriptors now, even
* before closing the socket.
*/
if (res >= 0 && test >= 4)
close_test_fds(peers, __arraycount(peers));
close(fd[0]);
close(fd[1]);
}
/*
* Test send and receive requests with regular data, control data, both, or
* neither, and test segment boundaries.
*/
static void
test90i(void)
{
int state, test, sub;
subtest = 9;
for (state = 0; state < 3; state++) {
for (test = 0; test < 6; test++) {
for (sub = 0; sub < ((state < 2) ? 16 : 1); sub++) {
sub90i_send(SOCK_STREAM, state, test, sub);
sub90i_send(SOCK_SEQPACKET, state, test, sub);
sub90i_send(SOCK_DGRAM, state, test, sub);
}
}
}
}
/*
* Test segmentation of file descriptor transfer on a particular socket type.
*/
static void
sub90j(int type)
{
char path[PATH_MAX], buf[2];
int i, fd[2], out[7], in[7], rflags, nfds;
ssize_t len;
get_socket_pair(type, fd);
for (i = 0; i < __arraycount(out); i++) {
snprintf(path, sizeof(path), "file%d", i);
out[i] = open(path, O_RDWR | O_CREAT | O_EXCL | O_TRUNC, 0644);
if (out[i] < 0) e(0);
if (write(out[i], path, strlen(path)) != strlen(path)) e(0);
if (lseek(out[i], 0, SEEK_SET) != 0) e(0);
}
if (send_fds(fd[1], "A", 1, 0, NULL, 0, &out[0], 1) != 1) e(0);
if (send_fds(fd[1], "B", 1, 0, NULL, 0, &out[1], 3) != 1) e(0);
if (send_fds(fd[1], "C", 1, 0, NULL, 0, &out[4], 2) != 1) e(0);
nfds = 2;
if (recv_fds(fd[0], buf, sizeof(buf), 0, &rflags, &in[0], &nfds) != 1)
e(0);
if (buf[0] != 'A') e(0);
if (rflags != 0) e(0);
if (nfds != 1) e(0);
nfds = 5;
if (recv_fds(fd[0], buf, sizeof(buf), 0, &rflags, &in[1], &nfds) != 1)
e(0);
if (buf[0] != 'B') e(0);
if (rflags != 0) e(0);
if (nfds != 3) e(0);
if (send_fds(fd[1], "D", 1, 0, NULL, 0, &out[6], 1) != 1) e(0);
nfds = 2;
if (recv_fds(fd[0], buf, sizeof(buf), 0, &rflags, &in[4], &nfds) != 1)
e(0);
if (buf[0] != 'C') e(0);
if (rflags != 0) e(0);
if (nfds != 2) e(0);
nfds = 2;
if (recv_fds(fd[0], buf, sizeof(buf), 0, &rflags, &in[6], &nfds) != 1)
e(0);
if (buf[0] != 'D') e(0);
if (rflags != 0) e(0);
if (nfds != 1) e(0);
for (i = 0; i < __arraycount(in); i++) {
len = read(in[i], path, sizeof(path));
if (len < 5 || len > 7) e(0);
path[len] = '\0';
if (strncmp(path, "file", 4) != 0) e(0);
if (atoi(&path[4]) != i) e(0);
if (unlink(path) != 0) e(0);
if (close(in[i]) != 0) e(0);
}
for (i = 0; i < __arraycount(out); i++)
if (close(out[i]) != 0) e(0);
/*
* While we're here, see if UDS properly closes any remaining in-flight
* file descriptors when the socket is closed.
*/
if (send_test_fds(fd[1], "E", 1, 0, out, 7) != 1) e(0);
close(fd[0]);
close(fd[1]);
close_test_fds(out, 7);
}
/*
* Test segmentation of file descriptor transfer. That is, there are multiple
* in-flight file descriptors, they must each be associated with their
* respective segments.
*/
static void
test90j(void)
{
subtest = 10;
sub90j(SOCK_STREAM);
sub90j(SOCK_SEQPACKET);
sub90j(SOCK_DGRAM);
}
/*
* Test whether we can deadlock UDS by making it close the last reference to
* an in-flight file descriptor for a UDS socket. Currently we allow VFS/UDS
* to get away with throwing EDEADLK as a sledgehammer approach to preventing
* problems with in-flight UDS sockets.
*/
static void
test90k(void)
{
int r, fd[2], fd2;
subtest = 11;
get_socket_pair(SOCK_STREAM, fd);
if ((fd2 = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) e(0);
if ((r = send_fds(fd[0], "X", 1, 0, NULL, 0, &fd2, 1)) != 1) {
if (r != -1) e(0);
if (errno != EDEADLK) e(0); /* whew */
}
if (close(fd2) != 0) e(0);
if (close(fd[0]) != 0) e(0);
if (close(fd[1]) != 0) e(0); /* boom */
}
/*
* Test whether we can make UDS run out of file descriptors by transferring a
* UDS socket over itself and then closing all other references while it is
* in-flight. Currently we allow VFS/UDS to get away with throwing EDEADLK as
* a sledgehammer approach to preventing problems with in-flight UDS sockets.
*/
static void
test90l(void)
{
struct sockaddr_un sun;
int i, r, fd, fd2;
subtest = 12;
fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sun);
for (i = 0; i < OPEN_MAX + 1; i++) {
if ((fd2 = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) e(0);
if ((r = send_fds(fd2, "X", 1, 0, (struct sockaddr *)&sun,
sizeof(sun), &fd2, 1)) != 1) {
if (r != -1) e(0);
if (errno != EDEADLK) e(0); /* whew */
}
if (close(fd2) != 0) e(0); /* have fun in limbo.. */
}
if (close(fd) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
}
/*
* Receive with credentials.
*/
static int
recv_creds(int fd, char * buf, size_t size, int flags, int * rflags,
struct sockcred * sc, socklen_t * sc_len)
{
union {
char buf[CMSG_SPACE(SOCKCREDSIZE(NGROUPS_MAX))];
struct cmsghdr cmsg;
} control;
struct msghdr msg;
struct iovec iov;
size_t len;
int r;
iov.iov_base = buf;
iov.iov_len = size;
memset(&control.cmsg, 0, sizeof(control.cmsg));
control.cmsg.cmsg_len = CMSG_LEN(SOCKCREDSIZE(NGROUPS_MAX));
control.cmsg.cmsg_level = SOL_SOCKET;
control.cmsg.cmsg_type = SCM_RIGHTS;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = &control;
msg.msg_controllen = control.cmsg.cmsg_len;
if ((r = recvmsg(fd, &msg, flags)) < 0)
return r;
if (msg.msg_controllen > 0) {
assert(msg.msg_controllen <= sizeof(control));
assert(msg.msg_controllen >= sizeof(control.cmsg));
assert(control.cmsg.cmsg_len <= msg.msg_controllen);
len = control.cmsg.cmsg_len - CMSG_LEN(0);
assert(len >= sizeof(struct sockcred));
assert(len <= SOCKCREDSIZE(NGROUPS_MAX));
if (*sc_len > len)
*sc_len = len;
memcpy(sc, CMSG_DATA(&control.cmsg), *sc_len);
} else
*sc_len = 0;
*rflags = msg.msg_flags;
return r;
}
/*
* Test basic credentials passing on connection-oriented sockets.
*/
static void
sub90m(int type)
{
struct sockaddr_un sun;
struct sockcred sc;
struct msghdr msg;
struct iovec iov;
socklen_t len;
char buf[1];
int fd, fd2, fd3, val, rflags;
fd = get_bound_socket(type, SOCK_PATH_A, &sun);
val = 1;
if (setsockopt(fd, 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0);
if (listen(fd, 1) != 0) e(0);
if ((fd2 = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0);
len = sizeof(sun);
if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0);
if (send(fd2, "A", 1, 0) != 1) e(0);
if (send(fd2, "B", 1, 0) != 1) e(0);
len = sizeof(sc);
if (recv_creds(fd3, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1)
e(0);
if (buf[0] != 'A') e(0);
if (rflags != 0) e(0);
if (len != sizeof(sc)) e(0);
if (sc.sc_uid != getuid()) e(0);
if (sc.sc_euid != geteuid()) e(0);
len = sizeof(sc);
if (recv_creds(fd3, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1)
e(0);
if (buf[0] != 'B') e(0);
if (rflags != 0) e(0);
if (len != 0) e(0);
if (send(fd3, "C", 1, 0) != 1) e(0);
val = 1;
if (setsockopt(fd2, 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0);
if (send(fd3, "D", 1, 0) != 1) e(0);
val = 1;
if (setsockopt(fd2, 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0);
if (send(fd3, "E", 1, 0) != 1) e(0);
len = sizeof(sc);
if (recv_creds(fd2, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1)
e(0);
if (buf[0] != 'C') e(0);
if (rflags != 0) e(0);
if (len != 0) e(0);
len = sizeof(sc);
if (recv_creds(fd2, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1)
e(0);
if (buf[0] != 'D') e(0);
if (rflags != 0) e(0);
if (len != sizeof(sc)) e(0);
if (sc.sc_uid != getuid()) e(0);
if (sc.sc_euid != geteuid()) e(0);
memset(&msg, 0, sizeof(msg));
iov.iov_base = buf;
iov.iov_len = sizeof(buf);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
if (recvmsg(fd2, &msg, 0) != 1) e(0);
if (buf[0] != 'E') e(0);
if (msg.msg_flags != MSG_CTRUNC) e(0);
if (close(fd2) != 0) e(0);
if (close(fd3) != 0) e(0);
val = 0;
if (setsockopt(fd, 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0);
if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0);
len = sizeof(sun);
if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0);
if (send(fd2, "F", 1, 0) != 1) e(0);
len = sizeof(sc);
if (recv_creds(fd3, buf, sizeof(buf), 0, &rflags, &sc, &len) != 1)
e(0);
if (buf[0] != 'F') e(0);
if (rflags != 0) e(0);
if (len != 0) e(0);
if (close(fd) != 0) e(0);
if (close(fd2) != 0) e(0);
if (close(fd3) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
}
/*
* A few tests for credentials passing that matter to some applications:
* the credentials passing setting is inherited by accepted connections from
* their listening socket, and, credentials are passed only once on a
* connection-oriented socket.
*/
static void
test90m(void)
{
struct sockcred sc;
socklen_t len;
char buf[1];
int fd[2], val, rflags;
subtest = 13;
sub90m(SOCK_STREAM);
sub90m(SOCK_SEQPACKET);
get_socket_pair(SOCK_DGRAM, fd);
val = 1;
if (setsockopt(fd[0], 0, LOCAL_CREDS, &val, sizeof(val)) != 0) e(0);
if (send(fd[1], "A", 1, 0) != 1) e(0);
if (send(fd[0], "B", 1, 0) != 1) e(0);
if (send(fd[1], "C", 1, 0) != 1) e(0);
len = sizeof(sc);
if (recv_creds(fd[0], buf, sizeof(buf), 0, &rflags, &sc, &len) != 1)
e(0);
if (buf[0] != 'A') e(0);
if (rflags != 0) e(0);
if (len != sizeof(sc)) e(0);
if (sc.sc_uid != getuid()) e(0);
if (sc.sc_euid != geteuid()) e(0);
len = sizeof(sc);
if (recv_creds(fd[1], buf, sizeof(buf), 0, &rflags, &sc, &len) != 1)
e(0);
if (buf[0] != 'B') e(0);
if (rflags != 0) e(0);
if (len != 0) e(0);
len = sizeof(sc);
if (recv_creds(fd[0], buf, sizeof(buf), 0, &rflags, &sc, &len) != 1)
e(0);
if (buf[0] != 'C') e(0);
if (rflags != 0) e(0);
if (len != sizeof(sc)) e(0);
if (sc.sc_uid != getuid()) e(0);
if (sc.sc_euid != geteuid()) e(0);
if (close(fd[0]) != 0) e(0);
if (close(fd[1]) != 0) e(0);
}
/*
* Test whether MSG_CMSG_CLOEXEC is honored when copying in file descriptors.
* We do not bother to test with execve(2w); obtaining the FD flags suffices.
*/
static void
test90n(void)
{
char buf[1];
int i, fd[2], sfd, rfd, fl, rflags, nfds;
subtest = 14;
get_socket_pair(SOCK_STREAM, fd);
if ((sfd = open("/dev/null", O_RDONLY)) < 0) e(0);
if (send_fds(fd[0], "A", 1, 0, NULL, 0, &sfd, 1) != 1) e(0);
if (send_fds(fd[0], "B", 1, 0, NULL, 0, &sfd, 1) != 1) e(0);
if ((fl = fcntl(sfd, F_GETFD, 0)) < 0) e(0);
if (fcntl(sfd, F_SETFD, fl | FD_CLOEXEC) != 0) e(0);
if (send_fds(fd[0], "C", 1, 0, NULL, 0, &sfd, 1) != 1) e(0);
if (send_fds(fd[0], "D", 1, 0, NULL, 0, &sfd, 1) != 1) e(0);
for (i = 0; i < 4; i++) {
fl = (i & 1) ? MSG_CMSG_CLOEXEC : 0;
nfds = 1;
if (recv_fds(fd[1], buf, sizeof(buf), fl, &rflags, &rfd,
&nfds) != 1) e(0);
if (buf[0] != 'A' + i) e(0);
if (rflags != 0) e(0);
if (nfds != 1) e(0);
if ((fl = fcntl(rfd, F_GETFD, 0)) < 0) e(0);
if (!!(fl & FD_CLOEXEC) != (i & 1)) e(0);
if (close(rfd) != 0) e(0);
}
if (close(sfd) != 0) e(0);
if (close(fd[0]) != 0) e(0);
if (close(fd[1]) != 0) e(0);
}
/*
* Test failures sending and receiving sets of file descriptors.
*/
static void
sub90o(int type)
{
static int ofd[OPEN_MAX];
char buf[1];
int i, fd[2], sfd[2], rfd[2], rflags, nfds;
get_socket_pair(type, fd);
if ((sfd[0] = open("/dev/null", O_RDONLY)) < 0) e(0);
sfd[1] = -1;
if (send_fds(fd[0], "A", 1, 0, NULL, 0, &sfd[1], 1) != -1) e(0);
if (errno != EBADF) e(0);
if (send_fds(fd[0], "B", 1, 0, NULL, 0, &sfd[0], 2) != -1) e(0);
if (errno != EBADF) e(0);
if ((sfd[1] = dup(sfd[0])) < 0) e(0);
if (send_fds(fd[0], "C", 1, 0, NULL, 0, &sfd[0], 2) != 1) e(0);
for (i = 0; i < __arraycount(ofd); i++) {
if ((ofd[i] = dup(sfd[0])) < 0) {
/* Either will do. */
if (errno != EMFILE && errno != ENFILE) e(0);
break;
}
}
nfds = 2;
if (recv_fds(fd[1], buf, sizeof(buf), 0, &rflags, rfd, &nfds) != -1)
e(0);
if (errno != ENFILE && errno != EMFILE) e(0);
if (close(sfd[1]) != 0) e(0);
nfds = 2;
if (recv_fds(fd[1], buf, sizeof(buf), 0, &rflags, rfd, &nfds) != -1)
e(0);
if (errno != ENFILE && errno != EMFILE) e(0);
if (close(sfd[0]) != 0) e(0);
nfds = 2;
if (recv_fds(fd[1], buf, sizeof(buf), 0, &rflags, rfd, &nfds) != 1)
e(0);
if (buf[0] != 'C') e(0);
if (rflags != 0) e(0);
if (nfds != 2) e(0);
if (close(rfd[1]) != 0) e(0);
if (close(rfd[0]) != 0) e(0);
while (i-- > 0)
if (close(ofd[i]) != 0) e(0);
if (close(fd[1]) != 0) e(0);
if (close(fd[0]) != 0) e(0);
}
/*
* Test failures sending and receiving sets of file descriptors.
*/
static void
test90o(void)
{
const int types[] = { SOCK_STREAM, SOCK_SEQPACKET, SOCK_DGRAM };
int i;
subtest = 15;
for (i = 0; i < OPEN_MAX + 1; i++)
sub90o(types[i % __arraycount(types)]);
}
/*
* Test socket reuse for a particular socket type.
*/
static void
sub90p(int type)
{
struct sockaddr_un sunA, sunB, sunC;
socklen_t len;
char buf[1];
uid_t euid;
gid_t egid;
int fd, fd2, fd3, val;
if ((fd = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
/* Unconnected. */
if (getpeereid(fd, &euid, &egid) != -1) e(0);
if (errno != ENOTCONN) e(0);
fd2 = get_bound_socket(type, SOCK_PATH_A, &sunA);
val = 1;
if (setsockopt(fd2, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0);
if (listen(fd2, 5) != 0) e(0);
if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != -1) e(0);
if (errno != EINPROGRESS) e(0);
/* Connecting. */
if (getpeereid(fd, &euid, &egid) != -1) e(0);
if (errno != ENOTCONN) e(0);
len = sizeof(sunB);
if ((fd3 = accept(fd2, (struct sockaddr *)&sunB, &len)) < 0) e(0);
/* Connected. */
len = sizeof(sunC);
if (getpeername(fd, (struct sockaddr *)&sunC, &len) != 0) e(0);
check_addr(&sunC, len, SOCK_PATH_A);
if (getpeereid(fd, &euid, &egid) != 0) e(0);
if (euid == -1 || egid == -1) e(0);
if (getpeereid(fd3, &euid, &egid) != 0) e(0);
if (euid == -1 || egid == -1) e(0);
if (send(fd3, "A", 1, 0) != 1) e(0);
if (send(fd3, "B", 1, 0) != 1) e(0);
if (send(fd3, "C", 1, 0) != 1) e(0);
if (close(fd3) != 0) e(0);
/* Disconnected. */
if (getpeereid(fd, &euid, &egid) != -1) e(0);
if (errno != ENOTCONN) e(0);
if (close(fd2) != 0) e(0);
fd2 = get_bound_socket(type, SOCK_PATH_B, &sunA);
if (listen(fd2, 5) != 0) e(0);
val = 1;
if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0);
if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != -1) e(0);
if (errno != EINPROGRESS) e(0);
/* Connecting. */
if (getpeereid(fd, &euid, &egid) != -1) e(0);
if (errno != ENOTCONN) e(0);
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'A') e(0);
len = sizeof(sunB);
if ((fd3 = accept(fd2, (struct sockaddr *)&sunB, &len)) < 0) e(0);
/* Connected. */
if (send(fd3, "D", 1, 0) != 1) e(0);
if (send(fd3, "E", 1, 0) != 1) e(0);
len = sizeof(sunC);
if (getpeername(fd, (struct sockaddr *)&sunC, &len) != 0) e(0);
check_addr(&sunC, len, SOCK_PATH_B);
if (getpeereid(fd, &euid, &egid) != 0) e(0);
if (euid == -1 || egid == -1) e(0);
if (close(fd2) != 0) e(0);
if (unlink(SOCK_PATH_B) != 0) e(0);
if (close(fd3) != 0) e(0);
/* Disconnected. */
if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != -1) e(0);
if (errno != ENOENT) e(0);
/* Unconnected. */
if (getpeereid(fd, &euid, &egid) != -1) e(0);
if (errno != ENOTCONN) e(0);
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'B') e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
if (bind(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'C') e(0);
val = 0;
if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0) e(0);
if (listen(fd, 1) != 0) e(0);
/* Listening. */
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'D') e(0);
if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
len = sizeof(sunC);
if ((fd3 = accept(fd, (struct sockaddr *)&sunC, &len)) < 0) e(0);
if (send(fd2, "F", 1, 0) != 1) e(0);
if (recv(fd3, buf, 1, 0) != 1) e(0);
if (buf[0] != 'F') e(0);
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'E') e(0);
if (recv(fd, buf, 1, 0) != -1) e(0);
if (errno != ENOTCONN) e(0);
/* It should be possible to obtain peer credentials now. */
if (getpeereid(fd2, &euid, &egid) != 0) e(0);
if (euid == -1 || egid == -1) e(0);
if (getpeereid(fd3, &euid, &egid) != 0) e(0);
if (euid == -1 || egid == -1) e(0);
if (close(fd3) != 0) e(0);
if (close(fd2) != 0) e(0);
if (close(fd) != 0) e(0);
/* Closed. */
if (unlink(SOCK_PATH_B) != 0) e(0);
if ((fd = socket(AF_UNIX, type, 0)) < 0) e(0);
/* Unconnected. */
fd2 = get_bound_socket(type, SOCK_PATH_A, &sunA);
if (listen(fd2, 5) != 0) e(0);
if (connect(fd, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
/* Connected. */
len = sizeof(sunB);
if ((fd3 = accept(fd2, (struct sockaddr *)&sunB, &len)) < 0) e(0);
if (close(fd2) != 0) e(0);
memset(&sunB, 0, sizeof(sunB));
sunB.sun_family = AF_UNIX;
strlcpy(sunB.sun_path, SOCK_PATH_B, sizeof(sunB.sun_path));
if (bind(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) e(0);
if (close(fd3) != 0) e(0);
/* Disconnected. */
if (listen(fd, 1) != 0) e(0);
/* Listening. */
if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) e(0);
len = sizeof(sunC);
if ((fd3 = accept(fd, (struct sockaddr *)&sunC, &len)) < 0) e(0);
/* It should NOT be possible to obtain peer credentials now. */
if (getpeereid(fd2, &euid, &egid) != -1) e(0);
if (errno != EINVAL) e(0);
if (getpeereid(fd3, &euid, &egid) != 0) e(0);
if (euid == -1 || egid == -1) e(0);
if (close(fd3) != 0) e(0);
if (close(fd2) != 0) e(0);
if (close(fd) != 0) e(0);
/* Closed. */
if (unlink(SOCK_PATH_A) != 0) e(0);
if (unlink(SOCK_PATH_B) != 0) e(0);
}
/*
* Test socket reuse, receiving left-overs in the receive buffer, and the
* (in)ability to obtain peer credentials.
*/
static void
test90p(void)
{
subtest = 16;
sub90p(SOCK_STREAM);
sub90p(SOCK_SEQPACKET);
}
/*
* Test state changes and errors related to connected datagram sockets.
*/
static void
test90q(void)
{
struct sockaddr_un sunA, sunB, sunC, sunD;
socklen_t len;
char buf[1];
int fd, fd2, fd3, val;
subtest = 17;
/*
* Sending a datagram to a datagram socket connected elsewhere should
* fail explicitly (specifically, EPERM).
*/
fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sunA);
fd2 = get_bound_socket(SOCK_DGRAM, SOCK_PATH_B, &sunB);
fd3 = get_bound_socket(SOCK_DGRAM, SOCK_PATH_C, &sunC);
if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (sendto(fd3, "A", 1, 0, (struct sockaddr *)&sunB,
sizeof(sunB)) != -1) e(0);
if (errno != EPERM) e(0);
/* Similarly, connecting to such a socket should fail. */
if (connect(fd3, (struct sockaddr *)&sunB, sizeof(sunB)) != -1) e(0);
if (errno != EPERM) e(0);
if (send(fd2, "B", 1, 0) != 1) e(0);
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'B') e(0);
/* Reconnection of a socket's target should result in ECONNRESET. */
if (connect(fd, (struct sockaddr *)&sunC, sizeof(sunC)) != 0) e(0);
len = sizeof(val);
if (getsockopt(fd2, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0);
if (val != ECONNRESET) e(0);
if (send(fd2, "C", 1, 0) != -1) e(0);
if (errno != EDESTADDRREQ) e(0);
if (send(fd, "D", 1, 0) != 1) e(0);
len = sizeof(sunD);
if (recvfrom(fd3, buf, 1, 0, (struct sockaddr *)&sunD, &len) != 1)
e(0);
if (buf[0] != 'D') e(0);
check_addr(&sunD, len, SOCK_PATH_A);
if (connect(fd2, (struct sockaddr *)&sunC, sizeof(sunC)) != 0) e(0);
if (connect(fd3, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
memset(&sunD, 0, sizeof(sunD));
sunD.sun_family = AF_UNIX;
strlcpy(sunD.sun_path, SOCK_PATH_D, sizeof(sunD.sun_path));
/* A failed reconnection attempt should not break the previous one. */
if (connect(fd3, (struct sockaddr *)&sunD, sizeof(sunD)) != -1) e(0);
if (errno != ENOENT) e(0);
/* The destination address should be ignored here. */
if (sendto(fd3, "E", 1, 0, (struct sockaddr *)&sunB,
sizeof(sunB)) != 1) e(0);
if (recv(fd2, buf, 1, 0) != -1) e(0);
if (errno != ECONNRESET) e(0);
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'E') e(0);
if (close(fd3) != 0) e(0);
len = sizeof(val);
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0);
if (val != ECONNRESET) e(0);
if (close(fd2) != 0) e(0);
len = sizeof(val);
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0);
if (val != 0) e(0);
if (close(fd) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
if (unlink(SOCK_PATH_B) != 0) e(0);
if (unlink(SOCK_PATH_C) != 0) e(0);
/*
* Finally, test unconnecting sockets.
*/
fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A, &sunA);
fd2 = get_bound_socket(SOCK_DGRAM, SOCK_PATH_B, &sunB);
if (connect(fd, (struct sockaddr *)&sunB, sizeof(sunB)) != 0) e(0);
if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (sendto(fd2, "F", 1, 0, NULL, 0) != 1) e(0);
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'F') e(0);
memset(&sunC, 0, sizeof(sunC));
sunC.sun_family = AF_UNSPEC;
if (connect(fd2, (struct sockaddr *)&sunC, sizeof(sunC)) != 0) e(0);
len = sizeof(val);
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &val, &len) != 0) e(0);
if (val != 0) e(0);
if (send(fd, "G", 1, 0) != 1) e(0);
if (sendto(fd2, "H", 1, 0, NULL, 0) != -1) e(0);
if (errno != EDESTADDRREQ) e(0);
if (sendto(fd2, "I", 1, 0, (struct sockaddr *)&sunA, sizeof(sunA)) != 1)
e(0);
if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (sendto(fd2, "J", 1, 0, NULL, 0) != 1) e(0);
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'I') e(0);
if (recv(fd, buf, 1, 0) != 1) e(0);
if (buf[0] != 'J') e(0);
if (recv(fd2, buf, 1, 0) != 1) e(0);
if (buf[0] != 'G') e(0);
if (close(fd) != 0) e(0);
if (close(fd2) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
if (unlink(SOCK_PATH_B) != 0) e(0);
}
/*
* Test socket file name reuse.
*/
static void
test90r(void)
{
struct sockaddr_un sun;
socklen_t len;
int fd, fd2, fd3, fd4;
subtest = 18;
fd = get_bound_socket(SOCK_STREAM | SOCK_NONBLOCK, SOCK_PATH_A, &sun);
if (rename(SOCK_PATH_A, SOCK_PATH_B) != 0) e(0);
if ((fd3 = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) e(0);
if (connect(fd3, (struct sockaddr *)&sun, sizeof(sun)) != -1) e(0);
if (errno != ENOENT) e(0);
if (listen(fd, 1) != 0) e(0);
len = sizeof(sun);
if (getsockname(fd, (struct sockaddr *)&sun, &len) != 0) e(0);
check_addr(&sun, len, SOCK_PATH_A);
fd2 = get_bound_socket(SOCK_STREAM | SOCK_NONBLOCK, SOCK_PATH_A, &sun);
if (listen(fd2, 1) != 0) e(0);
len = sizeof(sun);
if (getsockname(fd2, (struct sockaddr *)&sun, &len) != 0) e(0);
check_addr(&sun, len, SOCK_PATH_A);
len = sizeof(sun);
if (getsockname(fd, (struct sockaddr *)&sun, &len) != 0) e(0);
check_addr(&sun, len, SOCK_PATH_A);
memset(&sun, 0, sizeof(sun));
sun.sun_family = AF_UNIX;
strlcpy(sun.sun_path, SOCK_PATH_B, sizeof(sun.sun_path));
if (connect(fd3, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0);
len = sizeof(sun);
if ((fd4 = accept(fd2, (struct sockaddr *)&sun, &len)) >= 0) e(0);
if (errno != EWOULDBLOCK) e(0);
if ((fd4 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0);
len = sizeof(sun);
if (getpeername(fd3, (struct sockaddr *)&sun, &len) != 0) e(0);
check_addr(&sun, len, SOCK_PATH_A);
if (close(fd) != 0) e(0);
if (close(fd2) != 0) e(0);
if (close(fd3) != 0) e(0);
if (close(fd4) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
if (unlink(SOCK_PATH_B) != 0) e(0);
}
/*
* Test that non-canonized path names are accepted and returned.
* Also test datagram send errors on disconnect.
*/
static void
test90s(void)
{
struct sockaddr_un sun;
socklen_t len;
int fd, fd2;
subtest = 19;
fd = get_bound_socket(SOCK_DGRAM, SOCK_PATH_A_X, &sun);
if ((fd2 = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) e(0);
memset(&sun, 0, sizeof(sun));
sun.sun_family = AF_UNIX;
strlcpy(sun.sun_path, SOCK_PATH_A_Y, sizeof(sun.sun_path));
if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0);
len = sizeof(sun);
if (getpeername(fd2, (struct sockaddr *)&sun, &len) != 0) e(0);
check_addr(&sun, len, SOCK_PATH_A_X);
if (send(fd2, "A", 1, 0) != 1) e(0);
if (close(fd) != 0) e(0);
if (send(fd2, "B", 1, 0) != -1) e(0);
if (errno != ECONNRESET) e(0);
if (send(fd2, "B", 1, 0) != -1) e(0);
if (errno != EDESTADDRREQ) e(0);
if (close(fd2) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
}
/*
* Test basic sysctl(2) socket enumeration for a specific socket type.
*/
static void
sub90t(int type, const char * path)
{
struct kinfo_pcb *ki;
size_t i, len, oldlen;
int fd, mib[8];
if ((fd = socket(AF_UNIX, type, 0)) < 0) e(0);
memset(mib, 0, sizeof(mib));
len = __arraycount(mib);
if (sysctlnametomib(path, mib, &len) != 0) e(0);
if (len != 4) e(0);
if (sysctl(mib, __arraycount(mib), NULL, &oldlen, NULL, 0) != 0) e(0);
if (oldlen == 0) e(0);
if (oldlen % sizeof(*ki)) e(0);
if ((ki = (struct kinfo_pcb *)malloc(oldlen)) == NULL) e(0);
if (sysctl(mib, __arraycount(mib), ki, &oldlen, NULL, 0) != 0) e(0);
if (oldlen == 0) e(0);
if (oldlen % sizeof(*ki)) e(0);
/*
* We cannot check a whole lot of things, because we have no way of
* knowing which is the socket we created. Check some basics and leave
* it at that. This subtest is mostly trying to guarantee that
* netstat(1) will not show nothing, anyway.
*/
for (i = 0; i < oldlen / sizeof(*ki); i++) {
if (ki[i].ki_pcbaddr == 0) e(0);
if (ki[i].ki_sockaddr == 0) e(0);
if (ki[i].ki_family != AF_UNIX) e(0);
if (ki[i].ki_type != type) e(0);
if (ki[i].ki_protocol != 0) e(0);
}
free(ki);
if (close(fd) != 0) e(0);
}
/*
* Test basic sysctl(2) socket enumeration support.
*/
static void
test90t(void)
{
subtest = 20;
/*
* We test that for each of the socket types, when we create a socket,
* we can find at least one socket of that type in the respective
* sysctl(2) out.
*/
sub90t(SOCK_STREAM, "net.local.stream.pcblist");
sub90t(SOCK_SEQPACKET, "net.local.seqpacket.pcblist");
sub90t(SOCK_DGRAM, "net.local.dgram.pcblist");
}
/*
* Cause a pending recv() call to return. Here 'fd' is the file descriptor
* identifying the other end of the socket pair. If breaking the recv()
* requires sending data, 'data' and 'len' identify the data that should be
* sent. Return 'fd' if it is still open, or -1 if it is closed.
*/
static int
break_uds_recv(int fd, const char * data, size_t len)
{
int fd2;
/*
* This UDS-specific routine makes the recv() in one of two ways
* depending on whether the recv() call already made partial progress:
* if it did, this send call creates a segment boundary which should
* cut short the current receive call. If it did not, the send call
* will simply satisfy the receive call with regular data.
*/
if ((fd2 = open("/dev/null", O_RDONLY)) < 0) e(0);
if (send_fds(fd, data, len, 0, NULL, 0, &fd2, 1) != len) e(0);
if (close(fd2) != 0) e(0);
return fd;
}
/*
* Test for receiving on stream sockets. In particular, test SO_RCVLOWAT,
* MSG_PEEK, MSG_DONTWAIT, and MSG_WAITALL.
*/
static void
test90u(void)
{
subtest = 21;
socklib_stream_recv(socketpair, AF_UNIX, SOCK_STREAM, break_uds_recv);
}
#define MAX_BYTES 2 /* set to 3 for slightly better(?) testing */
#define USLEEP_TIME 250000 /* increase on wimpy platforms if needed */
/*
* Signal handler which just needs to exist, so that invoking it will interrupt
* an ongoing system call.
*/
static void
test90_got_signal(int sig __unused)
{
/* Nothing. */
}
/*
* Test for sending on stream sockets. The quick summary here is that send()
* should basically act as the mirror of recv(MSG_WAITALL), i.e., it should
* keep suspending until all data is sent (or the call is interrupted or no
* more can possibly be sent), and, SO_SNDLOWAT, mirroring SO_RCVLOWAT, acts as
* an admission test for the send: nothing is sent until there is room in the
* send buffer (i.e., the peer's receive buffer) for at least the low send
* watermark, or the whole send request length, whichever is smaller. In
* addition, select(2) should use the same threshold.
*/
static void
sub90v(int iroom, int istate, int slowat, int len, int bits, int act)
{
const char *data = "ABC"; /* this limits MAX_BYTES to 3 */
struct sigaction sa;
struct timeval tv;
fd_set fds;
char buf[2], *sndbuf;
pid_t pid;
int fd[2], rcvlen, min, flags, res, err;
int pfd[2], eroom, tstate, fl, status;
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0);
/*
* Set up the initial condition on the sockets.
*/
rcvlen = get_rcvbuf_len(fd[1]);
if (rcvlen <= iroom) e(0);
rcvlen -= iroom;
if ((sndbuf = malloc(rcvlen)) == NULL) e(0);
memset(sndbuf, 'X', rcvlen);
if (send(fd[0], sndbuf, rcvlen, 0) != rcvlen) e(0);
free(sndbuf);
switch (istate) {
case 0: break;
case 1: if (shutdown(fd[0], SHUT_WR) != 0) e(0); break;
case 2: if (shutdown(fd[1], SHUT_RD) != 0) e(0); break;
case 3: if (close(fd[1]) != 0) e(0); break;
}
if (setsockopt(fd[0], SOL_SOCKET, SO_SNDLOWAT, &slowat,
sizeof(slowat)) != 0) e(0);
/* SO_SNDLOWAT is always bounded by the actual send length. */
min = MIN(len, slowat);
flags = MSG_NOSIGNAL;
if (bits & 1) flags |= MSG_DONTWAIT;
/*
* Do a quick select test to see if its result indeed matches whether
* the available space in the "send" buffer meets the threshold.
*/
FD_ZERO(&fds);
FD_SET(fd[0], &fds);
tv.tv_sec = 0;
tv.tv_usec = 0;
res = select(fd[0] + 1, NULL, &fds, NULL, &tv);
if (res < 0 || res > 1) e(0);
if (res != (iroom >= slowat || istate > 0)) e(0);
if (res == 1 && !FD_ISSET(fd[0], &fds)) e(0);
/*
* Cut short a whole lot of cases, to avoid the overhead of forking,
* namely when we know the call should return immediately. This is the
* case when the socket state disallows further sending, or when all
* data could be sent, or when the call was non-blocking. The low
* send watermark only helps determine whether anything was sent here.
*/
if (istate > 0 || iroom >= len || (flags & MSG_DONTWAIT)) {
res = send(fd[0], data, len, flags);
if (istate > 0) {
if (res != -1) e(0);
if (errno != EPIPE) e(0);
} else if (iroom >= len) {
if (res != len) e(0);
} else if (iroom >= min) {
if (res != iroom) e(0);
} else {
if (res != -1) e(0);
if (errno != EWOULDBLOCK) e(0);
}
/* Early cleanup and return to avoid even more code clutter. */
if (istate != 3 && close(fd[1]) != 0) e(0);
if (close(fd[0]) != 0) e(0);
return;
}
/*
* Now starts the interesting stuff: the send call should now block,
* even though if we add MSG_DONTWAIT it may not return EWOULDBLOCK,
* because MSG_DONTWAIT prevents the send from blocking after partial
* completion. As such, we can only test our expectations by letting
* the call block, in a child process, and waiting. We do test as much
* of the above assumption as we can for safety right here, but this is
* not a substitute for actually blocking even in these cases!
*/
if (iroom < min) {
if (send(fd[0], data, len, flags | MSG_DONTWAIT) != -1) e(0);
if (errno != EWOULDBLOCK) e(0);
}
/*
* If (act < 9), we receive 0, 1, or 2 bytes from the receive queue
* before forcing the send call to terminate in one of three ways.
*
* If (act == 9), we use a signal to interrupt the send call.
*/
if (act < 9) {
eroom = act % 3;
tstate = act / 3;
} else
eroom = tstate = 0;
if (pipe2(pfd, O_NONBLOCK) != 0) e(0);
pid = fork();
switch (pid) {
case 0:
errct = 0;
if (close(fd[1]) != 0) e(0);
if (close(pfd[0]) != 0) e(0);
if (act == 9) {
memset(&sa, 0, sizeof(sa));
sa.sa_handler = test90_got_signal;
if (sigaction(SIGUSR1, &sa, NULL) != 0) e(0);
}
res = send(fd[0], data, len, flags);
err = errno;
if (write(pfd[1], &res, sizeof(res)) != sizeof(res)) e(0);
if (write(pfd[1], &err, sizeof(err)) != sizeof(err)) e(0);
exit(errct);
case -1:
e(0);
}
if (close(pfd[1]) != 0) e(0);
/*
* Allow the child to enter the blocking send(2), and check the pipe
* to see if it is really blocked.
*/
if (usleep(USLEEP_TIME) != 0) e(0);
if (read(pfd[0], &res, sizeof(res)) != -1) e(0);
if (errno != EAGAIN) e(0);
if (eroom > 0) {
if (recv(fd[1], buf, eroom, 0) != eroom) e(0);
/*
* The threshold for the send is now met if the entire request
* has been satisfied.
*/
if (iroom + eroom >= len) {
if ((fl = fcntl(pfd[0], F_GETFL)) == -1) e(0);
if (fcntl(pfd[0], F_SETFL, fl & ~O_NONBLOCK) != 0)
e(0);
if (read(pfd[0], &res, sizeof(res)) != sizeof(res))
e(0);
if (read(pfd[0], &err, sizeof(err)) != sizeof(err))
e(0);
if (res != len) e(0);
/* Bail out. */
goto cleanup;
}
}
if (act < 9) {
/*
* Now test various ways to terminate the send call. Ideally
* we would also like to have a case that raises a socket error
* here, but with UDS there is currently no way to do that.
*/
switch (tstate) {
case 0: if (shutdown(fd[0], SHUT_WR) != 0) e(0); break;
case 1: if (shutdown(fd[1], SHUT_RD) != 0) e(0); break;
case 2: if (close(fd[1]) != 0) e(0); fd[1] = -1; break;
}
} else
if (kill(pid, SIGUSR1) != 0) e(0);
if ((fl = fcntl(pfd[0], F_GETFL)) == -1) e(0);
if (fcntl(pfd[0], F_SETFL, fl & ~O_NONBLOCK) != 0) e(0);
if (read(pfd[0], &res, sizeof(res)) != sizeof(res)) e(0);
if (read(pfd[0], &err, sizeof(err)) != sizeof(err)) e(0);
/*
* If the send met the threshold before being terminate or interrupted,
* we should at least have sent something. Otherwise, the send was
* never admitted and should return EPIPE (if the send was terminated)
* or EINTR (if the child was killed).
*/
if (iroom + eroom >= min) {
if (res != MIN(iroom + eroom, len)) e(0);
} else {
if (res != -1) e(0);
if (act < 9) {
if (err != EPIPE) e(0);
} else
if (err != EINTR) e(0);
}
cleanup:
if (close(pfd[0]) != 0) e(0);
if (wait(&status) != pid) e(0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0);
if (fd[1] != -1 && close(fd[1]) != 0) e(0);
if (close(fd[0]) != 0) e(0);
}
/*
* Test for sending on stream sockets. In particular, test SO_SNDLOWAT and
* MSG_DONTWAIT.
*/
static void
test90v(void)
{
int iroom, istate, slowat, len, bits, act;
subtest = 22;
/* Insanity. */
for (iroom = 0; iroom <= MAX_BYTES; iroom++)
for (istate = 0; istate <= 3; istate++)
for (slowat = 1; slowat <= MAX_BYTES; slowat++)
for (len = 1; len <= MAX_BYTES; len++)
for (bits = 0; bits < 2; bits++)
for (act = 0; act <= 9; act++)
sub90v(iroom, istate,
slowat, len, bits,
act);
}
/*
* Test that SO_RCVLOWAT is limited to the size of the receive buffer.
*/
static void
sub90w_recv(int fill_delta, int rlowat_delta, int exp_delta)
{
char *buf;
int fd[2], rcvlen, fill, rlowat, res;
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0);
rcvlen = get_rcvbuf_len(fd[0]);
if ((buf = malloc(rcvlen + 1)) == NULL) e(0);
fill = rcvlen + fill_delta;
rlowat = rcvlen + rlowat_delta;
memset(buf, 0, fill);
if (send(fd[1], buf, fill, 0) != fill) e(0);
if (setsockopt(fd[0], SOL_SOCKET, SO_RCVLOWAT, &rlowat,
sizeof(rlowat)) != 0) e(0);
res = recv(fd[0], buf, rcvlen + 1, MSG_DONTWAIT);
if (exp_delta < 0) {
if (res != -1) e(0);
if (errno != EWOULDBLOCK) e(0);
} else
if (res != rcvlen - exp_delta) e(0);
free(buf);
if (close(fd[0]) != 0) e(0);
if (close(fd[1]) != 0) e(0);
}
/*
* Test that SO_SNDLOWAT is limited to the size of the "send" buffer.
*/
static void
sub90w_send(int fill, int slowat_delta, int exp_delta)
{
char *buf;
socklen_t len;
int fd[2], sndlen, slowat, res;
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != 0) e(0);
len = sizeof(sndlen);
if (getsockopt(fd[0], SOL_SOCKET, SO_SNDBUF, &sndlen, &len) != 0) e(0);
if (len != sizeof(sndlen)) e(0);
if ((buf = malloc(sndlen + 1)) == NULL) e(0);
slowat = sndlen + slowat_delta;
if (fill > 0) {
memset(buf, 0, fill);
if (send(fd[0], buf, fill, 0) != fill) e(0);
}
if (setsockopt(fd[0], SOL_SOCKET, SO_SNDLOWAT, &slowat,
sizeof(slowat)) != 0) e(0);
res = send(fd[0], buf, sndlen + 1, MSG_DONTWAIT);
if (exp_delta < 0) {
if (res != -1) e(0);
if (errno != EWOULDBLOCK) e(0);
} else
if (res != sndlen - exp_delta) e(0);
free(buf);
if (close(fd[0]) != 0) e(0);
if (close(fd[1]) != 0) e(0);
}
/*
* Test that on stream sockets, SO_RCVLOWAT and SO_SNDLOWAT are limited to
* their respective buffer sizes.
*/
static void
test90w(void)
{
subtest = 23;
/*
* With the receive buffer filled except for one byte, all data should
* be retrieved unless the threshold is not met.
*/
sub90w_recv(-1, -1, 1);
sub90w_recv(-1, 0, -1);
sub90w_recv(-1, 1, -1);
/*
* With the receive buffer filled completely, all data should be
* retrieved in all cases.
*/
sub90w_recv(0, -1, 0);
sub90w_recv(0, 0, 0);
sub90w_recv(0, 1, 0);
/*
* With a "send" buffer that contains one byte, all data should be sent
* unless the threshold is not met.
*/
sub90w_send(1, -1, 1);
sub90w_send(1, 0, -1);
sub90w_send(1, 1, -1);
/*
* With the "send" buffer filled completely, all data should be sent
* in all cases.
*/
sub90w_send(0, -1, 0);
sub90w_send(0, 0, 0);
sub90w_send(0, 1, 0);
}
/*
* Test shutdown on listening sockets.
*/
static void
sub90x(int type, int how, int connwait)
{
struct sockaddr_un sun;
socklen_t len;
char buf[1];
int fd, fd2, fd3, val, fl;
subtest = 24;
fd = get_bound_socket(type, SOCK_PATH_A, &sun);
if (listen(fd, 5) != 0) e(0);
if (!connwait) {
if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0)
e(0);
} else {
val = 1;
if (setsockopt(fd, 0, LOCAL_CONNWAIT, &val, sizeof(val)) != 0)
e(0);
if ((fd2 = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != -1)
e(0);
if (errno != EINPROGRESS) e(0);
}
if (shutdown(fd, how) != 0) e(0);
len = sizeof(sun);
if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0);
if (write(fd2, "A", 1) != 1) e(0);
if (read(fd3, buf, 1) != 1) e(0);
if (buf[0] != 'A') e(0);
if (write(fd3, "B", 1) != 1) e(0);
if (read(fd2, buf, 1) != 1) e(0);
if (buf[0] != 'B') e(0);
len = sizeof(sun);
if (accept(fd, (struct sockaddr *)&sun, &len) != -1) e(0);
if (errno != ECONNABORTED) e(0);
/*
* Strangely, both NetBSD and Linux (yes, my two reference platforms)
* return EWOULDBLOCK from non-blocking accept(2) calls even though
* they always return ECONNABORTED when blocking. For consistency and
* select(2), we always return ECONNABORTED.
*/
if ((fl = fcntl(fd, F_GETFL)) == -1) e(0);
if (fcntl(fd, F_SETFL, fl | O_NONBLOCK) != 0) e(0);
len = sizeof(sun);
if (accept(fd, (struct sockaddr *)&sun, &len) != -1) e(0);
if (errno != ECONNABORTED) e(0);
if (fcntl(fd, F_SETFL, fl) != 0) e(0);
if (close(fd3) != 0) e(0);
if (close(fd2) != 0) e(0);
if ((fd2 = socket(AF_UNIX, type | SOCK_NONBLOCK, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != -1) e(0);
if (errno != ECONNREFUSED) e(0);
len = sizeof(sun);
if (accept(fd, (struct sockaddr *)&sun, &len) != -1) e(0);
if (errno != ECONNABORTED) e(0);
if (close(fd2) != 0) e(0);
if (close(fd) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
}
/*
* Test shutdown on listening sockets. Pending connections should still be
* acceptable (and not inherit the shutdown flags), but new connections must be
* refused, and the accept call must no longer ever block.
*/
static void
test90x(void)
{
const int types[] = { SOCK_STREAM, SOCK_SEQPACKET };
const int hows[] = { SHUT_RD, SHUT_WR, SHUT_RDWR };
unsigned int i, j, k;
for (i = 0; i < __arraycount(types); i++)
for (j = 0; j < __arraycount(hows); j++)
for (k = 0; k <= 1; k++)
sub90x(types[i], hows[j], k);
}
/*
* Test accepting connections without LOCAL_CONNWAIT for the given socket type.
*/
static void
sub90y(int type)
{
struct sockaddr_un sunA, sunB, sunC;
socklen_t len;
struct timeval tv;
fd_set fds;
char buf[7];
uid_t uid;
gid_t gid;
int fd, fd2, fd3, fd4, val;
fd = get_bound_socket(type | SOCK_NONBLOCK, SOCK_PATH_A, &sunA);
len = sizeof(val);
if (getsockopt(fd, 0, LOCAL_CONNWAIT, &val, &len) != 0) e(0);
if (len != sizeof(val)) e(0);
if (val != 0) e(0);
if (listen(fd, 5) != 0) e(0);
/*
* Any socket options should be inherited from the listening socket at
* connect time, and not be re-inherited at accept time. It does not
* really matter what socket option we set here, as long as it is
* supposed to be inherited.
*/
val = 123;
if (setsockopt(fd, SOL_SOCKET, SO_SNDLOWAT, &val, sizeof(val)) != 0)
e(0);
fd2 = get_bound_socket(type, SOCK_PATH_B, &sunB);
if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
val = 456;
if (setsockopt(fd, SOL_SOCKET, SO_SNDLOWAT, &val, sizeof(val)) != 0)
e(0);
/*
* Obtaining the peer name should work. As always, the name should be
* inherited from the listening socket.
*/
len = sizeof(sunC);
if (getpeername(fd2, (struct sockaddr *)&sunC, &len) != 0) e(0);
check_addr(&sunC, len, SOCK_PATH_A);
/*
* Obtaining peer credentials should work. This is why NetBSD obtains
* the peer credentials at bind time, not at accept time.
*/
if (getpeereid(fd2, &uid, &gid) != 0) e(0);
if (uid != geteuid()) e(0);
if (gid != getegid()) e(0);
/*
* Sending to the socket should work, and it should be possible to
* receive the data from the other side once accepted.
*/
if (send(fd2, "Hello, ", 7, 0) != 7) e(0);
if (send(fd2, "world!", 6, 0) != 6) e(0);
/* Shutdown settings should be visible after accepting, too. */
if (shutdown(fd2, SHUT_RDWR) != 0) e(0);
len = sizeof(sunB);
if ((fd3 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) e(0);
check_addr(&sunB, len, SOCK_PATH_B);
len = sizeof(val);
if (getsockopt(fd3, SOL_SOCKET, SO_SNDLOWAT, &val, &len) != 0) e(0);
if (len != sizeof(val)) e(0);
if (val != 123) e(0);
if (recv(fd3, buf, 7, 0) != 7) e(0);
if (memcmp(buf, "Hello, ", 7) != 0) e(0);
if (recv(fd3, buf, 7, 0) != 6) e(0);
if (memcmp(buf, "world!", 6) != 0) e(0);
if (recv(fd3, buf, sizeof(buf), 0) != 0) e(0);
if (send(fd3, "X", 1, MSG_NOSIGNAL) != -1) e(0);
if (errno != EPIPE) e(0);
if (close(fd2) != 0) e(0);
if (close(fd3) != 0) e(0);
if (unlink(SOCK_PATH_B) != 0) e(0);
/*
* If the socket pending acceptance is closed, the listening socket
* should pretend as though the connection was never there.
*/
if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
FD_ZERO(&fds);
FD_SET(fd, &fds);
tv.tv_sec = 0;
tv.tv_usec = 0;
if (select(fd + 1, &fds, NULL, NULL, &tv) != 1) e(0);
if (!FD_ISSET(fd, &fds)) e(0);
if (close(fd2) != 0) e(0);
if (select(fd + 1, &fds, NULL, NULL, &tv) != 0) e(0);
if (FD_ISSET(fd, &fds)) e(0);
len = sizeof(sunB);
if (accept(fd, (struct sockaddr *)&sunB, &len) != -1) e(0);
if (errno != EWOULDBLOCK) e(0);
/*
* Try the same thing, but now with the connection sandwiched between
* two different pending connections, which should be left intact.
*/
if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (send(fd2, "A", 1, 0) != 1) e(0);
if ((fd3 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd3, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (send(fd3, "B", 1, 0) != 1) e(0);
if ((fd4 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd4, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (send(fd4, "C", 1, 0) != 1) e(0);
if (close(fd3) != 0) e(0);
len = sizeof(sunB);
if ((fd3 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) e(0);
if (recv(fd3, buf, sizeof(buf), 0) != 1) e(0);
if (buf[0] != 'A') e(0);
if (close(fd3) != 0) e(0);
if (close(fd2) != 0) e(0);
FD_ZERO(&fds);
FD_SET(fd, &fds);
tv.tv_sec = 0;
tv.tv_usec = 0;
if (select(fd + 1, &fds, NULL, NULL, &tv) != 1) e(0);
if (!FD_ISSET(fd, &fds)) e(0);
len = sizeof(sunB);
if ((fd3 = accept(fd, (struct sockaddr *)&sunB, &len)) < 0) e(0);
if (recv(fd3, buf, sizeof(buf), 0) != 1) e(0);
if (buf[0] != 'C') e(0);
if (close(fd3) != 0) e(0);
if (close(fd4) != 0) e(0);
if (select(fd + 1, &fds, NULL, NULL, &tv) != 0) e(0);
if (FD_ISSET(fd, &fds)) e(0);
len = sizeof(sunB);
if (accept(fd, (struct sockaddr *)&sunB, &len) != -1) e(0);
if (errno != EWOULDBLOCK) e(0);
/*
* If the listening socket is closed, the socket pending acceptance
* should be reset. We actually rely on this behavior in the sweep
* test, but we test this with more than one socket this time.
*/
if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if ((fd3 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd3, (struct sockaddr *)&sunA, sizeof(sunA)) != 0) e(0);
if (close(fd) != 0) e(0);
if (recv(fd2, buf, sizeof(buf), 0) != -1) e(0);
if (errno != ECONNRESET) e(0);
if (recv(fd2, buf, sizeof(buf), 0) != 0) e(0);
if (recv(fd3, buf, sizeof(buf), 0) != -1) e(0);
if (errno != ECONNRESET) e(0);
if (recv(fd3, buf, sizeof(buf), 0) != 0) e(0);
if (close(fd3) != 0) e(0);
if (close(fd2) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
}
/*
* Test accepting connections without LOCAL_CONNWAIT. Since both the old UDS
* service and the initial version of the new UDS service supported only the
* LOCAL_CONNWAIT behavior, the alternative (which is now the default, as it is
* on other platforms) has been a bit under-tested so far.
*/
static void
test90y(void)
{
subtest = 25;
sub90y(SOCK_STREAM);
sub90y(SOCK_SEQPACKET);
}
/*
* Test that SO_LINGER has no effect on sockets of the given type.
*/
static void
sub90z(int type)
{
struct sockaddr_un sun;
socklen_t len;
struct linger l;
char buf[1];
int fd, fd2, fd3;
fd = get_bound_socket(type, SOCK_PATH_A, &sun);
if (listen(fd, 1) != 0) e(0);
if ((fd2 = socket(AF_UNIX, type, 0)) < 0) e(0);
if (connect(fd2, (struct sockaddr *)&sun, sizeof(sun)) != 0) e(0);
len = sizeof(sun);
if ((fd3 = accept(fd, (struct sockaddr *)&sun, &len)) < 0) e(0);
if (close(fd) != 0) e(0);
if (send(fd2, "A", 1, 0) != 1) e(0);
l.l_onoff = 1;
l.l_linger = 0;
if (setsockopt(fd2, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) != 0) e(0);
if (close(fd2) != 0) e(0);
if (recv(fd3, buf, sizeof(buf), 0) != 1) e(0);
if (buf[0] != 'A') e(0);
/* We should not get ECONNRESET now. */
if (recv(fd3, buf, sizeof(buf), 0) != 0) e(0);
if (close(fd3) != 0) e(0);
if (unlink(SOCK_PATH_A) != 0) e(0);
}
/*
* Test that SO_LINGER has no effect on UNIX domain sockets. In particular, a
* timeout of zero does not cause the connection to be reset forcefully.
*/
static void
test90z(void)
{
subtest = 26;
sub90z(SOCK_STREAM);
sub90z(SOCK_SEQPACKET);
}
/*
* Test program for UDS.
*/
int
main(int argc, char ** argv)
{
int i, m;
start(90);
if (argc == 2)
m = atoi(argv[1]);
else
m = 0xFFFFFFF;
for (i = 0; i < ITERATIONS; i++) {
if (m & 0x0000001) test90a();
if (m & 0x0000002) test90b();
if (m & 0x0000004) test90c();
if (m & 0x0000008) test90d();
if (m & 0x0000010) test90e();
if (m & 0x0000020) test90f();
if (m & 0x0000040) test90g();
if (m & 0x0000080) test90h();
if (m & 0x0000100) test90i();
if (m & 0x0000200) test90j();
if (m & 0x0000400) test90k();
if (m & 0x0000800) test90l();
if (m & 0x0001000) test90m();
if (m & 0x0002000) test90n();
if (m & 0x0004000) test90o();
if (m & 0x0008000) test90p();
if (m & 0x0010000) test90q();
if (m & 0x0020000) test90r();
if (m & 0x0040000) test90s();
if (m & 0x0080000) test90t();
if (m & 0x0100000) test90u();
if (m & 0x0200000) test90v();
if (m & 0x0400000) test90w();
if (m & 0x0800000) test90x();
if (m & 0x1000000) test90y();
if (m & 0x2000000) test90z();
}
quit();
/* NOTREACHED */
}
Reference in New Issue View Git Blame Copy Permalink