switch from tabs to spaces

It was fun while it lasted, but I do believe that spaces are strictly
superior, and clang-format struggles with tabs while using advanced
configuration options.

1 files changed, 123 insertions, 123 deletions

diff --git a/src/tcp_server.c b/src/tcp_server.c
index f5c39fc..cdd5db6 100644
--- a/src/tcp_server.c
+++ b/src/tcp_server.c
@@ -60,161 +60,161 @@
  */
 
 struct client {
-	struct tcp_server* server;
-	int conn_fd;
+    struct tcp_server* server;
+    int conn_fd;
 
-	int cleanup_fd;
+    int cleanup_fd;
 
-	pid_t tid;
-	pthread_t thread;
+    pid_t tid;
+    pthread_t thread;
 
-	SIMPLEQ_ENTRY(client) entries;
+    SIMPLEQ_ENTRY(client) entries;
 };
 
 SIMPLEQ_HEAD(client_queue, client);
 
 struct tcp_server {
-	struct event_loop* loop;
+    struct event_loop* loop;
 
-	tcp_server_conn_handler conn_handler;
-	void* conn_handler_arg;
+    tcp_server_conn_handler conn_handler;
+    void* conn_handler_arg;
 
-	struct client_queue client_queue;
+    struct client_queue client_queue;
 
-	int accept_fd;
+    int accept_fd;
 };
 
 static void client_destroy(struct client* client) {
-	log_debug("Cleaning up client thread %d\n", client->tid);
+    log_debug("Cleaning up client thread %d\n", client->tid);
 
-	SIMPLEQ_REMOVE(&client->server->client_queue, client, client, entries);
-	pthread_errno_if(pthread_join(client->thread, NULL), "pthread_join");
-	file_close(client->cleanup_fd);
-	net_close(client->conn_fd);
-	free(client);
+    SIMPLEQ_REMOVE(&client->server->client_queue, client, client, entries);
+    pthread_errno_if(pthread_join(client->thread, NULL), "pthread_join");
+    file_close(client->cleanup_fd);
+    net_close(client->conn_fd);
+    free(client);
 }
 
 static int client_destroy_handler(UNUSED struct event_loop* loop,
                                   UNUSED int fd,
                                   UNUSED short revents,
                                   void* _client) {
-	struct client* client = (struct client*)_client;
-	log_debug("Client thread %d indicated that it's done\n", client->tid);
+    struct client* client = (struct client*)_client;
+    log_debug("Client thread %d indicated that it's done\n", client->tid);
 
-	client_destroy(client);
-	return 0;
+    client_destroy(client);
+    return 0;
 }
 
 static void* client_thread_func(void* _client) {
-	struct client* client = (struct client*)_client;
-	int ret = 0;
+    struct client* client = (struct client*)_client;
+    int ret = 0;
 
-	client->tid = gettid();
-	log_debug("New client thread thread %d has started\n", client->tid);
+    client->tid = gettid();
+    log_debug("New client thread thread %d has started\n", client->tid);
 
-	/* Let the client thread handle its signals except those that should be
-	 * handled in the main thread. */
-	ret = signal_block_sigterms();
-	if (ret < 0)
-		goto cleanup;
+    /* Let the client thread handle its signals except those that should be
+     * handled in the main thread. */
+    ret = signal_block_sigterms();
+    if (ret < 0)
+        goto cleanup;
 
-	ret = client->server->conn_handler(client->conn_fd, client->server->conn_handler_arg);
-	if (ret < 0)
-		goto cleanup;
+    ret = client->server->conn_handler(client->conn_fd, client->server->conn_handler_arg);
+    if (ret < 0)
+        goto cleanup;
 
 cleanup:
-	log_errno_if(eventfd_write(client->cleanup_fd, 1), "eventfd_write");
+    log_errno_if(eventfd_write(client->cleanup_fd, 1), "eventfd_write");
 
-	return NULL;
+    return NULL;
 }
 
 static int client_create_thread(struct client* client) {
-	sigset_t old_mask;
-	int ret = 0;
+    sigset_t old_mask;
+    int ret = 0;
 
-	/* Block all signals (we'll unblock them later); the client thread will
-	 * have all signals blocked initially. This allows the main thread to
-	 * handle SIGINT/SIGTERM/etc. */
-	ret = signal_block_all(&old_mask);
-	if (ret < 0)
-		return ret;
+    /* Block all signals (we'll unblock them later); the client thread will
+     * have all signals blocked initially. This allows the main thread to
+     * handle SIGINT/SIGTERM/etc. */
+    ret = signal_block_all(&old_mask);
+    if (ret < 0)
+        return ret;
 
-	ret = pthread_create(&client->thread, NULL, client_thread_func, client);
-	if (ret) {
-		pthread_errno(ret, "pthread_create");
-		goto restore_mask;
-	}
+    ret = pthread_create(&client->thread, NULL, client_thread_func, client);
+    if (ret) {
+        pthread_errno(ret, "pthread_create");
+        goto restore_mask;
+    }
 
 restore_mask:
-	/* Restore the previously-enabled signals for handling in the main thread. */
-	signal_set_mask(&old_mask);
+    /* Restore the previously-enabled signals for handling in the main thread. */
+    signal_set_mask(&old_mask);
 
-	return ret;
+    return ret;
 }
 
 static int client_create(struct tcp_server* server, int conn_fd) {
-	int ret = 0;
+    int ret = 0;
 
-	struct client* client = calloc(1, sizeof(struct client));
-	if (!client) {
-		log_errno("calloc");
-		return -1;
-	}
+    struct client* client = calloc(1, sizeof(struct client));
+    if (!client) {
+        log_errno("calloc");
+        return -1;
+    }
 
-	client->server = server;
-	client->conn_fd = conn_fd;
+    client->server = server;
+    client->conn_fd = conn_fd;
 
-	ret = eventfd(0, EFD_CLOEXEC);
-	if (ret < 0) {
-		log_errno("eventfd");
-		goto free;
-	}
-	client->cleanup_fd = ret;
+    ret = eventfd(0, EFD_CLOEXEC);
+    if (ret < 0) {
+        log_errno("eventfd");
+        goto free;
+    }
+    client->cleanup_fd = ret;
 
-	ret = event_loop_add_once(
-	    server->loop, client->cleanup_fd, POLLIN, client_destroy_handler, client);
-	if (ret < 0)
-		goto close_cleanup_fd;
+    ret = event_loop_add_once(
+        server->loop, client->cleanup_fd, POLLIN, client_destroy_handler, client);
+    if (ret < 0)
+        goto close_cleanup_fd;
 
-	SIMPLEQ_INSERT_TAIL(&server->client_queue, client, entries);
+    SIMPLEQ_INSERT_TAIL(&server->client_queue, client, entries);
 
-	ret = client_create_thread(client);
-	if (ret < 0)
-		goto remove_from_client_queue;
+    ret = client_create_thread(client);
+    if (ret < 0)
+        goto remove_from_client_queue;
 
-	return ret;
+    return ret;
 
 remove_from_client_queue:
-	SIMPLEQ_REMOVE(&server->client_queue, client, client, entries);
+    SIMPLEQ_REMOVE(&server->client_queue, client, client, entries);
 
 close_cleanup_fd:
-	file_close(client->cleanup_fd);
+    file_close(client->cleanup_fd);
 
 free:
-	free(client);
+    free(client);
 
-	return ret;
+    return ret;
 }
 
 static void client_queue_create(struct client_queue* client_queue) {
-	SIMPLEQ_INIT(client_queue);
+    SIMPLEQ_INIT(client_queue);
 }
 
 static void client_queue_destroy(struct client_queue* client_queue) {
-	struct client* entry1 = SIMPLEQ_FIRST(client_queue);
-	while (entry1) {
-		struct client* entry2 = SIMPLEQ_NEXT(entry1, entries);
-		client_destroy(entry1);
-		entry1 = entry2;
-	}
+    struct client* entry1 = SIMPLEQ_FIRST(client_queue);
+    while (entry1) {
+        struct client* entry2 = SIMPLEQ_NEXT(entry1, entries);
+        client_destroy(entry1);
+        entry1 = entry2;
+    }
 }
 
 static int tcp_server_accept_handler(UNUSED struct event_loop* loop,
                                      UNUSED int fd,
                                      UNUSED short revents,
                                      void* _server) {
-	struct tcp_server* server = (struct tcp_server*)_server;
-	return tcp_server_accept(server);
+    struct tcp_server* server = (struct tcp_server*)_server;
+    return tcp_server_accept(server);
 }
 
 int tcp_server_create(struct tcp_server** _server,
@@ -222,63 +222,63 @@ int tcp_server_create(struct tcp_server** _server,
                       const char* port,
                       tcp_server_conn_handler conn_handler,
                       void* conn_handler_arg) {
-	int ret = 0;
+    int ret = 0;
 
-	struct tcp_server* server = calloc(1, sizeof(struct tcp_server));
-	if (!server) {
-		log_errno("calloc");
-		return -1;
-	}
+    struct tcp_server* server = calloc(1, sizeof(struct tcp_server));
+    if (!server) {
+        log_errno("calloc");
+        return -1;
+    }
 
-	server->loop = loop;
+    server->loop = loop;
 
-	server->conn_handler = conn_handler;
-	server->conn_handler_arg = conn_handler_arg;
+    server->conn_handler = conn_handler;
+    server->conn_handler_arg = conn_handler_arg;
 
-	client_queue_create(&server->client_queue);
+    client_queue_create(&server->client_queue);
 
-	ret = net_bind(port);
-	if (ret < 0)
-		goto free;
-	server->accept_fd = ret;
+    ret = net_bind(port);
+    if (ret < 0)
+        goto free;
+    server->accept_fd = ret;
 
-	ret = event_loop_add(loop, server->accept_fd, POLLIN, tcp_server_accept_handler, server);
-	if (ret < 0)
-		goto close;
+    ret = event_loop_add(loop, server->accept_fd, POLLIN, tcp_server_accept_handler, server);
+    if (ret < 0)
+        goto close;
 
-	*_server = server;
-	return ret;
+    *_server = server;
+    return ret;
 
 close:
-	net_close(server->accept_fd);
+    net_close(server->accept_fd);
 free:
-	free(server);
+    free(server);
 
-	return ret;
+    return ret;
 }
 
 void tcp_server_destroy(struct tcp_server* server) {
-	net_close(server->accept_fd);
-	client_queue_destroy(&server->client_queue);
-	free(server);
+    net_close(server->accept_fd);
+    client_queue_destroy(&server->client_queue);
+    free(server);
 }
 
 int tcp_server_accept(struct tcp_server* server) {
-	int conn_fd = -1, ret = 0;
+    int conn_fd = -1, ret = 0;
 
-	ret = net_accept(server->accept_fd);
-	if (ret < 0)
-		return ret;
-	conn_fd = ret;
+    ret = net_accept(server->accept_fd);
+    if (ret < 0)
+        return ret;
+    conn_fd = ret;
 
-	ret = client_create(server, conn_fd);
-	if (ret < 0)
-		goto close_conn;
+    ret = client_create(server, conn_fd);
+    if (ret < 0)
+        goto close_conn;
 
-	return ret;
+    return ret;
 
 close_conn:
-	net_close(conn_fd);
+    net_close(conn_fd);
 
-	return ret;
+    return ret;
 }