spiped 0.0.0

data/ext/spiped/spiped-source/libcperciva/network/network_write.c

@@ -0,0 +1,188 @@
+#include <sys/socket.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "events.h"
+#include "warnp.h"
+
+#include "network.h"
+
+/**
+ * POSIX.1-2008 requires that MSG_NOSIGNAL be defined as a flag for send(2)
+ * which has the effect of preventing SIGPIPE from being raised when writing
+ * to a descriptor which has been shut down.  Unfortunately there are some
+ * platforms which are not POSIX.1-2008 compliant; we provide a workaround
+ * (-DPOSIXFAIL_MSG_NOSIGNAL) which instead blocks the SIGPIPE signal on such
+ * platforms.
+ *
+ * (This workaround could be used automatically, but requiring that it be
+ * explicitly enabled helps to get platforms fixed.)
+ */
+#ifdef POSIXFAIL_MSG_NOSIGNAL
+#ifndef MSG_NOSIGNAL
+#define MSG_NOSIGNAL 0
+#endif
+#endif
+
+struct network_write_cookie {
+	int (*callback)(void *, ssize_t);
+	void * cookie;
+	int fd;
+	const uint8_t * buf;
+	size_t buflen;
+	size_t minlen;
+	size_t bufpos;
+};
+
+/* Invoke the callback, clean up, and return the callback's status. */
+static int
+docallback(struct network_write_cookie * C, ssize_t nbytes)
+{
+	int rc;
+
+	/* Invoke the callback. */
+	rc = (C->callback)(C->cookie, nbytes);
+
+	/* Clean up. */
+	free(C);
+
+	/* Return the callback's status. */
+	return (rc);
+}
+
+/* The socket is ready for reading/writing. */
+static int
+callback_buf(void * cookie)
+{
+	struct network_write_cookie * C = cookie;
+	size_t oplen;
+	ssize_t len;
+#ifdef POSIXFAIL_MSG_NOSIGNAL
+	void (*oldsig)(int);
+#endif
+
+	/* If we don't have MSG_NOSIGNAL, catch SIGPIPE. */
+#ifdef POSIXFAIL_MSG_NOSIGNAL
+	if ((oldsig = signal(SIGPIPE, SIG_IGN)) == SIG_ERR) {
+		warnp("signal(SIGPIPE)");
+		goto failed;
+	}
+#endif
+
+	/* Attempt to read/write data to/from the buffer. */
+	oplen = C->buflen - C->bufpos;
+	len = send(C->fd, C->buf + C->bufpos, oplen, MSG_NOSIGNAL);
+
+	/* We should never see a send length of zero. */
+	assert(len != 0);
+
+	/* If we set a SIGPIPE handler, restore the old one. */
+#ifdef POSIXFAIL_MSG_NOSIGNAL
+	if (signal(SIGPIPE, oldsig) == SIG_ERR) {
+		warnp("signal(SIGPIPE)");
+		goto failed;
+	}
+#endif
+
+	/* Failure? */
+	if (len == -1) {
+		/* Was it really an error, or just a try-again? */
+		if ((errno == EAGAIN) ||
+		    (errno == EWOULDBLOCK) ||
+		    (errno == EINTR))
+			goto tryagain;
+
+		/* Something went wrong. */
+		goto failed;
+	}
+
+	/* We processed some data.  Do we need to keep going? */
+	if ((C->bufpos += len) < C->minlen)
+		goto tryagain;
+
+	/* Invoke the callback and return. */
+	return (docallback(C, C->bufpos));
+
+tryagain:
+	/* Reset the event. */
+	if (events_network_register(callback_buf, C, C->fd,
+	    EVENTS_NETWORK_OP_WRITE))
+		goto failed;
+
+	/* Callback was reset. */
+	return (0);
+
+failed:
+	/* Invoke the callback with a failure status and return. */
+	return (docallback(C, -1));
+}
+
+/**
+ * network_write(fd, buf, buflen, minwrite, callback, cookie):
+ * Asynchronously write up to ${buflen} bytes of data from ${buf} to ${fd}.
+ * When at least ${minwrite} bytes have been written or on error, invoke
+ * ${callback}(${cookie}, lenwrit), where lenwrit is -1 on error and the
+ * number of bytes written (between ${minwrite} and ${buflen} inclusive)
+ * otherwise.  Return a cookie which can be passed to network_write_cancel in
+ * order to cancel the write.
+ */
+void *
+network_write(int fd, const uint8_t * buf, size_t buflen, size_t minwrite,
+    int (* callback)(void *, ssize_t), void * cookie)
+{
+	struct network_write_cookie * C;
+
+	/* Make sure buflen is non-zero. */
+	assert(buflen != 0);
+
+	/* Sanity-check: # bytes must fit into a ssize_t. */
+	assert(buflen <= SSIZE_MAX);
+
+	/* Bake a cookie. */
+	if ((C = malloc(sizeof(struct network_write_cookie))) == NULL)
+		goto err0;
+	C->callback = callback;
+	C->cookie = cookie;
+	C->fd = fd;
+	C->buf = buf;
+	C->buflen = buflen;
+	C->minlen = minwrite;
+	C->bufpos = 0;
+
+	/* Register a callback for network readiness. */
+	if (events_network_register(callback_buf, C, C->fd,
+	    EVENTS_NETWORK_OP_WRITE))
+		goto err1;
+
+	/* Success! */
+	return (C);
+
+err1:
+	free(C);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * network_write_cancel(cookie):
+ * Cancel the buffer write for which the cookie ${cookie} was returned by
+ * network_write.  Do not invoke the callback associated with the write.
+ */
+void
+network_write_cancel(void * cookie)
+{
+	struct network_write_cookie * C = cookie;
+
+	/* Kill the network event. */
+	events_network_cancel(C->fd, EVENTS_NETWORK_OP_WRITE);
+
+	/* Free the cookie. */
+	free(C);
+}

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

@@ -0,0 +1,49 @@
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "asprintf.h"
+
+/**
+ * asprintf(ret, format, ...):
+ * Do asprintf(3) like GNU and BSD do.
+ */
+int
+asprintf(char ** ret, const char * format, ...)
+{
+	va_list ap;
+	int len;
+	size_t buflen;
+
+	/* Figure out how long the string needs to be. */
+	va_start(ap, format);
+	len = vsnprintf(NULL, 0, format, ap);
+	va_end(ap);
+
+	/* Did we fail? */
+	if (len < 0)
+		goto err0;
+	buflen = (size_t)(len) + 1;
+
+	/* Allocate memory. */
+	if ((*ret = malloc(buflen)) == NULL)
+		goto err0;
+
+	/* Actually generate the string. */
+	va_start(ap, format);
+	len = vsnprintf(*ret, buflen, format, ap);
+	va_end(ap);
+
+	/* Did we fail? */
+	if (len < 0)
+		goto err1;
+
+	/* Success! */
+	return (len);
+
+err1:
+	free(*ret);
+err0:
+	/* Failure! */
+	return (-1);
+}

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

@@ -0,0 +1,16 @@
+#ifndef _ASPRINTF_H_
+#define _ASPRINTF_H_
+
+/* Avoid namespace collisions with BSD/GNU asprintf. */
+#ifdef asprintf
+#undef asprintf
+#endif
+#define asprintf libcperciva_asprintf
+
+/**
+ * asprintf(ret, format, ...):
+ * Do asprintf(3) like GNU and BSD do.
+ */
+int asprintf(char **, const char *, ...);
+
+#endif /* !_ASPRINTF_H_ */

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

@@ -0,0 +1,134 @@
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "noeintr.h"
+#include "warnp.h"
+
+#include "daemonize.h"
+
+/**
+ * daemonize(spid):
+ * Daemonize and write the process ID in decimal to a file named ${spid}.
+ * The parent process will exit only after the child has written its pid.
+ * On success, the child will return 0; on failure, the parent will return
+ * -1.
+ */
+int
+daemonize(const char * spid)
+{
+	FILE * f;
+	int fd[2];
+	char dummy = 0;
+
+	/*
+	 * Create a pipe for the child to notify the parent when it has
+	 * finished daemonizing.
+	 */
+	if (pipe(fd)) {
+		warnp("pipe");
+		goto err0;
+	}
+
+	/*
+	 * Fork into the parent process (which waits for a poke and exits)
+	 * and the child process (which keeps going).
+	 */
+	switch (fork()) {
+	case -1:
+		/* Fork failed. */
+		warnp("fork");
+		goto err2;
+	case 0:
+		/* In child process. */
+		break;
+	default:
+		/*
+		 * In parent process.  Close write end of pipe so that if the
+		 * client dies we will notice the pipe being reset.
+		 */
+		while (close(fd[1])) {
+			if (errno == EINTR)
+				continue;
+			warnp("close");
+			goto err1;
+		}
+		do {
+			switch (read(fd[0], &dummy, 1)) {
+			case -1:
+				/* Error in read. */
+				break;
+			case 0:
+				/* EOF -- the child died without poking us. */
+				goto err1;
+			case 1:
+				/* We have been poked by the child.  Exit. */
+				_exit(0);
+			}
+
+			/* Anything other than EINTR is bad. */
+			if (errno != EINTR) {
+				warnp("read");
+				goto err1;
+			}
+		} while (1);
+	}
+
+	/* Set ourselves to be a session leader. */
+	if (setsid() == -1) {
+		warnp("setsid");
+		goto die;
+	}
+
+	/* Write out our pid file. */
+	if ((f = fopen(spid, "w")) == NULL) {
+		warnp("fopen(%s)", spid);
+		goto die;
+	}
+	if (fprintf(f, "%d", getpid()) < 0) {
+		warnp("fprintf");
+		goto die;
+	}
+	if (fclose(f)) {
+		warnp("fclose");
+		goto die;
+	}
+
+	/* Tell the parent to suicide. */
+	if (noeintr_write(fd[1], &dummy, 1) == -1) {
+		warnp("write");
+		goto die;
+	}
+
+	/* Close the pipe. */
+	while (close(fd[0])) {
+		if (errno == EINTR)
+			continue;
+		warnp("close");
+		goto die;
+	}
+	while (close(fd[1])) {
+		if (errno == EINTR)
+			continue;
+		warnp("close");
+		goto die;
+	}
+
+	/* Success! */
+	return (0);
+
+err2:
+	close(fd[1]);
+err1:
+	close(fd[0]);
+err0:
+	/* Failure! */
+	return (-1);
+
+die:
+	/*
+	 * We're in the child and something bad happened; the parent will be
+	 * notified when we die thanks to the pipe being closed.
+	 */
+	_exit(0);
+}

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

@@ -0,0 +1,10 @@
+#ifndef _DAEMONIZE_H_
+#define _DAEMONIZE_H_
+
+/**
+ * daemonize(spid):
+ * Daemonize and write the process ID in decimal to a file named ${spid}.
+ */
+int daemonize(const char *);
+
+#endif /* !_DAEMONIZE_H_ */

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

@@ -0,0 +1,76 @@
+#include <fcntl.h>
+#include <limits.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#include "warnp.h"
+
+#include "entropy.h"
+
+/**
+ * XXX Portability
+ * XXX We obtain random bytes from the operating system by opening
+ * XXX /dev/urandom and reading them from that device; this works on
+ * XXX modern UNIX-like operating systems but not on systems like
+ * XXX win32 where there is no concept of /dev/urandom.
+ */
+
+/**
+ * entropy_read(buf, buflen):
+ * Fill the given buffer with random bytes provided by the operating system.
+ */
+int
+entropy_read(uint8_t * buf, size_t buflen)
+{
+	int fd;
+	ssize_t lenread;
+
+	/* Sanity-check the buffer size. */
+	if (buflen > SSIZE_MAX) {
+		warn0("Programmer error: "
+		    "Trying to read insane amount of random data: %zu",
+		    buflen);
+		goto err0;
+	}
+
+	/* Open /dev/urandom. */
+	if ((fd = open("/dev/urandom", O_RDONLY)) == -1) {
+		warnp("open(/dev/urandom)");
+		goto err0;
+	}
+
+	/* Read bytes until we have filled the buffer. */
+	while (buflen > 0) {
+		if ((lenread = read(fd, buf, buflen)) == -1) {
+			warnp("read(/dev/urandom)");
+			goto err1;
+		}
+
+		/* The random device should never EOF. */
+		if (lenread == 0) {
+			warn0("EOF on /dev/urandom?");
+			goto err1;
+		}
+
+		/* We've filled a portion of the buffer. */
+		buf += lenread;
+		buflen -= lenread;
+	}
+
+	/* Close the device. */
+	while (close(fd) == -1) {
+		if (errno != EINTR) {
+			warnp("close(/dev/urandom)");
+			goto err0;
+		}
+	}
+
+	/* Success! */
+	return (0);
+
+err1:
+	close(fd);
+err0:
+	/* Failure! */
+	return (-1);
+}