/*

* Socket test code library. This file contains code that is worth sharing

* between TCP/IP and UDS tests, as well as code that is worth sharing between

* various TCP/IP tests.

*/

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <signal.h>

#include <sys/param.h>

#include <sys/wait.h>

#include <sys/socket.h>

#include <sys/ioctl.h>

#include <sys/sysctl.h>

#include <net/if.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <netinet6/in6_var.h>

#include <arpa/inet.h>

#include <ifaddrs.h>

#include <unistd.h>

#include <fcntl.h>

#include "common.h"

#include "socklib.h"

#define TEST_PORT_A 12345 /* this port should be free and usable */

#define TEST_PORT_B 12346 /* this port should be free and usable */

#define LOOPBACK_IFNAME "lo0" /* loopback interface name */

#define LOOPBACK_IPV4 "127.0.0.1" /* IPv4 address */

#define LOOPBACK_IPV6_LL "fe80::1" /* link-local IPv6 address */

/* These address should simply eat all packets. */

#define TEST_BLACKHOLE_IPV4 "127.255.0.254"

#define TEST_BLACKHOLE_IPV6 "::2"

#define TEST_BLACKHOLE_IPV6_LL "fe80::ffff"

/* Addresses for multicast-related testing. */

#define TEST_MULTICAST_IPV4 "233.252.0.1" /* RFC 5771 Sec. 9.2 */

#define TEST_MULTICAST_IPV6 "ff0e::db8:0:1" /* RFC 6676 Sec. 3 */

#define TEST_MULTICAST_IPV6_LL "ff02::db8:0:1"

#define TEST_MULTICAST_IPV6_BAD "ff00::db8:0:1"

#define BAD_IFINDEX 255 /* guaranteed not to belong to an interface */

/* 0 = check, 1 = generate source, 2 = generate CSV */

#define SOCKLIB_SWEEP_GENERATE 0

#if SOCKLIB_SWEEP_GENERATE

/* Link against minix/usr.bin/trace/error.o to make this work! */

const char *get_error_name(int err);

#if SOCKLIB_SWEEP_GENERATE == 2

static const char *statename[S_MAX] = {

"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_C_SHUT_R",

"S_C_SHUT_W",

"S_C_SHUT_RW",

"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_PRE_RESET",

"S_AT_RESET",

"S_POST_RESET",

"S_FAILED",

"S_POST_FAILED",

};

#endif

static const char *callname[C_MAX] = {

"C_ACCEPT",

"C_BIND",

"C_CONNECT",

"C_GETPEERNAME",

"C_GETSOCKNAME",

"C_GETSOCKOPT_ERR",

"C_GETSOCKOPT_KA",

"C_GETSOCKOPT_RB",

"C_IOCTL_NREAD",

"C_LISTEN",

"C_RECV",

"C_RECVFROM",

"C_SEND",

"C_SENDTO",

"C_SELECT_R",

"C_SELECT_W",

"C_SELECT_X",

"C_SETSOCKOPT_BC",

"C_SETSOCKOPT_KA",

"C_SETSOCKOPT_L",

"C_SETSOCKOPT_RA",

"C_SHUTDOWN_R",

"C_SHUTDOWN_RW",

"C_SHUTDOWN_W",

};

#endif

static int socklib_sigpipe;

/*

* Signal handler for SIGPIPE signals.

*/

static void

socklib_signal(int sig)

{

if (sig != SIGPIPE) e(0);

socklib_sigpipe++;

}

/*

* The given socket file descriptor 'fd' has been set up in the desired state.

* Perform the given call 'call' on it, possibly using local socket address

* 'local_addr' (for binding) or remote socket address 'remote_addr' (for

* connecting or to store resulting addresses), both of size 'addr_len'.

* Return the result of the call, using a positive value if the call succeeded,

* or a negated errno code if the call failed.

*/

int

socklib_sweep_call(enum call call, int fd, struct sockaddr * local_addr,

struct sockaddr * remote_addr, socklen_t addr_len)

{

char data[1];

struct linger l;

fd_set fd_set;

struct timeval tv;

socklen_t len;

int i, r, fd2;

fd2 = -1;

switch (call) {

case C_ACCEPT:

r = accept(fd, remote_addr, &addr_len);

if (r >= 0)

fd2 = r;

break;

case C_BIND:

r = bind(fd, local_addr, addr_len);

break;

case C_CONNECT:

r = connect(fd, remote_addr, addr_len);

break;

case C_GETPEERNAME:

r = getpeername(fd, remote_addr, &addr_len);

break;

case C_GETSOCKNAME:

r = getsockname(fd, remote_addr, &addr_len);

break;

case C_GETSOCKOPT_ERR:

len = sizeof(i);

r = getsockopt(fd, SOL_SOCKET, SO_ERROR, &i, &len);

/*

* We assume this call always succeeds, and test against the

* pending error.

*/

if (r != 0) e(0);

if (i != 0) {

r = -1;

errno = i;

}

break;

case C_GETSOCKOPT_KA:

len = sizeof(i);

r = getsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &i, &len);

break;

case C_GETSOCKOPT_RB:

len = sizeof(i);

r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &i, &len);

break;

case C_IOCTL_NREAD:

r = ioctl(fd, FIONREAD, &i);

/* On success, we test against the returned value here. */

if (r == 0)

r = i;

break;

case C_LISTEN:

r = listen(fd, 1);

break;

case C_RECV:

r = recv(fd, data, sizeof(data), 0);

break;

case C_RECVFROM:

r = recvfrom(fd, data, sizeof(data), 0, remote_addr,

&addr_len);

break;

case C_SEND:

data[0] = 0;

r = send(fd, data, sizeof(data), 0);

break;

case C_SENDTO:

data[0] = 0;

r = sendto(fd, data, sizeof(data), 0, remote_addr, addr_len);

break;

case C_SETSOCKOPT_BC:

i = 0;

r = setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &i, sizeof(i));

break;

case C_SETSOCKOPT_KA:

i = 1;

r = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &i, sizeof(i));

break;

case C_SETSOCKOPT_L:

l.l_onoff = 1;

l.l_linger = 0;

r = setsockopt(fd, SOL_SOCKET, SO_LINGER, &l, sizeof(l));

break;

case C_SETSOCKOPT_RA:

i = 1;

r = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));

break;

case C_SELECT_R:

case C_SELECT_W:

case C_SELECT_X:

FD_ZERO(&fd_set);

FD_SET(fd, &fd_set);

tv.tv_sec = 0;

tv.tv_usec = 0;

r = select(fd + 1, (call == C_SELECT_R) ? &fd_set : NULL,

(call == C_SELECT_W) ? &fd_set : NULL,

(call == C_SELECT_X) ? &fd_set : NULL, &tv);

break;

case C_SHUTDOWN_R:

r = shutdown(fd, SHUT_RD);

break;

case C_SHUTDOWN_W:

r = shutdown(fd, SHUT_WR);

break;

case C_SHUTDOWN_RW:

r = shutdown(fd, SHUT_RDWR);

break;

default:

r = -1;

errno = EINVAL;

e(0);

}

if (r < -1) e(0);

if (r == -1)

r = -errno;

if (fd2 >= 0 && close(fd2) != 0) e(0);

return r;

}

/*

* Perform a sweep of socket calls vs socket states, testing the outcomes

* against provided tables or (if SOCKLIB_SWEEP_GENERATE is set) reporting on

* the outcomes instead. The caller must provide the following:

*

* - the socket domain, type, and protocol to test; these are simply forwarded

* to the callback function (see below);

* - the set of S_ states to test, as array 'states' with 'nstates' elements;

* - unless generating output, a matrix of expected results as 'results', which

* is actually a two-dimensional array with dimensions [C_MAX][nstates], with

* either positive call output or a negated call errno code in each cell;

* - a callback function 'proc' that must set up a socket in the given state

* and pass it to socklib_sweep_call().

*

* The 'states' array allows each socket sweep test to support a different set

* of states, because not every type of socket can be put in every possible

* state. All calls are always tried in each state, though.

*

* The sweep also tests for SIGPIPE generation, which assumes that all calls on

* SOCK_STREAM sockets that return EPIPE, also raise a SIGPIPE signal, and that

* no other SIGPIPE signal is ever raised otherwise.

*

* Standard e() error throwing is used for set-up and result mismatches.

*/

void

socklib_sweep(int domain, int type, int protocol, const enum state * states,

unsigned int nstates, const int * results, int (* proc)(int domain,

int type, int protocol, enum state, enum call))

{

struct sigaction act, oact;

enum state state;

enum call call;

#if SOCKLIB_SWEEP_GENERATE

const char *name;

int res, *nresults;

#else

int res, exp;

#endif

memset(&act, 0, sizeof(act));

act.sa_handler = socklib_signal;

if (sigaction(SIGPIPE, &act, &oact) != 0) e(0);

#if SOCKLIB_SWEEP_GENERATE

if ((nresults = malloc(nstates * C_MAX)) == NULL) e(0);

#endif

for (state = 0; state < nstates; state++) {

for (call = 0; call < C_MAX; call++) {

socklib_sigpipe = 0;

res = proc(domain, type, protocol, states[state],

call);

/*

* If the result was EPIPE and this is a stream-type

* socket, we must have received exactly one SIGPIPE

* signal. Otherwise, we must not have received one.

* Note that technically, the SIGPIPE could arrive

* sometime after this check, but with regular system

* service scheduling that will never happen.

*/

if (socklib_sigpipe !=

(res == -EPIPE && type == SOCK_STREAM)) e(0);

#if SOCKLIB_SWEEP_GENERATE

nresults[call * nstates + state] = res;

#else

exp = results[call * nstates + state];

if (res != exp) {

printf("FAIL state %d call %d res %d exp %d\n",

state, call, res, exp);

e(0);

}

#endif

}

}

if (sigaction(SIGPIPE, &oact, NULL) != 0) e(0);

#if SOCKLIB_SWEEP_GENERATE

#if SOCKLIB_SWEEP_GENERATE == 1

/*

* Generate a table in C form, ready to be pasted into test source.

* Obviously, generated results should be hand-checked carefully before

* being pasted into a test. Arguably these tables should be hand-made

* for maximum scrutiny, but I already checked the results from the

* CSV form (#define SOCKLIB_SWEEP_GENERATE 2) and have no desire for

* RSI -dcvmoole

*/

printf("\nstatic const int X_results[][__arraycount(X_states)] = {\n");

for (call = 0; call < C_MAX; call++) {

if ((name = callname[call]) == NULL) e(0);

printf("\t[%s]%s%s%s= {", name,

(strlen(name) <= 21) ? "\t" : "",

(strlen(name) <= 13) ? "\t" : "",

(strlen(name) <= 5) ? "\t" : "");

for (state = 0; state < nstates; state++) {

if (state % 4 == 0)

printf("\n\t\t");

res = nresults[call * nstates + state];

name = (res < 0) ? get_error_name(-res) : NULL;

if (name != NULL) {

printf("-%s,", name);

if ((state + 1) % 4 != 0 &&

state < nstates - 1)

printf("%s%s",

(strlen(name) <= 13) ? "\t" : "",

(strlen(name) <= 5) ? "\t" : "");

} else {

printf("%d,", res);

if ((state + 1) % 4 != 0 &&

state < nstates - 1)

printf("\t\t");

}

}

printf("\n\t},\n");

}

printf("};\n");

#elif SOCKLIB_SWEEP_GENERATE == 2

/* Generate table in CSV form. */

printf("\n");

for (state = 0; state < nstates; state++)

printf(",%s", statename[states[state]] + 2);

for (call = 0; call < C_MAX; call++) {

printf("\n%s", callname[call] + 2);

for (state = 0; state < nstates; state++) {

res = nresults[call * nstates + state];

name = (res < 0) ? get_error_name(-res) : NULL;

if (name != NULL)

printf(",%s", name);

else

printf(",%d", res);

}

}

printf("\n");

#endif

free(nresults);

#endif

}

/*

* Test for setting and retrieving UDP/RAW multicast transmission options.

* This is an interface-level test only: we do not (yet) test whether the

* options have any effect. The given 'type' must be SOCK_DGRAM or SOCK_RAW.

*/

void

socklib_multicast_tx_options(int type)

{

struct in_addr in_addr;

socklen_t len;

unsigned int ifindex;

uint8_t byte;

int fd, val;

subtest = 10;

if ((fd = socket(AF_INET, type, 0)) < 0) e(0);

/*

* Initially, the multicast TTL is expected be 1, looping should be

* enabled, and the multicast source address should be <any>.

*/

byte = 0;

len = sizeof(byte);

if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &byte, &len) != 0)

e(0);

if (len != sizeof(byte)) e(0);

if (type != SOCK_STREAM && byte != 1) e(0);

byte = 0;

len = sizeof(byte);

if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &byte, &len) != 0)

e(0);

if (len != sizeof(byte)) e(0);

if (byte != 1) e(0);

len = sizeof(in_addr);

if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &in_addr, &len) != 0)

e(0);

if (len != sizeof(in_addr)) e(0);

if (in_addr.s_addr != htonl(INADDR_ANY)) e(0);

/* It must not be possible to get/set IPv6 options on IPv4 sockets. */

val = 0;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val,

sizeof(val)) != -1) e(0);

if (errno != ENOPROTOOPT) e(0);

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val,

sizeof(val)) != -1) e(0);

if (errno != ENOPROTOOPT) e(0);

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val,

sizeof(val) /*wrong but it doesn't matter*/) != -1) e(0);

if (errno != ENOPROTOOPT) e(0);

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val,

&len) != -1) e(0);

if (errno != ENOPROTOOPT) e(0);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val,

&len) != -1) e(0);

if (errno != ENOPROTOOPT) e(0);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val, &len) != -1)

e(0);

if (errno != ENOPROTOOPT) e(0);

if (close(fd) != 0) e(0);

if ((fd = socket(AF_INET6, type, 0)) < 0) e(0);

/*

* Expect the same defaults as for IPv4. IPV6_MULTICAST_IF uses an

* interface index rather than an IP address, though.

*/

val = 0;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (type != SOCK_STREAM && val != 1) e(0);

val = 0;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != 1) e(0);

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != 0) e(0);

/* It must not be possible to get/set IPv4 options on IPv6 sockets. */

byte = 0;

if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &byte,

sizeof(byte)) != -1) e(0);

if (errno != ENOPROTOOPT) e(0);

if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &byte,

sizeof(byte)) != -1) e(0);

if (errno != ENOPROTOOPT) e(0);

if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &byte,

sizeof(byte) /* wrong but it doesn't matter */) != -1) e(0);

if (errno != ENOPROTOOPT) e(0);

len = sizeof(byte);

if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &val, &len) != -1)

e(0);

if (errno != ENOPROTOOPT) e(0);

if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &val, &len) != -1)

e(0);

if (errno != ENOPROTOOPT) e(0);

if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &val, &len) != -1)

e(0);

if (errno != ENOPROTOOPT) e(0);

if (close(fd) != 0) e(0);

/* Test changing options. */

if ((fd = socket(AF_INET, type, 0)) < 0) e(0);

byte = 129;

if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &byte,

sizeof(byte)) != 0) e(0);

byte = 0;

len = sizeof(byte);

if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &byte, &len) != 0)

e(0);

if (len != sizeof(byte)) e(0);

if (byte != 129) e(0);

byte = 0;

if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &byte,

sizeof(byte)) != 0)

e(0);

byte = 1;

len = sizeof(byte);

if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &byte, &len) != 0)

e(0);

if (len != sizeof(byte)) e(0);

if (byte != 0) e(0);

in_addr.s_addr = htonl(INADDR_LOOPBACK);

if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &in_addr,

sizeof(in_addr)) != 0)

e(0);

in_addr.s_addr = htonl(INADDR_ANY);

len = sizeof(in_addr);

if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &in_addr, &len) != 0)

e(0);

if (len != sizeof(in_addr)) e(0);

if (in_addr.s_addr != htonl(INADDR_LOOPBACK)) e(0);

if (close(fd) != 0) e(0);

if ((fd = socket(AF_INET6, type, 0)) < 0) e(0);

val = 137;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val,

sizeof(val)) != 0) e(0);

val = 0;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != 137) e(0);

val = -2;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val,

sizeof(val)) != -1) e(0);

if (errno != EINVAL) e(0);

val = 256;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val,

sizeof(val)) != -1) e(0);

if (errno != EINVAL) e(0);

val = 0;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != 137) e(0);

val = -1; /* use default */

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val,

sizeof(val)) != 0) e(0);

val = 0;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != 1) e(0);

val = 0;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val,

sizeof(val)) != 0) e(0);

val = 1;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != 0) e(0);

val = 1;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val,

sizeof(val)) != 0) e(0);

val = -1;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val,

sizeof(val)) != -1) e(0);

if (errno != EINVAL) e(0);

val = 2;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val,

sizeof(val)) != -1) e(0);

if (errno != EINVAL) e(0);

val = 0;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != 1) e(0);

val = -1;

ifindex = if_nametoindex(LOOPBACK_IFNAME);

val = ifindex;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val,

sizeof(val)) != 0) e(0);

val = 0;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != ifindex) e(0);

val = BAD_IFINDEX;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val,

sizeof(val)) != -1) e(0);

val = -1;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val,

sizeof(val)) != -1) e(0);

val = 0;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != ifindex) e(0);

val = 0;

if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val,

sizeof(val)) != 0) e(0);

val = ifindex;

len = sizeof(val);

if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &val, &len) != 0)

e(0);

if (len != sizeof(val)) e(0);

if (val != 0) e(0);

if (close(fd) != 0) e(0);

}

/*

* Test for large sends and receives on stream sockets with MSG_WAITALL.

*/

void

socklib_large_transfers(int fd[2])

{

char *buf;

pid_t pid;

int i, status;

#define LARGE_BUF (4096*1024)

if ((buf = malloc(LARGE_BUF)) == NULL) e(0);

memset(buf, 0, LARGE_BUF);

pid = fork();

switch (pid) {

case 0:

errct = 0;

if (close(fd[0]) != 0) e(0);

/* Part 1. */

if (recv(fd[1], buf, LARGE_BUF, MSG_WAITALL) != LARGE_BUF)

e(0);

for (i = 0; i < LARGE_BUF; i++)

if (buf[i] != (char)(i + (i >> 16))) e(0);

if (recv(fd[1], buf, LARGE_BUF,

MSG_DONTWAIT | MSG_WAITALL) != -1) e(0);

if (errno != EWOULDBLOCK) e(0);

/* Part 2. */

if (send(fd[1], buf, LARGE_BUF / 2, 0) != LARGE_BUF / 2) e(0);

if (shutdown(fd[1], SHUT_WR) != 0) e(0);

/* Part 3. */

memset(buf, 'y', LARGE_BUF);

if (recv(fd[1], buf, LARGE_BUF, MSG_WAITALL) != LARGE_BUF - 1)

e(0);

for (i = 0; i < LARGE_BUF - 1; i++)

if (buf[i] != (char)(i + (i >> 16))) e(0);

if (buf[LARGE_BUF - 1] != 'y') e(0);

if (recv(fd[1], buf, LARGE_BUF, MSG_WAITALL) != 0) e(0);

exit(errct);

case -1:

e(0);

}

if (close(fd[1]) != 0) e(0);

/* Part 1: check that a large send fully arrives. */

for (i = 0; i < LARGE_BUF; i++)

buf[i] = (char)(i + (i >> 16));

if (send(fd[0], buf, LARGE_BUF, 0) != LARGE_BUF) e(0);

/* Part 2: check that remote shutdown terminates a partial receive. */

memset(buf, 'x', LARGE_BUF);

if (recv(fd[0], buf, LARGE_BUF, MSG_WAITALL) != LARGE_BUF / 2) e(0);

for (i = 0; i < LARGE_BUF / 2; i++)

if (buf[i] != (char)(i + (i >> 16))) e(0);

for (; i < LARGE_BUF; i++)

if (buf[i] != 'x') e(0);

if (recv(fd[0], buf, LARGE_BUF, MSG_WAITALL) != 0) e(0);

/* Part 3: check that remote close terminates a partial receive. */

for (i = 0; i < LARGE_BUF; i++)

buf[i] = (char)(i + (i >> 16));

if (send(fd[0], buf, LARGE_BUF - 1, 0) != LARGE_BUF - 1) e(0);

if (close(fd[0]) != 0) e(0);

if (waitpid(pid, &status, 0) != pid) e(0);

if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) e(0);

free(buf);

}

#define PRINT_STATS 0

/*

* A randomized producer-consumer test for stream sockets. As part of this,

* we also perform very basic bulk functionality tests of FIONREAD, MSG_PEEK,

* MSG_DONTWAIT, and MSG_WAITALL.

*/

void

socklib_producer_consumer(int fd[2])

{

char *buf;

time_t t;

socklen_t len, size, off;

ssize_t r;

pid_t pid;

int i, rcvlen, status, exp, flags, num, stat[3] = { 0, 0, 0 };

len = sizeof(rcvlen);

if (getsockopt(fd[0], SOL_SOCKET, SO_RCVBUF, &rcvlen, &len) != 0) e(0);

if (len != sizeof(rcvlen)) e(0);

size = rcvlen * 3;

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, the use of MSG_PEEK, and

* the fact that without MSG_WAITALL a receive call may return any

* partial result, all contribute to the expectation that the consumer

* side will fall behind the producer. In order to test both filling

* and draining the receive queue, we use a somewhat larger small

* receive size for the consumer size (up to 256 bytes rather than 64)

* during each half of the four phases. The effectiveness of these

* numbers can be verified with statistics (disabled by default).

*/

#define TRANSFER_SIZE (16 * 1024 * 1024)

pid = fork();

switch (pid) {

case 0:

errct = 0;

if (close(fd[0]) != 0) e(0);

srand48(t + 1);

for (off = 0; off < TRANSFER_SIZE; ) {

if (off < TRANSFER_SIZE / 2)

len = lrand48() %

((off / (TRANSFER_SIZE / 8) % 2) ? 64 :

256);

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 a lower bound.

*/

if (ioctl(fd[1], FIONREAD, &exp) != 0) e(0);

if (exp < 0 || exp > rcvlen) e(0);

} else

exp = -1;

stat[0]++;

if ((r = recv(fd[1], buf, len, flags)) == -1) {

if (errno != EWOULDBLOCK) e(0);

if (exp > 0) e(0);

stat[2]++;

continue;

}

if (r < len) {

stat[1]++;

if (exp > r) e(0);

}

for (i = 0; i < r; i++)

if (buf[i] != (char)((off + i) +

((off + i) >> 16))) e(0);

if (!(flags & MSG_PEEK)) {

off += r;

if ((flags & (MSG_DONTWAIT | MSG_WAITALL)) ==

MSG_WAITALL && r != len &&

off < TRANSFER_SIZE) e(0);

}

}

#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 short %d again %d\n",

stat[0], stat[1], stat[2]);

#endif

if (close(fd[1]) != 0) e(0);

exit(errct);

case -1:

e(0);

}

if (close(fd[1]) != 0) e(0);

srand48(t);

for (off = 0; off < TRANSFER_SIZE; ) {

if (off < TRANSFER_SIZE / 4 ||

(off >= TRANSFER_SIZE / 2 && off < TRANSFER_SIZE * 3 / 4))

len = lrand48() % 64;

else

len = lrand48() % size;

if (len > TRANSFER_SIZE - off)

len = TRANSFER_SIZE - off;

for (i = 0; i < len; i++)

buf[i] = (off + i) + ((off + i) >> 16);

flags = (lrand48() % 2) ? MSG_DONTWAIT : 0;

stat[0]++;

r = send(fd[0], buf, len, flags);

if (r != len) {

if (r > (ssize_t)len) e(0);

if (!(flags & MSG_DONTWAIT)) e(0);

if (r == -1) {

if (errno != EWOULDBLOCK) e(0);

r = 0;

stat[2]++;

} else

stat[1]++;

}

if (off / (TRANSFER_SIZE / 4) !=

(off + r) / (TRANSFER_SIZE / 4))

sleep(1);

off += r;