spiped 0.0.0

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

@@ -0,0 +1,56 @@
+#ifndef _SOCK_H_
+#define _SOCK_H_
+
+/**
+ * Address strings are of the following forms:
+ * /path/to/unix/socket
+ * [ip.v4.ad.dr]:port
+ * [ipv6:add::ress]:port
+ * host.name:port
+ */
+
+/* Opaque address structure. */
+struct sock_addr;
+
+/**
+ * sock_resolve(addr):
+ * Return a NULL-terminated array of pointers to sock_addr structures.
+ */
+struct sock_addr ** sock_resolve(const char *);
+
+/**
+ * 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 *);
+
+/**
+ * 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 *);
+
+/**
+ * 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 *);
+
+/**
+ * sock_addr_free(sa):
+ * Free the provided sock_addr structure.
+ */
+void sock_addr_free(struct sock_addr *);
+
+/**
+ * sock_addr_freelist(sas):
+ * Free the provided NULL-terminated array of sock_addr structures.
+ */
+void sock_addr_freelist(struct sock_addr **);
+
+#endif /* !_SOCK_H_ */

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

@@ -0,0 +1,14 @@
+#ifndef _SOCK_INTERNAL_H_
+#define _SOCK_INTERNAL_H_
+
+#include <sys/socket.h>
+
+/* Socket address structure. */
+struct sock_addr {
+	int ai_family;
+	int ai_socktype;
+	struct sockaddr * name;
+	socklen_t namelen;
+};
+
+#endif /* !_SOCK_INTERNAL_H_ */

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

@@ -0,0 +1,271 @@
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include <netinet/in.h>
+
+#include <arpa/inet.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "asprintf.h"
+#include "sock.h"
+
+#include "sock_util.h"
+#include "sock_internal.h"
+
+/**
+ * sock_addr_cmp(sa1, sa2):
+ * Return non-zero iff the socket addresses ${sa1} and ${sa2} are different.
+ */
+int
+sock_addr_cmp(const struct sock_addr * sa1, const struct sock_addr * sa2)
+{
+
+	/* Family, socket type, and name length must match. */
+	if ((sa1->ai_family != sa2->ai_family) ||
+	    (sa1->ai_socktype != sa2->ai_socktype) ||
+	    (sa1->namelen != sa2->namelen))
+		return (1);
+
+	/* The required length of the sockaddr must match. */
+	if (memcmp(sa1->name, sa2->name, sa1->namelen) != 0)
+		return (1);
+
+	/* Everything matched. */
+	return (0);
+}
+
+/**
+ * sock_addr_dup(sa):
+ * Duplicate the provided socket address.
+ */
+struct sock_addr *
+sock_addr_dup(const struct sock_addr * sa)
+{
+	struct sock_addr * sa2;
+
+	/* Allocate a struct sock_addr and copy fields. */
+	if ((sa2 = malloc(sizeof(struct sock_addr))) == NULL)
+		goto err0;
+	sa2->ai_family = sa->ai_family;
+	sa2->ai_socktype = sa->ai_socktype;
+	sa2->namelen = sa->namelen;
+
+	/* Allocate and copy the sockaddr. */
+	if ((sa2->name = malloc(sa2->namelen)) == NULL)
+		goto err1;
+	memcpy(sa2->name, sa->name, sa2->namelen);
+
+	/* Success! */
+	return (sa2);
+
+err1:
+	free(sa2);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * sock_addr_duplist(sas):
+ * Duplicate the provided list of socket addresses.
+ */
+struct sock_addr **
+sock_addr_duplist(struct sock_addr * const * sas)
+{
+	struct sock_addr ** sas2;
+	size_t i;
+
+	/* Count socket addresses. */
+	for (i = 0; sas[i] != NULL; i++)
+		continue;
+
+	/* Allocate the list to hold addresses plus a NULL terminator. */
+	if ((sas2 = malloc((i + 1) * sizeof(struct sock_addr *))) == NULL)
+		goto err0;
+
+	/* Duplicate addresses and NULL-terminate. */
+	for (i = 0; sas[i] != NULL; i++) {
+		if ((sas2[i] = sock_addr_dup(sas[i])) == NULL)
+			goto err1;
+	}
+	sas2[i] = NULL;
+
+	/* Success! */
+	return (sas2);
+
+err1:
+	/*
+	 * Regardless of how many addresses we managed to duplicate before
+	 * failing and being sent here, we have a valid socket address list,
+	 * since the erroring sock_addr_dup call NULL-terminated it for us;
+	 * so we can free it and its constituent addresses easily.
+	 */
+	sock_addr_freelist(sas2);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * sock_addr_serialize(sa, buf, buflen):
+ * Allocate a buffer and serialize the socket address ${sa} into it.  Return
+ * the buffer via ${buf} and its length via ${buflen}.  The serialization is
+ * machine and operating system dependent.
+ */
+int
+sock_addr_serialize(const struct sock_addr * sa,
+    uint8_t ** buf, size_t * buflen)
+{
+	uint8_t * p;
+
+	/* Compute buffer length and allocate buffer. */
+	*buflen = 2 * sizeof(int) + sizeof(socklen_t) + sa->namelen;
+	if ((p = *buf = malloc(*buflen)) == NULL)
+		goto err0;
+
+	/* Copy in data. */
+	memcpy(p, &sa->ai_family, sizeof(int));
+	p += sizeof(int);
+	memcpy(p, &sa->ai_socktype, sizeof(int));
+	p += sizeof(int);
+	memcpy(p, &sa->namelen, sizeof(socklen_t));
+	p += sizeof(socklen_t);
+	memcpy(p, sa->name, sa->namelen);
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * sock_addr_deserialize(buf, buflen):
+ * Deserialize the ${buflen}-byte serialized socket address from ${buf}.
+ */
+struct sock_addr *
+sock_addr_deserialize(const uint8_t * buf, size_t buflen)
+{
+	struct sock_addr * sa;
+
+	/* Sanity check. */
+	if (buflen < 2 * sizeof(int) + sizeof(socklen_t))
+		goto err0;
+
+	/* Allocate a structure and copy in fields. */
+	if ((sa = malloc(sizeof(struct sock_addr))) == NULL)
+		goto err0;
+	memcpy(&sa->ai_family, buf, sizeof(int));
+	buf += sizeof(int);
+	memcpy(&sa->ai_socktype, buf, sizeof(int));
+	buf += sizeof(int);
+	memcpy(&sa->namelen, buf, sizeof(socklen_t));
+	buf += sizeof(socklen_t);
+
+	/* Allocate and copy the sockaddr. */
+	if (buflen != 2 * sizeof(int) + sizeof(socklen_t) + sa->namelen)
+		goto err1;
+	if ((sa->name = malloc(sa->namelen)) == NULL)
+		goto err1;
+	memcpy(sa->name, buf, sa->namelen);
+
+	/* Success! */
+	return (sa);
+
+err1:
+	free(sa);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/* Prettyprint an IPv4 address. */
+static char *
+prettyprint_ipv4(struct sockaddr * name, size_t namelen)
+{
+	struct sockaddr_in sa_in;
+	char addr[INET_ADDRSTRLEN];
+	char * s;
+
+	/* Check name length. */
+	if (namelen != sizeof(struct sockaddr_in))
+		return (NULL);
+
+	/* Copy into buffer for alignment. */
+	memcpy(&sa_in, name, namelen);
+
+	/* Convert IP address to string. */
+	if (inet_ntop(AF_INET, &sa_in.sin_addr, addr, sizeof(addr)) == NULL)
+		return (NULL);
+
+	/* Construct address string. */
+	if (asprintf(&s, "[%s]:%d", addr, ntohs(sa_in.sin_port)) == -1)
+		return (NULL);
+
+	/* Success! */
+	return (s);
+}
+
+/* Prettyprint an IPv6 address. */
+static char *
+prettyprint_ipv6(struct sockaddr * name, size_t namelen)
+{
+	struct sockaddr_in6 sa_in6;
+	char addr[INET6_ADDRSTRLEN];
+	char * s;
+
+	/* Check name length. */
+	if (namelen != sizeof(struct sockaddr_in6))
+		return (NULL);
+
+	/* Copy into buffer for alignment. */
+	memcpy(&sa_in6, name, namelen);
+
+	/* Convert IPv6 address to string. */
+	if (inet_ntop(AF_INET6, &sa_in6.sin6_addr, addr, sizeof(addr)) == NULL)
+		return (NULL);
+
+	/* Construct address string. */
+	if (asprintf(&s, "[%s]:%d", addr, ntohs(sa_in6.sin6_port)) == -1)
+		return (NULL);
+
+	/* Success! */
+	return (s);
+}
+
+/* Prettyprint a UNIX address. */
+static char *
+prettyprint_unix(struct sockaddr_un * name)
+{
+
+	/* Just strdup the path. */
+	return (strdup(name->sun_path));
+}
+
+/**
+ * sock_addr_prettyprint(sa):
+ * Allocate and return a string in one of the forms
+ * /path/to/unix/socket
+ * [ip.v4.ad.dr]:port
+ * [ipv6:add::ress]:port
+ * representing the provided socket address.
+ */
+char *
+sock_addr_prettyprint(const struct sock_addr * sa)
+{
+
+	/* Handle different types of addresses differently. */
+	switch (sa->ai_family) {
+	case AF_INET:
+		return (prettyprint_ipv4(sa->name, sa->namelen));
+	case AF_INET6:
+		return (prettyprint_ipv6(sa->name, sa->namelen));
+	case AF_UNIX:
+		return (prettyprint_unix((struct sockaddr_un *)(sa->name)));
+	default:
+		return (strdup("Unknown address"));
+	}
+}

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

@@ -0,0 +1,51 @@
+#ifndef _SOCK_UTIL_H_
+#define _SOCK_UTIL_H_
+
+#include <stdint.h>
+
+/* Opaque address structure. */
+struct sock_addr;
+
+/**
+ * sock_addr_cmp(sa1, sa2):
+ * Return non-zero iff the socket addresses ${sa1} and ${sa2} are different.
+ */
+int sock_addr_cmp(const struct sock_addr *, const struct sock_addr *);
+
+/**
+ * sock_addr_dup(sa):
+ * Duplicate the provided socket address.
+ */
+struct sock_addr * sock_addr_dup(const struct sock_addr *);
+
+/**
+ * sock_addr_duplist(sas):
+ * Duplicate the provided list of socket addresses.
+ */
+struct sock_addr ** sock_addr_duplist(struct sock_addr * const *);
+
+/**
+ * sock_addr_serialize(sa, buf, buflen):
+ * Allocate a buffer and serialize the socket address ${sa} into it.  Return
+ * the buffer via ${buf} and its length via ${buflen}.  The serialization is
+ * machine and operating system dependent.
+ */
+int sock_addr_serialize(const struct sock_addr *, uint8_t **, size_t *);
+
+/**
+ * sock_addr_deserialize(buf, buflen):
+ * Deserialize the ${buflen}-byte serialized socket address from ${buf}.
+ */
+struct sock_addr * sock_addr_deserialize(const uint8_t *, size_t);
+
+/**
+ * sock_addr_prettyprint(sa):
+ * Allocate and return a string in one of the forms
+ * /path/to/unix/socket
+ * [ip.v4.ad.dr]:port
+ * [ipv6:add::ress]:port
+ * representing the provided socket address.
+ */
+char * sock_addr_prettyprint(const struct sock_addr *);
+
+#endif /* !_SOCK_H_ */

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

@@ -0,0 +1,146 @@
+#ifndef _SYSENDIAN_H_
+#define _SYSENDIAN_H_
+
+#include <stdint.h>
+
+/* Avoid namespace collisions with BSD <sys/endian.h>. */
+#define be16dec libcperciva_be16dec
+#define be16enc libcperciva_be16enc
+#define be32dec libcperciva_be32dec
+#define be32enc libcperciva_be32enc
+#define be64dec libcperciva_be64dec
+#define be64enc libcperciva_be64enc
+#define le16dec libcperciva_le16dec
+#define le16enc libcperciva_le16enc
+#define le32dec libcperciva_le32dec
+#define le32enc libcperciva_le32enc
+#define le64dec libcperciva_le64dec
+#define le64enc libcperciva_le64enc
+
+static inline uint16_t
+be16dec(const void * pp)
+{
+	const uint8_t * p = (uint8_t const *)pp;
+
+	return ((uint16_t)(p[1]) + ((uint16_t)(p[0]) << 8));
+}
+
+static inline void
+be16enc(void * pp, uint16_t x)
+{
+	uint8_t * p = (uint8_t *)pp;
+
+	p[1] = x & 0xff;
+	p[0] = (x >> 8) & 0xff;
+}
+
+static inline uint32_t
+be32dec(const void * pp)
+{
+	const uint8_t * p = (uint8_t const *)pp;
+
+	return ((uint32_t)(p[3]) + ((uint32_t)(p[2]) << 8) +
+	    ((uint32_t)(p[1]) << 16) + ((uint32_t)(p[0]) << 24));
+}
+
+static inline void
+be32enc(void * pp, uint32_t x)
+{
+	uint8_t * p = (uint8_t *)pp;
+
+	p[3] = x & 0xff;
+	p[2] = (x >> 8) & 0xff;
+	p[1] = (x >> 16) & 0xff;
+	p[0] = (x >> 24) & 0xff;
+}
+
+static inline uint64_t
+be64dec(const void * pp)
+{
+	const uint8_t * p = (uint8_t const *)pp;
+
+	return ((uint64_t)(p[7]) + ((uint64_t)(p[6]) << 8) +
+	    ((uint64_t)(p[5]) << 16) + ((uint64_t)(p[4]) << 24) +
+	    ((uint64_t)(p[3]) << 32) + ((uint64_t)(p[2]) << 40) +
+	    ((uint64_t)(p[1]) << 48) + ((uint64_t)(p[0]) << 56));
+}
+
+static inline void
+be64enc(void * pp, uint64_t x)
+{
+	uint8_t * p = (uint8_t *)pp;
+
+	p[7] = x & 0xff;
+	p[6] = (x >> 8) & 0xff;
+	p[5] = (x >> 16) & 0xff;
+	p[4] = (x >> 24) & 0xff;
+	p[3] = (x >> 32) & 0xff;
+	p[2] = (x >> 40) & 0xff;
+	p[1] = (x >> 48) & 0xff;
+	p[0] = (x >> 56) & 0xff;
+}
+
+static inline uint16_t
+le16dec(const void * pp)
+{
+	const uint8_t * p = (uint8_t const *)pp;
+
+	return ((uint16_t)(p[0]) + ((uint16_t)(p[1]) << 8));
+}
+
+static inline void
+le16enc(void * pp, uint16_t x)
+{
+	uint8_t * p = (uint8_t *)pp;
+
+	p[0] = x & 0xff;
+	p[1] = (x >> 8) & 0xff;
+}
+
+static inline uint32_t
+le32dec(const void * pp)
+{
+	const uint8_t * p = (uint8_t const *)pp;
+
+	return ((uint32_t)(p[0]) + ((uint32_t)(p[1]) << 8) +
+	    ((uint32_t)(p[2]) << 16) + ((uint32_t)(p[3]) << 24));
+}
+
+static inline void
+le32enc(void * pp, uint32_t x)
+{
+	uint8_t * p = (uint8_t *)pp;
+
+	p[0] = x & 0xff;
+	p[1] = (x >> 8) & 0xff;
+	p[2] = (x >> 16) & 0xff;
+	p[3] = (x >> 24) & 0xff;
+}
+
+static inline uint64_t
+le64dec(const void * pp)
+{
+	const uint8_t * p = (uint8_t const *)pp;
+
+	return ((uint64_t)(p[0]) + ((uint64_t)(p[1]) << 8) +
+	    ((uint64_t)(p[2]) << 16) + ((uint64_t)(p[3]) << 24) +
+	    ((uint64_t)(p[4]) << 32) + ((uint64_t)(p[5]) << 40) +
+	    ((uint64_t)(p[6]) << 48) + ((uint64_t)(p[7]) << 56));
+}
+
+static inline void
+le64enc(void * pp, uint64_t x)
+{
+	uint8_t * p = (uint8_t *)pp;
+
+	p[0] = x & 0xff;
+	p[1] = (x >> 8) & 0xff;
+	p[2] = (x >> 16) & 0xff;
+	p[3] = (x >> 24) & 0xff;
+	p[4] = (x >> 32) & 0xff;
+	p[5] = (x >> 40) & 0xff;
+	p[6] = (x >> 48) & 0xff;
+	p[7] = (x >> 56) & 0xff;
+}
+
+#endif /* !_SYSENDIAN_H_ */