Actual install process

9 files changed, 1012 insertions, 0 deletions

diff --git a/src/.gitignore b/src/.gitignore
new file mode 100644
index 0000000..bf84729
--- /dev/null
+++ b/src/.gitignore
@@ -0,0 +1,5 @@
+/freenect-server
+/multipart-replace-http-server
+
+*.o
+.*.mk
diff --git a/src/freenect-server.c b/src/freenect-server.c
new file mode 100644
index 0000000..c5ed99a
--- /dev/null
+++ b/src/freenect-server.c
@@ -0,0 +1,289 @@
+/*
+ * This file is part of the OpenKinect Project. http://www.openkinect.org
+ *
+ * Copyright (c) 2010 Brandyn White (bwhite@dappervision.com)
+ * Copyright (c) 2016 Luke Shumaker (lukeshu@sbcglobal.net)
+ *
+ * This code is licensed to you under the terms of the Apache License, version
+ * 2.0, or, at your option, the terms of the GNU General Public License,
+ * version 2.0. See the APACHE20 and GPL2 files for the text of the licenses,
+ * or the following URLs:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.gnu.org/licenses/gpl-2.0.txt
+ *
+ * If you redistribute this file in source form, modified or unmodified, you
+ * may:
+ *   1) Leave this header intact and distribute it under the same terms,
+ *      accompanying it with the APACHE20 and GPL20 files, or
+ *   2) Delete the Apache 2.0 clause and accompany it with the GPL2 file, or
+ *   3) Delete the GPL v2 clause and accompany it with the APACHE20 file
+ * In all cases you must keep the copyright notice intact and include a copy
+ * of the CONTRIB file.
+ *
+ * Binary distributions must follow the binary distribution requirements of
+ * either License.
+ */
+#include <errno.h>
+#include <error.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h> /* atexit */
+#include <unistd.h> /* dup2 */
+
+#include <libfreenect/libfreenect.h>
+#include <libusb-1.0/libusb.h>
+
+#include <jpeglib.h>
+
+#include "util.h"
+
+FILE *depth_stream = NULL;
+FILE *video_stream = NULL;
+FILE *accel_stream = NULL;
+freenect_context *ctx;
+
+struct jpeg_error_mgr jpeg_encoder_err;
+struct jpeg_compress_struct jpeg_encoder;
+unsigned char *jpeg_encoder_buf;
+unsigned long jpeg_encoder_len;
+
+void jpeg_init() {
+	jpeg_encoder.err = jpeg_std_error(&jpeg_encoder_err);
+	jpeg_create_compress(&jpeg_encoder);
+	jpeg_encoder.image_width = 640;
+	jpeg_encoder.image_height = 480;
+	jpeg_encoder.input_components = 3;
+	jpeg_encoder.in_color_space = JCS_RGB;
+	jpeg_set_defaults(&jpeg_encoder);
+	jpeg_mem_dest(&jpeg_encoder, &jpeg_encoder_buf, &jpeg_encoder_len);
+}
+
+void write_imageframe(FILE *stream, JSAMPLE *data) {
+	JSAMPLE *row_pointers[480];
+	for (size_t i = 0; i < 480; i++)
+		row_pointers[i] = &data[i*640*3];
+
+	jpeg_start_compress(&jpeg_encoder, TRUE);
+	while (jpeg_encoder.next_scanline < jpeg_encoder.image_height)
+		jpeg_write_scanlines(&jpeg_encoder, &row_pointers[jpeg_encoder.next_scanline], 480-jpeg_encoder.next_scanline);
+	jpeg_finish_compress(&jpeg_encoder);
+
+	if (fprintf(stream,
+	            "--ffserver\r\n"
+	            "Content-type: image/jpeg\r\n"
+	            "Content-length: %lu\r\n"
+	            "\r\n",
+	            jpeg_encoder_len) < 1)
+		error(EXIT_FAILURE, ferror(stream), "writing header");
+	if (fwrite(jpeg_encoder_buf, jpeg_encoder_len, 1, stream) < 1)
+		error(EXIT_FAILURE, ferror(stream), "writing body");
+	if (fwrite("\r\n", 2, 1, stream) < 1)
+		error(EXIT_FAILURE, ferror(stream), "writing footer");
+	fflush(stream);
+}
+
+void handle_accel(freenect_device *dev UNUSED, freenect_raw_tilt_state* data) {
+	double x, y, z, angle;
+	freenect_get_mks_accel(data, &x, &y, &z);
+	angle = freenect_get_tilt_degs(data);
+
+	const char *motor;
+	switch (data->tilt_status) {
+	case TILT_STATUS_STOPPED:
+		motor = "stopped";
+		break;
+	case TILT_STATUS_LIMIT:
+		motor = "limit";
+		break;
+	case TILT_STATUS_MOVING:
+		motor = "moving";
+		break;
+	default:
+		motor = "unknown";
+	}
+
+	char *json = NULL;
+	int len = asprintf(&json,
+	                 "{	\"x\": %f,\n"
+	                 "	\"y\": %f,\n"
+	                 "	\"z\": %f,\n"
+	                 "	\"angle\": %f,\n"
+	                 "	\"motor\": \"%s\" }\n",
+	                 x, y, z, angle, motor);
+	if (len < 0)
+		error(EXIT_FAILURE, errno, "asprintf");
+	fprintf(accel_stream,
+	        "--ffserver\r\n"
+	        "Content-type: application/json\r\n"
+	        "Content-length: %d\r\n"
+	        "\r\n"
+	        "%s\r\n",
+	        len, json);
+	fflush(accel_stream);
+}
+
+uint8_t depth_rgb[640*480*3];
+void handle_depth(freenect_device *dev, void *depth, uint32_t timestamp UNUSED) {
+	uint32_t size = freenect_get_current_depth_mode(dev).bytes;
+	if (size != 640*480*2)
+		error(EXIT_FAILURE, 0, "handle_depth: expected 640*480*2 byte frame, but got %"PRId32, size);
+	/* scale the 11-bit values into 8-bit values */
+	uint16_t *depth_grey = depth;
+	for (size_t i = 0; i < 640*480; i++)
+		depth_rgb[i*3+0] = depth_rgb[i*3+1] = depth_rgb[i*3+2] = (uint8_t)(depth_grey[i]*8.0/11.0);
+	/* write the image */
+	write_imageframe(depth_stream, depth_rgb);
+}
+
+void handle_video(freenect_device *dev, void *rgb, uint32_t timestamp UNUSED) {
+	uint32_t size = freenect_get_current_video_mode(dev).bytes;
+	if (size != 640*480*3)
+		error(EXIT_FAILURE, 0, "handle_video: expected 640*480*3 byte frame, but got %"PRId32, size);
+	/* write the image */
+	write_imageframe(video_stream, rgb);
+}
+
+void print_mode(const char *name, freenect_frame_mode mode) {
+	/* This is just a courtesy function to let the user know the mode
+	   if it becomes a bother for maintainability just comment out the
+	   code in its body.  It will only break if struct entries go missing.
+	*/
+	printf("%s Mode: {%d, %d, {%d}, %d, %d, %d, %d, %d, %d, %d}\n", name,
+	       mode.reserved, (int)mode.resolution, (int)mode.video_format, mode.bytes, mode.width,
+	       mode.height, mode.data_bits_per_pixel, mode.padding_bits_per_pixel,
+	       mode.framerate, mode.is_valid);
+}
+
+void cleanup() {
+	log("STOPPING=1");
+	if (ctx)
+		freenect_shutdown(ctx);
+	if (video_stream)
+		fclose(video_stream);
+	if (depth_stream)
+		fclose(depth_stream);
+	if (accel_stream)
+		fclose(accel_stream);
+	fflush(stderr);
+	sleep(5); /* work around systemd bug dropping log messages */
+}
+
+FILE *xfopen(const char *path, const char *mode) {
+	FILE *stream = fopen(path, mode);
+	if (stream == NULL)
+		error(EXIT_FAILURE, errno, "fopen: %s", path);
+	return stream;
+}
+
+FILE *xfdopen(const char *path, const char *mode) {
+	int fd = get_fd(path);
+	if (fd < 0)
+		error(EXIT_FAILURE, -fd, "get_fd: %s", path);
+	FILE *stream = fdopen(fd, mode);
+	if (stream == NULL)
+		error(EXIT_FAILURE, errno, "fdopen: %s (%d)", path, fd);
+	return stream;
+}
+
+void usage() {
+	printf("Usage: %s [-h] [-v video.mjpg|-V video_fd] [-d depth.mjpg|-D depth_fd] [-a accel.mjson|-A accel_fd]\n", program_invocation_name);
+}
+
+int main(int argc, char *argv[]) {
+	int res = 0;
+	freenect_device *dev;
+
+	atexit(cleanup);
+
+	for (int i = 1; i < argc; i++) {
+		if (argv[i][0] == '-' && argv[i][1] != '\0' && argv[i][2] == '\0') {
+			switch (argv[i][1]) {
+			case 'h':
+				usage();
+				return EXIT_SUCCESS;
+			case 'v':
+				i++;
+				video_stream = xfopen(argv[i], "w");
+				break;
+			case 'd':
+				i++;
+				depth_stream = xfopen(argv[i], "w");
+				break;
+			case 'a':
+				i++;
+				accel_stream = xfopen(argv[i], "w");
+				break;
+			case 'V':
+				i++;
+				video_stream = xfdopen(argv[i], "w");
+				break;
+			case 'D':
+				i++;
+				depth_stream = xfdopen(argv[i], "w");
+				break;
+			case 'A':
+				i++;
+				accel_stream = xfdopen(argv[i], "w");
+				break;
+			default:
+				dup2(2, 1);
+				usage();
+				return EXIT_FAILURE;
+			}
+		} else {
+			dup2(2, 1);
+			usage();
+			return EXIT_FAILURE;
+		}
+	}
+	if (!(video_stream || depth_stream || accel_stream)) {
+		dup2(2, 1);
+		usage();
+		return EXIT_FAILURE;
+	}
+
+	jpeg_init();
+
+	res = freenect_init(&ctx, 0);
+	if (res) {
+		error(EXIT_FAILURE, 0, "freenect_init: %s", libusb_strerror(res));
+	}
+
+	freenect_device_flags devices = 0;
+	if (video_stream || depth_stream)
+		devices |= FREENECT_DEVICE_CAMERA;
+	if (accel_stream)
+		devices |= FREENECT_DEVICE_MOTOR;
+
+	freenect_select_subdevices(ctx, devices);
+	if ((res = freenect_open_device(ctx, &dev, 0))) {
+		error(EXIT_FAILURE, 0, "freenect_open_device: %s", libusb_strerror(res));
+	}
+
+	if (video_stream) {
+		print_mode("Video", freenect_find_video_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_VIDEO_RGB));
+		freenect_set_video_mode(dev, freenect_find_video_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_VIDEO_RGB));
+		freenect_start_video(dev);
+		freenect_set_video_callback(dev, handle_video);
+	}
+
+	if (depth_stream) {
+		print_mode("Depth", freenect_find_depth_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_DEPTH_11BIT));
+		freenect_set_depth_mode(dev, freenect_find_depth_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_DEPTH_11BIT));
+		freenect_start_depth(dev);
+		freenect_set_depth_callback(dev, handle_depth);
+	}
+
+	while (freenect_process_events(ctx) >= 0) {
+		if (accel_stream) {
+			freenect_raw_tilt_state* state;
+			freenect_update_tilt_state(dev);
+			state = freenect_get_tilt_state(dev);
+			handle_accel(dev, state);
+		}
+	}
+
+	freenect_stop_depth(dev);
+	freenect_stop_video(dev);
+	freenect_close_device(dev);
+}
diff --git a/src/multipart-replace-http-server.c b/src/multipart-replace-http-server.c
new file mode 100644
index 0000000..726714f
--- /dev/null
+++ b/src/multipart-replace-http-server.c
@@ -0,0 +1,367 @@
+/* Copyright 2016 Luke Shumaker */
+
+#include <errno.h>
+#include <error.h>
+#include <fcntl.h> /* for open */
+#include <netdb.h> /* for {get,free}addrinfo() */
+#include <stdio.h>
+#include <stdlib.h> /* atexit */
+#include <stdlib.h> /* for EXIT_FAILURE */
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h> /* for open */
+#include <sys/un.h>
+#include <unistd.h>
+
+#include "util.h"
+#include "wg.h"
+#include "multipart-replace.h"
+
+struct httpfile {
+	char name[256];
+	struct multipart_replace_stream *stream;
+};
+
+size_t filec = 0;
+struct httpfile *filev = NULL;
+
+struct reader_thread_args {
+	struct multipart_replace_stream *stream;
+	int fd;
+	const char *filename;
+	const char *boundary;
+};
+
+
+bool running = true;
+int sock;
+struct wg wg;
+
+void stop(int sig) {
+	log("Caught %d", sig);
+	log("STOPPING=1");
+	running = false;
+	close(sock);
+}
+
+#define threaderror(stat, errnum, ...) do { error(0, errnum, __VA_ARGS__); stop(0); } while(0)
+
+void *reader_thread(void *args_anon) {
+	struct reader_thread_args *args = args_anon;
+
+	char *name = alloca(strlen("read ")+strlen(args->filename)+1);
+	strcpy(name, "read ");
+	strcpy(&name[strlen("read ")], args->filename);
+	pthread_setname_np(pthread_self(), name);
+	debug("starting thread: %s", name);
+
+	multipart_replace_reader(args->stream, args->fd, args->boundary);
+	sleep(5);
+	threaderror(EXIT_FAILURE, 0, "multipart_replace stream ended: %s", args->filename);
+	wg_sub(&wg, 1);
+	return NULL;
+}
+
+void start_multipart_replace_reader(struct multipart_replace_stream *s, int fd, const char *filename, const char *boundary) {
+	struct reader_thread_args *args = xrealloc(NULL, sizeof(struct reader_thread_args));
+	args->stream = s;
+	args->fd = fd;
+	args->filename = strdup(filename);
+	args->boundary = boundary;
+	pthread_t thread;
+	wg_add(&wg, 1);
+	pthread_create(&thread, NULL, reader_thread, args);
+}
+
+void file_add(const char *filename) {
+	struct multipart_replace_stream *stream = xrealloc(NULL, sizeof(struct multipart_replace_stream));
+	init_multipart_replace_stream(stream);
+	int fd = open(filename, O_RDONLY);
+	if (fd < 0) {
+		threaderror(EXIT_FAILURE, errno, "opening file: %s", filename);
+		return;
+	}
+	filev = xrealloc(filev, (++filec)*sizeof(*filev));
+	char *shortname = strrchr(filename, '/');
+	if (shortname == NULL) {
+		shortname = alloca(strlen(filename)+2);
+		shortname[0] = '/';
+		strcpy(&shortname[1], filename);
+	}
+	strncpy(filev[filec-1].name, shortname, sizeof(filev[filec-1].name));
+	log("added file #%zd: %s", filec-1, filev[filec-1].name);
+	filev[filec-1].stream = stream;
+	start_multipart_replace_reader(stream, fd, filev[filec-1].name, "ffserver" /* FIXME */);
+}
+
+struct multipart_replace_stream *file_get(const char *filename) {
+	for (size_t i = 0; i < filec; i++) {
+		if (strncmp(filename, filev[i].name, sizeof(filev[i].name)) == 0) {
+			return filev[i].stream;
+		}
+	}
+	return NULL;
+}
+
+void connection_handler(int fd) {
+	FILE *netstream = fdopen(fd, "r");
+	char *line_buf = NULL;
+	size_t line_cap = 0;
+	ssize_t line_len = 0;
+
+	line_len = getline(&line_buf, &line_cap, netstream);
+	/* expect line to be "GET /path.mjpg HTTP/1.1" */
+	if (strncmp(line_buf, "GET ", 4) != 0) {
+		dprintf(fd,
+		        "HTTP/1.1 405 Method Not Allowed\r\n"
+		        "Allow: GET\r\n"
+		        "\r\n");
+		close(fd);
+		return;
+	}
+	char *version = &line_buf[4];
+	char *path = strsep(&version, " ");
+	if (strcmp(version, "HTTP/1.1\r\n") != 0 && strcmp(version, "HTTP/1.0\r\n")) {
+		close(fd);
+		return;
+	}
+	path = strdupa(path);
+
+	/* run through the rest of the headers */
+	while (strcmp(line_buf, "\r\n") != 0 && line_len >= 0)
+		line_len = getline(&line_buf, &line_cap, netstream);
+
+	if (strcmp(path, "/") == 0) {
+		log("200 %s", path);
+		dprintf(fd,
+		        "HTTP/1.1 200 OK\r\n"
+		        "Content-Type: text/html; charset=utf-8\r\n"
+		        "\r\n"
+		        "<!DOCTYPE html>\n"
+		        "<html>\n"
+		        "<head>\n"
+		        "  <title>multipart/x-mixed-replace HTTP server</title>\n"
+		        "</head>\n"
+		        "<body>\n"
+		        "  <ul>\n"
+		        );
+		for (size_t i = 0; i < filec; i++)
+			dprintf(fd, "    <li><a href=\"%s\">%s</a></li>\n", filev[i].name, filev[i].name);
+		dprintf(fd,
+		        "  </ul>\n"
+		        "</body>\n"
+		        "</html>\n");
+		close(fd);
+		return;
+	}
+	struct multipart_replace_stream *vidstream = file_get(path);
+	if (vidstream == NULL) {
+		log("404 %s", path);
+		dprintf(fd,
+		        "HTTP/1.1 404 Not Found\r\n"
+		        "\r\n");
+		return;
+	}
+
+	const char *boundary = "boundary" /* FIXME */;
+	log("200 %s", path);
+	dprintf(fd,
+	        "HTTP/1.1 200 OK\r\n"
+	        "Content-Type: multipart/x-mixed-replace;boundary=%s\r\n"
+	        "\r\n",
+	        boundary);
+	multipart_replace_writer(vidstream, fd, boundary);
+	close(fd);
+}
+
+void *connection_thread(void *arg_anon) {
+	pthread_setname_np(pthread_self(), "connection");
+	int fd = (int)(intptr_t)arg_anon;
+	log("Connection %d opened", fd);
+	connection_handler(fd);
+	log("Connection %d closed", fd);
+	wg_sub(&wg, 1);
+	return NULL;
+}
+
+
+/* same error codes values as -getaddrinfo(); */
+int sockstream_listen(const char *type, const char *addr) {
+	int sock;
+	if (strcmp(type, "fd") == 0) {
+		sock = get_fd(addr);
+		if (sock < 0) {
+			errno = -sock;
+			return -EAI_SYSTEM;
+		}
+		/* make sure it's a socket */
+		struct stat st;
+		if (fstat(sock, &st) < 0)
+			return -EAI_SYSTEM;
+		if (!S_ISSOCK(st.st_mode)) {
+			errno = ENOTSOCK;
+			return -EAI_SYSTEM;
+		}
+		/* make sure the socket is a stream */
+		int fd_socktype = 0;
+		socklen_t l = sizeof(fd_socktype);
+		if (getsockopt(sock, SOL_SOCKET, SO_TYPE, &fd_socktype, &l) < 0)
+			return -EAI_SYSTEM;
+		if (l != sizeof(fd_socktype)) {
+			errno = EINVAL;
+			return -EAI_SYSTEM;
+		}
+		if (fd_socktype != SOCK_STREAM) {
+			errno = ENOSTR;
+			return -EAI_SYSTEM;
+		}
+		/* make sure the socket is listening */
+		int fd_listening = 0;
+		l = sizeof(fd_listening);
+		if (getsockopt(sock, SOL_SOCKET, SO_ACCEPTCONN, &fd_listening, &l) < 0)
+			return -EAI_SYSTEM;
+		if (l != sizeof(fd_listening)) {
+			errno = EINVAL;
+			return -EAI_SYSTEM;
+		}
+		if (!fd_listening)
+			listen(sock, SOMAXCONN);
+		/* return the socket */
+		return sock;
+	} else if (strcmp(type, "unix") == 0) {
+		struct sockaddr_un un_addr = { 0 };
+		if (strlen(addr)+1 > sizeof(un_addr.sun_path)) {
+			errno = ENAMETOOLONG;
+			return -EAI_SYSTEM;
+		}
+		un_addr.sun_family = AF_UNIX;
+		strcpy(un_addr.sun_path, addr);
+		int sock = socket(AF_UNIX, SOCK_STREAM, 0);
+		if (sock < 0)
+			return -EAI_SYSTEM;
+		unlink(addr);
+		if (bind(sock, (struct sockaddr *)&un_addr, sizeof(un_addr)) < 0)
+			return -EAI_SYSTEM;
+		if (listen(sock, SOMAXCONN) < 0)
+			return -EAI_SYSTEM;
+		return sock;
+	} else if (strcmp(type, "tcp4") == 0 || strcmp(type, "tcp6") == 0) {
+		struct addrinfo *ai_addr = NULL;
+		struct addrinfo ai_hints = { 0 };
+
+		char *host = strdupa(addr);
+		char *col = strrchr(host, ':');
+		if (col == NULL) {
+			errno = EINVAL;
+			return -EAI_SYSTEM;
+		}
+		char *port = &col[1];
+		*col = '\0';
+		if (host[0] == '\0')
+			host = NULL;
+
+		ai_hints.ai_family = (strcmp(type, "tcp6") == 0) ? AF_INET6 : AF_INET;
+		ai_hints.ai_socktype = SOCK_STREAM;
+		ai_hints.ai_flags = AI_PASSIVE;
+
+		int r = getaddrinfo(host, port, &ai_hints, &ai_addr);
+		if (r < 0)
+			return r;
+		if (r > 0)
+			return -r;
+
+		int sock = socket(ai_addr->ai_family, ai_addr->ai_socktype, ai_addr->ai_protocol);
+		if (sock < 0)
+			return -EAI_SYSTEM;
+
+		int yes = 1;
+		setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
+
+		if (bind(sock, ai_addr->ai_addr, ai_addr->ai_addrlen) < 0)
+			return -EAI_SYSTEM;
+
+		if (listen(sock, SOMAXCONN) < 0)
+			return -EAI_SYSTEM;
+
+		freeaddrinfo(ai_addr);
+		return sock;
+	} else {
+		errno = EINVAL;
+		return -EAI_SYSTEM;
+	}
+}
+
+void usage() {
+	printf("Usage: %s [-h] ADDRTYPE ADDR [FILENAME...]\n", program_invocation_name);
+	printf("Multiplex several multipart/x-mixed-replace streams over HTTP.\n"
+	       "\n"
+	       "ADDRTYPE is \"tcp4\", \"tcp6\", \"fd\", or \"unix\".  For tcp4/6, ADDR\n"
+	       "is a socket address in standard notation.  For fd, ADDR is \"stdin\",\n"
+	       "\"stdout\", \"stder\", \"systemd\", or an unsigned integer.  For unix,\n"
+	       "ADDR is a file path.\n"
+	       "\n"
+	       "The leading directories of the FILENAMEs are stripped; they are served\n"
+	       "at just the base filename.  As common sense should eventually suggest,\n"
+	       "the FILENAMEs should be pipes or sockets.\n");
+}
+
+void cleanup() {
+	fflush(stderr);
+	sleep(5); /* work around systemd bug dropping log messages */
+}
+
+pthread_t main_thread;
+
+void progname() {
+	char threadname[16];
+	if (pthread_self() != main_thread && pthread_getname_np(pthread_self(), threadname, sizeof(threadname)) == 0)
+		fprintf(stderr, "%s:%s: ", program_invocation_name, threadname);
+	else
+		fprintf(stderr, "%s: ", program_invocation_name);
+}
+
+int main(int argc, char *argv[]) {
+	if (argc >=2 && strcmp(argv[1], "-h") == 0) {
+		usage();
+		return EXIT_SUCCESS;
+	}
+	if (argc < 3) {
+		dup2(2, 1);
+		usage();
+		return EXIT_FAILURE;
+	}
+
+	main_thread = pthread_self();
+	error_print_progname = progname;
+	atexit(cleanup);
+
+	sock = sockstream_listen(argv[1], argv[2]);
+	if (sock < 0) {
+		if (sock == -EAI_SYSTEM)
+			error(EXIT_FAILURE, errno, "Opening socket %s %s", argv[1], argv[2]);
+		else
+			error(EXIT_FAILURE, 0, "Opening socket %s %s: %s", argv[1], argv[2], gai_strerror(-sock));
+	}
+
+	wg_init(&wg);
+	for (int i = 3; i < argc; i++)
+		file_add(argv[i]);
+
+	signal(SIGPIPE, SIG_IGN);
+	signal(SIGTERM, stop);
+	signal(SIGQUIT, stop);
+	signal(SIGINT, stop);
+	while (running) {
+		int conn = accept(sock, NULL, NULL);
+		if (conn < 0)
+			continue;
+		pthread_t thread;
+		wg_add(&wg, 1);
+		pthread_create(&thread, NULL, connection_thread, (void*)(intptr_t)conn);
+	}
+	wg_wait(&wg);
+	for (size_t i = 0; i < filec; i++)
+		destroy_multipart_replace_stream(filev[i].stream);
+	free(filev);
+	return 0;
+}
diff --git a/src/multipart-replace.c b/src/multipart-replace.c
new file mode 100644
index 0000000..9a5e268
--- /dev/null
+++ b/src/multipart-replace.c
@@ -0,0 +1,168 @@
+/* Copyright 2016 Luke Shumaker */
+
+#include <errno.h>
+#include <error.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "multipart-replace.h"
+#include "util.h"
+
+#define error(stat, errnum, ...) do { error(0, errnum, __VA_ARGS__); goto end; } while(0)
+
+static
+char *boundary_line(const char *old) {
+	size_t len = strlen(old);
+	char *new = xrealloc(NULL, len+5);
+	new[0] = '-';
+	new[1] = '-';
+	strcpy(&new[2], old);
+	new[2+len+0] = '\r';
+	new[2+len+1] = '\n';
+	new[2+len+2] = '\0';
+	return new;
+}
+
+static
+ssize_t safe_atoi(char *str) {
+	while (*str == ' ')
+		str++;
+	size_t len = 0;
+	while ('0' <= str[len] && str[len] <= '9')
+		len++;
+	size_t i = len;
+	while (str[i] == ' ')
+		i++;
+	if (len < 1 || strcmp(&str[i], "\r\n") != 0)
+		return -1;
+	return atoi(str);
+}
+
+void multipart_replace_reader(struct multipart_replace_stream *s, int fd, const char *_boundary) {
+	FILE *stream = fdopen(fd, "r");
+	char *boundary = boundary_line(_boundary);
+
+	char *line_buf = NULL;
+	size_t line_cap = 0;
+	ssize_t line_len = 0;
+	ssize_t content_length = -1;
+
+	bool first = true;
+	while (running) {
+		content_length = -1;
+		/* scan for the first non-empty line */
+		do {
+			line_len = getline(&line_buf, &line_cap, stream);
+			if (line_len < 0)
+				error(EXIT_FAILURE, ferror(stream), "source hung up");
+		} while (strcmp(line_buf, "\r\n") == 0);
+		/* make sure it matches the boundary separator */
+		if (first) {
+			while (strcmp(line_buf, boundary) != 0) {
+				line_len = getline(&line_buf, &line_cap, stream);
+				if (line_len < 0)
+					error(EXIT_FAILURE, ferror(stream), "source hung up");
+			}
+			first = false;
+		} else {
+			if (strcmp(line_buf, boundary) != 0)
+				error(EXIT_FAILURE, 0, "line does not match boundary: \"%s\"", line_buf);
+		}
+		/* read the frame header (MIME headers) */
+		s->back->len = 0;
+		do {
+			line_len = getline(&line_buf, &line_cap, stream);
+			if (line_len < 0)
+				error(EXIT_FAILURE, ferror(stream), "source hung up");
+			/* append the line to the frame contents */
+			if ((ssize_t)s->back->cap < s->back->len + line_len)
+				s->back->buf = xrealloc(s->back->buf, s->back->cap = s->back->len + line_len);
+			memcpy(&s->back->buf[s->back->len], line_buf, line_len);
+			s->back->len += line_len;
+			/* parse the Content-length (if applicable) */
+			if (strncasecmp(line_buf, "Content-length:", strlen("Content-length:")) == 0) {
+				content_length = safe_atoi(&line_buf[strlen("Content-length:")]);
+			}
+		} while (strcmp(line_buf, "\r\n") != 0);
+		/* make sure that it included a Content-length header */
+		if (content_length < 0)
+			error(EXIT_FAILURE, 0, "did not get frame length");
+		/* read the frame contents */
+		if ((ssize_t)s->back->cap < s->back->len + content_length)
+			s->back->buf = xrealloc(s->back->buf, s->back->cap = s->back->len + content_length);
+		if (fread(&s->back->buf[s->back->len], content_length, 1, stream) != 1)
+			error(EXIT_FALURE, ferror(stream), "fread(%zd)", s->back->len);
+		s->back->len += content_length;
+
+		/* swap the frames */
+		pthread_rwlock_wrlock(&s->frontlock);
+		struct frame *tmp = s->front;
+		s->front = s->back;
+		s->back = tmp;
+		s->framecount++;
+		pthread_rwlock_unlock(&s->frontlock);
+	}
+ end:
+	free(boundary);
+	fclose(stream);
+}
+
+void multipart_replace_writer(struct multipart_replace_stream *s, int fd, const char *_boundary) {
+	FILE *stream = fdopen(fd, "w");
+	struct frame myframe = { 0 };
+	long lastframe = 0;
+	char *boundary = boundary_line(_boundary);
+	size_t boundary_len = strlen(boundary);
+
+	pthread_rwlock_rdlock(&s->frontlock);
+	while (running) {
+		/* get the most recent frame (copy `s->front` to `myframe`) */
+		if (myframe.cap < (size_t)s->front->len)
+			myframe.buf = xrealloc(myframe.buf, myframe.cap = s->front->len);
+		memcpy(myframe.buf, s->front->buf, myframe.len = s->front->len);
+		lastframe = s->framecount;
+
+		pthread_rwlock_unlock(&s->frontlock);
+
+		/* send the frame to the client */
+		if (fwrite(boundary, boundary_len, 1, stream) < 1)
+			error(EXIT_FAILURE, ferror(stream), "fwrite(boundary)");
+		if (fwrite(myframe.buf, myframe.len, 1, stream) < 1)
+			error(EXIT_FAILURE, ferror(stream), "fwrite(frame.buf)");
+		/* send a blank line for pleasantness */
+		if (fwrite("\r\n", 2, 1, stream) < 1)
+			error(EXIT_FAILURE, ferror(stream), "fwrite(\"\\r\\n\")");
+		fflush(stream);
+
+		/* poll until there's a new frame */
+		pthread_rwlock_rdlock(&s->frontlock);
+		while (s->framecount == lastframe && running) {
+			pthread_rwlock_unlock(&s->frontlock);
+			usleep(30000); /* a bit over 30 FPS */
+			pthread_rwlock_rdlock(&s->frontlock);
+		}
+	}
+	pthread_rwlock_unlock(&s->frontlock);
+ end:
+	free(boundary);
+	free(myframe.buf);
+	fclose(stream);
+}
+
+void init_multipart_replace_stream(struct multipart_replace_stream *s) {
+	ZERO(s->a);
+	ZERO(s->b);
+	s->front = &s->a;
+	s->back = &s->b;
+	pthread_rwlock_init(&s->frontlock, NULL);
+	s->framecount = 0;
+}
+
+void destroy_multipart_replace_stream(struct multipart_replace_stream *s) {
+	free(s->a.buf);
+	free(s->b.buf);
+	pthread_rwlock_destroy(&s->frontlock);
+}
diff --git a/src/multipart-replace.h b/src/multipart-replace.h
new file mode 100644
index 0000000..2aa5e61
--- /dev/null
+++ b/src/multipart-replace.h
@@ -0,0 +1,26 @@
+/* Copyright 2016 Luke Shumaker */
+
+#pragma once
+
+#include <pthread.h>
+#include <stdbool.h>
+
+struct frame {
+	ssize_t len;
+	size_t cap;
+	char *buf;
+};
+
+struct multipart_replace_stream {
+	struct frame a, b;
+	struct frame *front, *back;
+	pthread_rwlock_t frontlock;
+	long framecount;
+};
+
+void multipart_replace_reader(struct multipart_replace_stream *s, int fd, const char *boundary);
+void multipart_replace_writer(struct multipart_replace_stream *s, int fd, const char *boundary);
+void init_multipart_replace_stream(struct multipart_replace_stream *s);
+void destroy_multipart_replace_stream(struct multipart_replace_stream *s);
+
+extern bool running;
diff --git a/src/util.c b/src/util.c
new file mode 100644
index 0000000..772dbf8
--- /dev/null
+++ b/src/util.c
@@ -0,0 +1,72 @@
+/* Copyright 2016 Luke Shumaker */
+
+#include <ctype.h> /* for isdigit */
+#include <stdlib.h>
+#include <error.h>
+#include <errno.h>
+
+#include "util.h"
+
+void *xrealloc(void *ptr, size_t size)
+{
+	void *ret = realloc(ptr, size);
+	if (ret == NULL) {
+		if (ptr==NULL)
+			error(1, errno, "Could not allocate memory");
+		else
+			error(1, errno, "Could not re-allocate memory");
+	}
+	return ret;
+}
+
+bool is_numeric(const char *str) {
+	for (size_t i = 0; str[i] != '\0'; i++)
+		if (!isdigit(str[i]))
+			return false;
+	if (str[0] == '\0')
+		return false;
+	return true;
+}	
+
+int get_fd(const char *addr) {
+	int sock;
+	if (strcmp(addr, "stdin") == 0) {
+		sock = 0;
+	} else if (strcmp(addr, "stdout") == 0) {
+		sock = 1;
+	} else if (strcmp(addr, "stderr") == 0) {
+		sock = 2;
+	} else if (strncmp(addr, "systemd", strlen("systemd")) == 0) {
+		sock = 3; /* <systemd/sd-daemon.h>:SD_LISTEN_FDS_START */
+		addr = &addr[strlen("systemd")];
+		switch (addr[0]) {
+		case '\0':
+			/* do nothing */
+			break;
+		case ':':
+			addr = &addr[1];
+			if (is_numeric(addr)) {
+				sock += atoi(addr);
+			} else {
+				const char *e = getenv("LISTEN_FDNAMES");
+				if (e == NULL)
+					return -ENOTCONN;
+				char *names = strdupa(e);
+				char *name = NULL;
+				int i = -1;
+				do {
+					name = strsep(&names, ":");
+					i++;
+				} while (name != NULL && strcmp(name, addr) != 0);
+				if (name == NULL)
+					return -ENOENT;
+				sock += i;
+			}
+		}
+	} else {
+		if (!is_numeric(addr))
+			return -EINVAL;
+		sock = atoi(addr);
+	}
+	return sock;
+}
diff --git a/src/util.h b/src/util.h
new file mode 100644
index 0000000..0432a57
--- /dev/null
+++ b/src/util.h
@@ -0,0 +1,21 @@
+/* Copyright 2016 Luke Shumaker */
+
+#pragma once
+
+#include <signal.h> /* for sig_atomic_t */
+#include <string.h> /* for memset(3) */
+#include <stdbool.h>
+
+#define UNUSED __attribute__((__unused__))
+#define ZERO(x) memset(&(x), 0, sizeof(x))
+
+#ifndef _
+#define _(str) str
+#endif
+
+#define log(...) error(0, 0, __VA_ARGS__)
+#define debug(...) error(0, 0, __VA_ARGS__)
+
+void *xrealloc(void *ptr, size_t size);
+bool is_numeric(const char *str);
+int get_fd(const char *addr);
diff --git a/src/wg.c b/src/wg.c
new file mode 100644
index 0000000..4f60765
--- /dev/null
+++ b/src/wg.c
@@ -0,0 +1,45 @@
+#include <errno.h>
+#include <error.h>
+#include <stdlib.h> /* for EXIT_FAILURE */
+#include <unistd.h>
+
+#include "wg.h"
+
+/* Thread management tools modeled on https://golang.org/pkg/sync/#WaitGroup */
+
+/* pthread_cond_t is overly complicated. Just use a self-pipe. */
+
+void wg_init(struct wg *wg) {
+	wg->count = 0;
+	pthread_mutex_init(&wg->lock, NULL);
+	int fds[2];
+	if (pipe(fds) != 0)
+		error(EXIT_FAILURE, errno, "pipe");
+	wg->fd_wait = fds[0];
+	wg->fd_signal = fds[1];
+}
+
+void wg_add(struct wg *wg, unsigned int n) {
+	pthread_mutex_lock(&wg->lock);
+	wg->count += n;
+	pthread_mutex_unlock(&wg->lock);
+}
+
+void wg_sub(struct wg *wg, unsigned int n) {
+	pthread_mutex_lock(&wg->lock);
+	wg->count -= n;
+	if (wg->count == 0)
+		if (write(wg->fd_signal, " ", 1) < 1)
+			error(EXIT_FAILURE, errno, "write");
+	pthread_mutex_unlock(&wg->lock);
+}
+
+void wg_wait(struct wg *wg) {
+	char b;
+ retry:
+	if (read(wg->fd_wait, &b, 1) == -1) {
+		if (errno == EINTR)
+			goto retry;
+		error(EXIT_FAILURE, errno, "wg_wait");
+	}
+}
diff --git a/src/wg.h b/src/wg.h
new file mode 100644
index 0000000..777e8a3
--- /dev/null
+++ b/src/wg.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <pthread.h>
+
+/* Thread management tools modeled on https://golang.org/pkg/sync/#WaitGroup */
+
+/* pthread_cond_t is overly complicated. Just use a self-pipe. */
+
+struct wg {
+	int count;
+	pthread_mutex_t lock;
+	int fd_wait;
+	int fd_signal;
+};
+
+void wg_init(struct wg *);
+void wg_add(struct wg *, unsigned int);
+void wg_sub(struct wg *, unsigned int);
+void wg_wait(struct wg*);