spiped 0.0.0

data/ext/spiped/spiped-source/libcperciva/util/entropy.h

@@ -0,0 +1,13 @@
+#ifndef _ENTROPY_H_
+#define _ENTROPY_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * entropy_read(buf, buflen):
+ * Fill the given buffer with random bytes provided by the operating system.
+ */
+int entropy_read(uint8_t *, size_t);
+
+#endif /* !_ENTROPY_H_ */

data/ext/spiped/spiped-source/libcperciva/util/imalloc.h

@@ -0,0 +1,33 @@
+#ifndef _IMALLOC_H_
+#define _IMALLOC_H_
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * imalloc(nrec, reclen):
+ * Allocate ${nrec} records of length ${reclen}.  Check for size_t overflow.
+ */
+static inline void *
+imalloc(size_t nrec, size_t reclen)
+{
+
+	if (nrec > SIZE_MAX / reclen) {
+		errno = ENOMEM;
+		return (NULL);
+	} else {
+		return (malloc(nrec * reclen));
+	}
+}
+
+/**
+ * IMALLOC(p, nrec, type):
+ * Allocate ${nrec} records of type ${type} and store the pointer in ${p}.
+ * Return non-zero on failure.
+ */
+#define IMALLOC(p, nrec, type)						\
+	((((p) = (type *)imalloc((nrec), sizeof(type))) == NULL) &&	\
+	    ((nrec) > 0))
+
+#endif /* !_IMALLOC_H_ */

data/ext/spiped/spiped-source/libcperciva/util/insecure_memzero.c

@@ -0,0 +1,19 @@
+#include <stddef.h>
+#include <stdint.h>
+
+#include "insecure_memzero.h"
+
+/* Fucntion which does the zeroing. */
+static void
+insecure_memzero_func(volatile void * buf, size_t len)
+{
+	volatile uint8_t * _buf = buf;
+	size_t i;
+
+	for (i = 0; i < len; i++)
+		_buf[i] = 0;
+}
+
+/* Pointer to memory-zeroing function. */
+void (* volatile insecure_memzero_ptr)(volatile void *, size_t) =
+    insecure_memzero_func;

data/ext/spiped/spiped-source/libcperciva/util/insecure_memzero.h

@@ -0,0 +1,33 @@
+#ifndef _INSECURE_MEMZERO_H_
+#define _INSECURE_MEMZERO_H_
+
+#include <stddef.h>
+
+/* Pointer to memory-zeroing function. */
+extern void (* volatile insecure_memzero_ptr)(volatile void *, size_t);
+
+/**
+ * insecure_memzero(buf, len):
+ * Attempt to zero ${len} bytes at ${buf} in spite of optimizing compilers'
+ * best (standards-compliant) attempts to remove the buffer-zeroing.  In
+ * particular, to avoid performing the zeroing, a compiler would need to
+ * use optimistic devirtualization; recognize that non-volatile objects do not
+ * need to be treated as volatile, even if they are accessed via volatile
+ * qualified pointers; and perform link-time optimization; in addition to the
+ * dead-code elimination which often causes buffer-zeroing to be elided.
+ *
+ * Note however that zeroing a buffer does nto guarantee that the data held
+ * in the buffer is not stored elsewhere; in particular, there may be copies
+ * held in CPU registers or in anonymous allocations on the stack, even if
+ * every named variable is successfully sanitized.  Solving the "wipe data
+ * from the system" problem will require a C language extension which does not
+ * yet exist.
+ */
+static inline void
+insecure_memzero(volatile void * buf, size_t len)
+{
+
+	(insecure_memzero_ptr)(buf, len);
+}
+
+#endif /* !_INSECURE_MEMZERO_H_ */

data/ext/spiped/spiped-source/libcperciva/util/monoclock.c

@@ -0,0 +1,52 @@
+#include <sys/time.h>
+
+#include <time.h>
+
+#include "warnp.h"
+
+#include "monoclock.h"
+
+/**
+ * monoclock_get(tv):
+ * Store the current time in ${tv}.  If CLOCK_MONOTONIC is available, use
+ * that clock; if CLOCK_MONOTONIC is unavailable, use CLOCK_REALTIME (if
+ * available) or gettimeofday(2).
+ */
+int
+monoclock_get(struct timeval * tv)
+{
+#if defined(CLOCK_MONOTONIC) || !defined(POSIXFAIL_CLOCK_REALTIME)
+	struct timespec tp;
+#endif
+
+#ifdef CLOCK_MONOTONIC
+	if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0) {
+		tv->tv_sec = tp.tv_sec;
+		tv->tv_usec = tp.tv_nsec / 1000;
+	} else if ((errno != ENOSYS) && (errno != EINVAL)) {
+		warnp("clock_gettime(CLOCK_MONOTONIC)");
+		goto err0;
+	} else
+#endif
+#ifndef POSIXFAIL_CLOCK_REALTIME
+	if (clock_gettime(CLOCK_REALTIME, &tp) == 0) {
+		tv->tv_sec = tp.tv_sec;
+		tv->tv_usec = tp.tv_nsec / 1000;
+	} else {
+		warnp("clock_gettime(CLOCK_REALTIME)");
+		goto err0;
+	}
+#else
+	if (gettimeofday(tv, NULL)) {
+		warnp("gettimeofday");
+		goto err0;
+	}
+#endif
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}

data/ext/spiped/spiped-source/libcperciva/util/monoclock.h

@@ -0,0 +1,14 @@
+#ifndef _MONOCLOCK_H_
+#define _MONOCLOCK_H_
+
+#include <sys/time.h>
+
+/**
+ * monoclock_get(tv):
+ * Store the current time in ${tv}.  If CLOCK_MONOTONIC is available, use
+ * that clock; if CLOCK_MONOTONIC is unavailable, use CLOCK_REALTIME (if
+ * available) or gettimeofday(2).
+ */
+int monoclock_get(struct timeval *);
+
+#endif /* !_MONOCLOCK_H_ */

data/ext/spiped/spiped-source/libcperciva/util/noeintr.c

@@ -0,0 +1,54 @@
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#include "noeintr.h"
+
+/**
+ * noeintr_write(d, buf, nbytes):
+ * Write ${nbytes} bytes of data from ${buf} to the file descriptor ${d} per
+ * the write(2) system call, but looping until completion if interrupted by
+ * a signal.  Return ${nbytes} on success or -1 on error.
+ */
+ssize_t
+noeintr_write(int d, const void * buf, size_t nbyte)
+{
+	const uint8_t * p = buf;
+	size_t len = nbyte;
+	ssize_t lenwrit;
+
+	/* Implementation-defined: Don't allow oversized writes. */
+	assert(nbyte <= SSIZE_MAX);
+
+	/* Loop until we have no data left to write. */
+	while (len > 0) {
+		if ((lenwrit = write(d, p, len)) == -1) {
+			/* EINTR is harmless. */
+			if (errno == EINTR)
+				continue;
+
+			/* Anything else isn't. */
+			goto err0;
+		}
+
+		/* Sanity check. */
+		assert(lenwrit >= 0);
+		assert(lenwrit <= (ssize_t)len);
+
+		/*
+		 * We might have done a partial write; advance the buffer
+		 * pointer and adjust the remaining write length.
+		 */
+		p += lenwrit;
+		len -= lenwrit;
+	}
+
+	/* Success! */
+	return (nbyte);
+
+err0:
+	/* Failure! */
+	return (-1);
+}

data/ext/spiped/spiped-source/libcperciva/util/noeintr.h

@@ -0,0 +1,14 @@
+#ifndef _NOEINTR_H_
+#define _NOEINTR_H_
+
+#include <unistd.h>
+
+/**
+ * noeintr_write(d, buf, nbytes):
+ * Write ${nbytes} bytes of data from ${buf} to the file descriptor ${d} per
+ * the write(2) system call, but looping until completion if interrupted by
+ * a signal.  Return ${nbytes} on success or -1 on error.
+ */
+ssize_t noeintr_write(int, const void *, size_t);
+
+#endif /* _NOEINTR_H_ */

data/ext/spiped/spiped-source/libcperciva/util/sock.c

@@ -0,0 +1,472 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include <netinet/in.h>
+
+#include <arpa/inet.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "imalloc.h"
+#include "warnp.h"
+
+#include "sock.h"
+#include "sock_internal.h"
+
+/* Convert a path into a socket address. */
+static struct sock_addr **
+sock_resolve_unix(const char * addr)
+{
+	struct sock_addr ** sas;
+	struct sock_addr * sa;
+	struct sockaddr_un * sa_un;
+
+	/* Allocate and populate a sockaddr_un structure. */
+	if ((sa_un = calloc(1, sizeof(struct sockaddr_un))) == NULL)
+		goto err0;
+	sa_un->sun_family = AF_UNIX;
+	if (strlen(addr) >= sizeof(sa_un->sun_path)) {
+		warn0("socket path too long: %s", addr);
+		goto err1;
+	}
+	strcpy(sa_un->sun_path, addr);
+
+	/* Allocate and populate our wrapper. */
+	if ((sa = malloc(sizeof(struct sock_addr))) == NULL)
+		goto err1;
+	sa->ai_family = AF_UNIX;
+	sa->ai_socktype = SOCK_STREAM;
+	sa->name = (struct sockaddr *)sa_un;
+	sa->namelen = sizeof(struct sockaddr_un);
+
+	/* Allocate and populate an array of pointers. */
+	if ((sas = malloc(2 * sizeof(struct sock_addr *))) == NULL)
+		goto err2;
+	sas[0] = sa;
+	sas[1] = NULL;
+
+	/* Success! */
+	return (sas);
+
+err2:
+	free(sa);
+err1:
+	free(sa_un);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/* Resolve a host into a list of socket addresses. */
+static struct sock_addr **
+sock_resolve_host(const char * addr, const char * ports)
+{
+	struct addrinfo hints;
+	struct addrinfo * res;
+	struct addrinfo * r;
+	struct sock_addr ** sas;
+	size_t n;
+	int error;
+
+	/* Create hints structure. */
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	/* Perform DNS lookup. */
+	if ((error = getaddrinfo(addr, ports, &hints, &res)) != 0) {
+		warn0("Error looking up %s: %s", addr, gai_strerror(error));
+		goto err0;
+	}
+
+	/* Count addresses returned. */
+	for (n = 0, r = res; r != NULL; r = r->ai_next)
+		n++;
+
+	/* Allocate our response array. */
+	if (IMALLOC(sas, n + 1, struct sock_addr *))
+		goto err1;
+
+	/* Create address structures. */
+	for (n = 0, r = res; r != NULL; n++, r = r->ai_next) {
+		/* Allocate a structure. */
+		if ((sas[n] = malloc(sizeof(struct sock_addr))) == NULL)
+			goto err2;
+
+		/* Copy in the address metadata. */
+		sas[n]->ai_family = r->ai_family;
+		sas[n]->ai_socktype = r->ai_socktype;
+		sas[n]->namelen = r->ai_addrlen;
+
+		/* Duplicate the address. */
+		if ((sas[n]->name = malloc(sas[n]->namelen)) == NULL)
+			goto err3;
+		memcpy(sas[n]->name, r->ai_addr, sas[n]->namelen);
+	}
+
+	/* Terminate array with a NULL. */
+	sas[n] = NULL;
+
+	/* Free the linked list of addresses returned by getaddrinfo. */
+	freeaddrinfo(res);
+
+	/* Success! */
+	return (sas);
+
+err3:
+	free(sas[n]);
+err2:
+	for (; n > 0; n--)
+		sock_addr_free(sas[n - 1]);
+	free(sas);
+err1:
+	freeaddrinfo(res);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/* Parse an IPv6 address into a socket address. */
+static struct sock_addr **
+sock_resolve_ipv6(const char * addr, in_port_t p)
+{
+	struct sock_addr ** sas;
+	struct sock_addr * sa;
+	struct sockaddr_in6 * sin6;
+
+	/* Allocate and populate a sockaddr_in6 structure. */
+	if ((sin6 = calloc(1, sizeof(struct sockaddr_in6))) == NULL)
+		goto err0;
+	sin6->sin6_family = AF_INET6;
+	sin6->sin6_port = htons(p);
+	if (inet_pton(AF_INET6, addr, &sin6->sin6_addr) != 1) {
+		warn0("Error parsing IP address: %s", addr);
+		goto err1;
+	}
+
+	/* Allocate and populate our wrapper. */
+	if ((sa = malloc(sizeof(struct sock_addr))) == NULL)
+		goto err1;
+	sa->ai_family = AF_INET6;
+	sa->ai_socktype = SOCK_STREAM;
+	sa->name = (struct sockaddr *)sin6;
+	sa->namelen = sizeof(struct sockaddr_in6);
+
+	/* Allocate and populate an array of pointers. */
+	if ((sas = malloc(2 * sizeof(struct sock_addr *))) == NULL)
+		goto err2;
+	sas[0] = sa;
+	sas[1] = NULL;
+
+	/* Success! */
+	return (sas);
+
+err2:
+	free(sa);
+err1:
+	free(sin6);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/* Parse an IPv4 address into a socket address. */
+static struct sock_addr **
+sock_resolve_ipv4(const char * addr, in_port_t p)
+{
+	struct sock_addr ** sas;
+	struct sock_addr * sa;
+	struct sockaddr_in * sin;
+
+	/* Allocate and populate a sockaddr_in structure. */
+	if ((sin = calloc(1, sizeof(struct sockaddr_in))) == NULL)
+		goto err0;
+	sin->sin_family = AF_INET;
+	sin->sin_port = htons(p);
+	if (inet_pton(AF_INET, addr, &sin->sin_addr) != 1) {
+		warn0("Error parsing IP address: %s", addr);
+		goto err1;
+	}
+
+	/* Allocate and populate our wrapper. */
+	if ((sa = malloc(sizeof(struct sock_addr))) == NULL)
+		goto err1;
+	sa->ai_family = AF_INET;
+	sa->ai_socktype = SOCK_STREAM;
+	sa->name = (struct sockaddr *)sin;
+	sa->namelen = sizeof(struct sockaddr_in);
+
+	/* Allocate and populate an array of pointers. */
+	if ((sas = malloc(2 * sizeof(struct sock_addr *))) == NULL)
+		goto err2;
+	sas[0] = sa;
+	sas[1] = NULL;
+
+	/* Success! */
+	return (sas);
+
+err2:
+	free(sa);
+err1:
+	free(sin);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * sock_resolve(addr):
+ * Return a NULL-terminated array of pointers to sock_addr structures.
+ */
+struct sock_addr **
+sock_resolve(const char * addr)
+{
+	struct sock_addr ** res;
+	char * s;
+	char * ports;
+	char * ips;
+	long p;
+
+	/* If the address starts with '/', it's a unix socket. */
+	if (addr[0] == '/') {
+		res = sock_resolve_unix(addr);
+		goto done0;
+	}
+
+	/* Copy the address so that we can mangle it. */
+	if ((s = strdup(addr)) == NULL)
+		goto err0;
+
+	/* The address should end with :port.  Look for the last ':'. */
+	if ((ports = strrchr(s, ':')) == NULL) {
+		warn0("Address must contain port number: %s", s);
+		goto err1;
+	}
+	*ports++ = '\0';
+
+	/* If the address doesn't start with '[', it's a host name. */
+	if (s[0] != '[') {
+		res = sock_resolve_host(s, ports);
+		goto done1;
+	}
+
+	/* The address (sans :port) should end with ']'. */
+	if (s[strlen(s) - 1] != ']') {
+		warn0("Invalid [IP address]: %s", s);
+		goto err1;
+	}
+
+	/* Extract the IP address string. */
+	ips = &s[1];
+	ips[strlen(ips) - 1] = '\0';
+
+	/*
+	 * Parse the port number.  If strtol fails to parse the port number,
+	 * it will return 0; but that's fine since port 0 is invalid anyway.
+	 */
+	p = strtol(ports, NULL, 10);
+	if ((p <= 0) || (p >= 65536)) {
+		warn0("Invalid port number: %s", ports);
+		goto err1;
+	}
+
+	/* If the IP address contains ':', it's IPv6; otherwise, IPv4. */
+	if (strchr(ips, ':') != NULL)
+		res = sock_resolve_ipv6(ips, p);
+	else
+		res = sock_resolve_ipv4(ips, p);
+
+done1:
+	/* Free string allocated by strdup. */
+	free(s);
+done0:
+	/* Return result from sock_resolve_foo. */
+	return (res);
+
+err1:
+	free(s);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * sock_listener(sa):
+ * Create a socket, set SO_REUSEADDR, bind it to the socket address ${sa},
+ * mark it for listening, and mark it as non-blocking.
+ */
+int
+sock_listener(const struct sock_addr * sa)
+{
+	int s;
+	int val = 1;
+
+	/* Create a socket. */
+	if ((s = socket(sa->ai_family, sa->ai_socktype, 0)) == -1) {
+		warnp("socket(%d, %d)", sa->ai_family, sa->ai_socktype);
+		goto err0;
+	}
+
+	/* Set SO_REUSEADDR. */
+	if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val))) {
+		warnp("setsockopt(SO_REUSEADDR)");
+		goto err1;
+	}
+
+	/* Bind the socket. */
+	if (bind(s, sa->name, sa->namelen)) {
+		warnp("Error binding socket");
+		goto err1;
+	}
+
+	/* Mark the socket as listening. */
+	if (listen(s, 10)) {
+		warnp("Error marking socket as listening");
+		goto err1;
+	}
+
+	/* Mark the socket as non-blocking. */
+	if (fcntl(s, F_SETFL, O_NONBLOCK) == -1) {
+		warnp("Error marking socket as non-blocking");
+		goto err1;
+	}
+
+	/* Success! */
+	return (s);
+
+err1:
+	close(s);
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * sock_connect(sas):
+ * Iterate through the addresses in ${sas}, attempting to create a socket and
+ * connect (blockingly).  Once connected, stop iterating, mark the socket as
+ * non-blocking, and return it.
+ */
+int
+sock_connect(struct sock_addr * const * sas)
+{
+	int s = -1;
+
+	/* Iterate through the addresses provided. */
+	for (; sas[0] != NULL; sas++) {
+		/* Create a socket. */
+		if ((s = socket(sas[0]->ai_family,
+		    sas[0]->ai_socktype, 0)) == -1)
+			continue;
+
+		/* Attempt to connect. */
+		if (connect(s, sas[0]->name, sas[0]->namelen) == 0)
+			break;
+
+		/* Close the socket; this address didn't work. */
+		close(s);
+	}
+
+	/* Did we manage to connect? */
+	if (sas[0] == NULL) {
+		warn0("Could not connect");
+		goto err0;
+	}
+
+	/* Mark the socket as non-blocking. */
+	if (fcntl(s, F_SETFL, O_NONBLOCK) == -1) {
+		warnp("Cannot make connection non-blocking");
+		goto err1;
+	}
+
+	/* Success! */
+	return (s);
+
+err1:
+	close(s);
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * sock_connect_nb(sa):
+ * Create a socket, mark it as non-blocking, and attempt to connect to the
+ * address ${sa}.  Return the socket (connected or in the process of
+ * connecting) or -1 on error.
+ */
+int
+sock_connect_nb(const struct sock_addr * sa)
+{
+	int s;
+
+	/* Create a socket. */
+	if ((s = socket(sa->ai_family, sa->ai_socktype, 0)) == -1)
+		goto err0;
+
+	/* Mark the socket as non-blocking. */
+	if (fcntl(s, F_SETFL, O_NONBLOCK) == -1) {
+		warnp("Cannot make socket non-blocking");
+		goto err1;
+	}
+
+	/* Attempt to connect. */
+	if ((connect(s, sa->name, sa->namelen) == -1) &&
+	    (errno != EINPROGRESS) &&
+	    (errno != EINTR))
+		goto err1;
+
+	/* We have a connect(ed|ing) socket. */
+	return (s);
+
+err1:
+	close(s);
+err0:
+	/* We failed to connect to this address. */
+	return (-1);
+}
+
+/**
+ * sock_addr_free(sa):
+ * Free the provided sock_addr structure.
+ */
+void
+sock_addr_free(struct sock_addr * sa)
+{
+
+	/* Compatibility with free(NULL). */
+	if (sa == NULL)
+		return;
+
+	/* Free the protocol-specific address structure and our struct. */
+	free(sa->name);
+	free(sa);
+}
+
+/**
+ * sock_addr_freelist(sas):
+ * Free the provided NULL-terminated array of sock_addr structures.
+ */
+void
+sock_addr_freelist(struct sock_addr ** sas)
+{
+	struct sock_addr ** p;
+
+	/* Compatibility with free(NULL). */
+	if (sas == NULL)
+		return;
+
+	/* Free structures until we hit NULL. */
+	for (p = sas; *p != NULL; p++)
+		sock_addr_free(*p);
+
+	/* Free the list. */
+	free(sas);
+}