(WIP) Handle errors and timeouts in whois.enneract/wip

2 files changed, 123 insertions, 39 deletions

diff --git a/src/lists.c b/src/lists.c
index 0a308c0..ea35cea 100644
--- a/src/lists.c
+++ b/src/lists.c
@@ -171,7 +171,7 @@ int lists_test(const char *revdns, const char *whois)
 		    !strstr(revdns, entry->pattern))
 			continue;
 
-		if (entry->type == ENTRY_WHOIS &&
+		if (whois && entry->type == ENTRY_WHOIS &&
 		    !strstr(whois, entry->pattern))
 			continue;
 
diff --git a/src/worker.c b/src/worker.c
index 82d4ce6..7553fb8 100644
--- a/src/worker.c
+++ b/src/worker.c
@@ -18,6 +18,8 @@ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 #include "shared.h"
 #include <netdb.h> // reverse DNS
+#include <sys/types.h>
+#include <sys/wait.h>
 
 static job_t *job_queue;
 static pthread_cond_t job_queue_cond = PTHREAD_COND_INITIALIZER;
@@ -62,47 +64,119 @@ void job_quit(void)
 	pthread_cond_broadcast(&job_queue_cond);
 }
 
-// FIXME: refactor with vstrs
-static int read_everything(FILE *fp, char **buffer)
+// Execute a process and read its stdout.
+//      path: the path to the process.
+//      argv: the argument list. The first arg is usually expected to be the
+//            process's path and the last to be NULL.
+//   timeout: wait for at most this long, kill the process if it takes to long.
+//       out: the output.
+//            NOTE: the caller is supposed to free the returned string
+//            NOTE: it's undefined if this function fails
+static int get_process_output(const char *path, char * const *argv,
+                              const struct timeval *timeout, char **out)
 {
-	size_t read = 0, alloc = 128, partial;
+	int  rv, pipefds[2], status;
+	pid_t child;
+	struct timeval time_left;
+	vstr_t vstr = VSTR_INITIALIZER;
+
+	if (pipe(pipefds) == -1) {
+		perror("pipe");
+		return 1;
+	}
 
-	alloc = 128;
-	*buffer = malloc(alloc);
-	if (!*buffer)
-		goto oom;
+	child = fork();
+	if (child == -1) {
+		close(pipefds[0]);
+		close(pipefds[1]);
+		perror("fork");
+		return 1;
+	}
 
-	while (1) {
-		size_t left = alloc - read;
+	if (child == 0) {
+		close(pipefds[0]);
+		dup2(pipefds[1], STDOUT_FILENO);
+		close(pipefds[1]);
+		if (execv(path, argv) == -1)
+			return 1;
+	}
 
-		if (left == 0) {
-			alloc *= 2;
-			*buffer = realloc(*buffer, alloc);
-			if (!buffer)
-				goto oom;
+	close(pipefds[1]);
 
-			continue;
-		}
+	memcpy(&time_left, timeout, sizeof(struct timeval));
 
-		partial = fread((*buffer) + read, 1, left, fp);
-		if (partial == 0) {
-			if (ferror(fp))
-				return 1;
+	for (;;) {
+		fd_set fds;
+		ssize_t i, r;
+		char buffer[1024];
+
+		FD_ZERO(&fds);
+		FD_SET(pipefds[0], &fds);
+	
+		rv = select(pipefds[0] + 1, &fds, NULL, NULL, &time_left);
+		if (rv == 0) {
+			eprintf("select timed out\n");
+			goto error;
+		} else if (rv == -1) {
+			perror("select");
+			goto error;
+		}
 
+		r = read(pipefds[0], buffer, sizeof(buffer));
+		if (r == 0)
 			break;
+		else if (r == -1) {
+			perror("read");
+			goto error;
 		}
 
-		read += partial;
+		// FIXME: don't do this char-by-char
+		for (i = 0; i < r; i++)
+			if (vstr_putc(&vstr, buffer[i])) {
+				eprintf("get_process_output: out of memory\n");
+				goto error;
+			}
 	}
 
+	if (waitpid(child, &status, 0) == -1) {
+		perror("waitpid");
+		// FIXME: figure out it's safe to ignore waitpid errors.
+		//        I'm not sure if this can leak resources.
+	} else {
+		// FIXME: check the exit code for errors
+		eprintf("subprocess exited with code %i\n", status);
+	}
+
+	close(pipefds[0]);
+
+	if (vstr.size == 0) {
+		*out = strdup("");
+		if (!*out) {
+			eprintf("get_process_output: out of memory\n");
+			return 1;
+		}
+	} else {
+		
+		if (vstr.alloc > vstr.size + 1) {
+			vstr.data = realloc(vstr.data, vstr.size + 1);
+			if (!vstr.data) {
+				eprintf("get_process_output: realloc failed (wtf?)\n");
+				return 1;
+			}
+		}
+
+		vstr.data[vstr.size] = '\0';
+		*out = vstr.data;
+	}
 
-	*buffer = realloc(*buffer, read + 1);
-	(*buffer)[read] = '\0';
 	return 0;
 
-oom:
-	fprintf(stderr, "read_everything: out of memory\n");
-	abort();
+error:
+	vstr_destroy(&vstr);
+	if (kill(child, SIGTERM) == -1)
+		perror("kill");
+	close(pipefds[0]);
+	return 1;
 }
 
 // Check if the database entry is complete (all fields are DB_VALID).
@@ -126,10 +200,17 @@ static void update_entry(db_entry *entry, db_entry_field *field, char *data)
 {
 	pthread_mutex_lock(&entry->mutex);
 
-	field->state = DB_VALID;
 	free(field->data);
-	field->data = data;
-	field->exp_time = get_time() + 24 * TIME_HOUR;
+
+	if (data) {
+		field->state = DB_VALID;
+		field->data = data;
+		field->exp_time = get_time() + 24 * TIME_HOUR;
+	} else {
+		field->state = DB_VALID;
+		field->data = NULL;
+		field->exp_time = get_time() + 30 * TIME_MINUTE;
+	}
 
 	// invalidate the result cache
 	entry->cached_result_valid = false;
@@ -213,18 +294,21 @@ static void worker_job_revdns(job_t *job)
 // This job makes a WHOIS query and stores it in the database.
 static void worker_job_whois(job_t *job)
 {
-	char command[80];
-	FILE *fp;
-	char *out;
+	char *argv[3], iparg[20], *out;
+	struct timeval timeout = {15, 0}; // FIXME: don't hardcode this
 
-	snprintf(command, sizeof(command), "whois \"%hhu.%hhu.%hhu.%hhu\"",
-	         (job->ipv4 >> 24) & 0xFF, (job->ipv4 >> 16) & 0xFF,
+	snprintf(iparg, sizeof(iparg), "%hhu.%hhu.%hhu.%hhu",
+	        (job->ipv4 >> 24) & 0xFF, (job->ipv4 >> 16) & 0xFF,
 	         (job->ipv4 >> 8) & 0xFF, job->ipv4 & 0xFF);
-	DEBUG("%s\n", command);
 
-	fp = popen(command, "r");
-	read_everything(fp, &out); // FIXME: handle errors
-	fclose(fp);
+	argv[0] = "/bin/whois";
+	argv[1] = iparg;
+	argv[2] = NULL;
+
+	if (get_process_output("/bin/whois", argv, &timeout, &out)) {
+		eprintf("whois failed for %s\n", iparg);
+		out = NULL;
+	}
 
 	update_entry(job->entry, &job->entry->whois, out);
 }