Make struct cfg global and make the corresponding changes throughout

1 files changed, 40 insertions, 40 deletions

diff --git a/proxy.c b/proxy.c
index 05117fd..28a207d 100644
--- a/proxy.c
+++ b/proxy.c
@@ -118,113 +118,113 @@ proxy_server_free(struct uring_task *task)
 }
 
 void
-proxy_delete(struct cfg *cfg, struct server_proxy *proxy)
+proxy_delete(struct server_proxy *proxy)
 {
 	debug(DBG_PROXY, "%s: shutting down proxy %p", proxy->server->name, proxy);
 
-	assert_return(cfg && proxy);
+	assert_return(proxy);
 
-	uring_task_destroy(cfg, &proxy->servertask);
-	uring_task_destroy(cfg, &proxy->clienttask);
-	uring_task_destroy(cfg, &proxy->task);
+	uring_task_destroy(&proxy->servertask);
+	uring_task_destroy(&proxy->clienttask);
+	uring_task_destroy(&proxy->task);
 }
 
-static void proxy_client_data_in(struct cfg *cfg, struct uring_task *task, int res);
+static void proxy_client_data_in(struct uring_task *task, int res);
 
 static void
-proxy_client_data_out(struct cfg *cfg, struct uring_task *task, int res)
+proxy_client_data_out(struct uring_task *task, int res)
 {
 	struct server_proxy *proxy = container_of(task, struct server_proxy, clienttask);
 
-	assert_return(cfg && task);
+	assert_return(task);
 	assert_task_alive(DBG_PROXY, task);
 
 	if (res <= 0) {
 		debug(DBG_PROXY, "%s: result was %i", proxy->server->name, res);
-		uring_task_close_fd(cfg, task);
-		proxy_delete(cfg, proxy);
+		uring_task_close_fd(task);
+		proxy_delete(proxy);
 		return;
 	}
 
 	proxy->client_bytes += res;
 	uring_task_set_fd(&proxy->clienttask, proxy->cfd);
-	uring_tbuf_read(cfg, task, proxy_client_data_in);
+	uring_tbuf_read(task, proxy_client_data_in);
 }
 
 static void
-proxy_client_data_in(struct cfg *cfg, struct uring_task *task, int res)
+proxy_client_data_in(struct uring_task *task, int res)
 {
 	struct server_proxy *proxy = container_of(task, struct server_proxy, clienttask);
 
-	assert_return(cfg && task);
+	assert_return(task);
 	assert_task_alive(DBG_PROXY, task);
 
 	if (res <= 0) {
 		debug(DBG_PROXY, "%s: result was %i", proxy->server->name, res);
-		uring_task_close_fd(cfg, task);
-		proxy_delete(cfg, proxy);
+		uring_task_close_fd(task);
+		proxy_delete(proxy);
 		return;
 	}
 
 	uring_task_set_fd(&proxy->clienttask, proxy->sfd);
-	uring_tbuf_write(cfg, task, proxy_client_data_out);
+	uring_tbuf_write(task, proxy_client_data_out);
 }
 
-static void proxy_server_data_in(struct cfg *cfg, struct uring_task *task,
+static void proxy_server_data_in(struct uring_task *task,
 				 int res);
 
 static void
-proxy_server_data_out(struct cfg *cfg, struct uring_task *task, int res)
+proxy_server_data_out(struct uring_task *task, int res)
 {
 	struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
 
-	assert_return(cfg && task);
+	assert_return(task);
 	assert_task_alive(DBG_PROXY, task);
 
 	if (res <= 0) {
 		debug(DBG_PROXY, "%s: result was %i", proxy->server->name, res);
-		uring_task_close_fd(cfg, task);
-		proxy_delete(cfg, proxy);
+		uring_task_close_fd(task);
+		proxy_delete(proxy);
 		return;
 	}
 
 	proxy->server_bytes += res;
 	uring_task_set_fd(&proxy->servertask, proxy->sfd);
-	uring_tbuf_read(cfg, &proxy->servertask, proxy_server_data_in);
+	uring_tbuf_read(&proxy->servertask, proxy_server_data_in);
 }
 
 static void
-proxy_server_data_in(struct cfg *cfg, struct uring_task *task, int res)
+proxy_server_data_in(struct uring_task *task, int res)
 {
 	struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
 
-	assert_return(cfg && task);
+	assert_return(task);
 	assert_task_alive(DBG_PROXY, task);
 
 	if (res <= 0) {
 		debug(DBG_PROXY, "%s: result was %i", proxy->server->name, res);
-		uring_task_close_fd(cfg, task);
-		proxy_delete(cfg, proxy);
+		uring_task_close_fd(task);
+		proxy_delete(proxy);
 		return;
 	}
 
 	uring_task_set_fd(&proxy->servertask, proxy->cfd);
-	uring_tbuf_write(cfg, task, proxy_server_data_out);
+	uring_tbuf_write(task, proxy_server_data_out);
 }
 
 static void
-proxy_connected_cb(struct cfg *cfg, struct connection *conn, bool connected)
+proxy_connected_cb(struct connection *conn, bool connected)
 {
 	struct server_proxy *proxy = container_of(conn, struct server_proxy, server_conn);
 
-	assert_return(cfg && conn);
+	assert_return(conn);
 	assert_task_alive(DBG_PROXY, &proxy->clienttask);
 	assert_task_alive(DBG_PROXY, &proxy->servertask);
 
 	if (!connected) {
 		error("%s: proxy connection to remote server failed",
 		      proxy->server->name);
-		proxy_delete(cfg, proxy);
+		proxy_delete(proxy);
 		return;
 	}
 
@@ -235,16 +235,16 @@ proxy_connected_cb(struct cfg *cfg, struct connection *conn, bool connected)
 		proxy->server_conn.remote.addrstr);
 	proxy->begin = time(NULL);
 
-	uring_tbuf_read(cfg, &proxy->clienttask, proxy_client_data_in);
-	uring_tbuf_read(cfg, &proxy->servertask, proxy_server_data_in);
+	uring_tbuf_read(&proxy->clienttask, proxy_client_data_in);
+	uring_tbuf_read(&proxy->servertask, proxy_server_data_in);
 }
 
 struct server_proxy *
-proxy_new(struct cfg *cfg, struct server *server, struct saddr *client, int fd)
+proxy_new(struct server *server, struct saddr *client, int fd)
 {
 	struct server_proxy *proxy;
 
-	assert_return(cfg && server && client && fd > 0, NULL);
+	assert_return(server && client && fd > 0, NULL);
 
 	proxy = zmalloc(sizeof(*proxy));
 	if (!proxy) {
@@ -255,22 +255,22 @@ proxy_new(struct cfg *cfg, struct server *server, struct saddr *client, int fd)
 	proxy->sfd = -1;
 	proxy->cfd = fd;
 	proxy->server = server;
-	uring_task_init(cfg, &proxy->task, "proxy", &server->task, proxy_free);
+	uring_task_init(&proxy->task, "proxy", &server->task, proxy_free);
 
-	connection_set_local(cfg, &proxy->client_conn, fd);
-	connection_set_remote(cfg, &proxy->client_conn, client);
+	connection_set_local(&proxy->client_conn, fd);
+	connection_set_remote(&proxy->client_conn, client);
 
-	uring_task_init(cfg, &proxy->clienttask, "proxy_client", &proxy->task,
+	uring_task_init(&proxy->clienttask, "proxy_client", &proxy->task,
 			proxy_client_free);
 	uring_task_set_buf(&proxy->clienttask, &proxy->clientbuf);
 	uring_task_set_fd(&proxy->clienttask, fd);
 
-	uring_task_init(cfg, &proxy->servertask, "proxy_server", &proxy->task,
+	uring_task_init(&proxy->servertask, "proxy_server", &proxy->task,
 			proxy_server_free);
 	uring_task_set_buf(&proxy->servertask, &proxy->serverbuf);
 
 	list_add(&proxy->list, &server->proxys);
-	connect_any(cfg, &proxy->servertask, &server->remotes,
+	connect_any(&proxy->servertask, &server->remotes,
 		    &proxy->server_conn, proxy_connected_cb);
 
 	return proxy;