imap-urlauth: imap-urlauth-worker-client - Rename most client variables to wclient.

diff --git a/src/imap-urlauth/imap-urlauth-worker-client.c b/src/imap-urlauth/imap-urlauth-worker-client.c
index 58b8215eb3c523527a1931fd4e5d6a031aacaca0..8c6a7cc0ec32a8cdec81e1775023d1be8f9ac4c3 100644 (file)
--- a/src/imap-urlauth/imap-urlauth-worker-client.c
+++ b/src/imap-urlauth/imap-urlauth-worker-client.c
@@ -16,10 +16,11 @@
 /* max. length of input lines (URLs) */
 #define MAX_INBUF_SIZE 2048
 
-static void client_worker_input(struct client *client);
+static void client_worker_input(struct client *wclient);
 
-int client_worker_connect(struct client *client)
+int client_worker_connect(struct client *wclient)
 {
+       struct client *client = wclient;
        static const char handshake[] = "VERSION\timap-urlauth-worker\t2\t0\n";
        const char *socket_path;
        ssize_t ret;
@@ -28,16 +29,16 @@ int client_worker_connect(struct client *client)
        socket_path = t_strconcat(client->set->base_dir,
                                  "/"IMAP_URLAUTH_WORKER_SOCKET, NULL);
 
-       e_debug(client->event, "Connecting to worker socket %s", socket_path);
+       e_debug(wclient->event, "Connecting to worker socket %s", socket_path);
 
-       client->fd_ctrl = net_connect_unix_with_retries(socket_path, 1000);
-       if (client->fd_ctrl < 0) {
+       wclient->fd_ctrl = net_connect_unix_with_retries(socket_path, 1000);
+       if (wclient->fd_ctrl < 0) {
                if (errno == EACCES) {
-                       e_error(client->event, "imap-urlauth-client: %s",
+                       e_error(wclient->event, "imap-urlauth-client: %s",
                                eacces_error_get("net_connect_unix",
                                                 socket_path));
                } else {
-                       e_error(client->event, "imap-urlauth-client: "
+                       e_error(wclient->event, "imap-urlauth-client: "
                                "net_connect_unix(%s) failed: %m",
                                socket_path);
                }
@@ -46,73 +47,74 @@ int client_worker_connect(struct client *client)
 
        /* transfer one or two fds */
        data = (client->fd_in == client->fd_out ? '0' : '1');
-       ret = fd_send(client->fd_ctrl, client->fd_in, &data, sizeof(data));
+       ret = fd_send(wclient->fd_ctrl, client->fd_in, &data, sizeof(data));
        if (ret > 0 && client->fd_in != client->fd_out) {
                data = '0';
-               ret = fd_send(client->fd_ctrl, client->fd_out,
+               ret = fd_send(wclient->fd_ctrl, client->fd_out,
                              &data, sizeof(data));
        }
 
        if (ret <= 0) {
                if (ret < 0) {
-                       e_error(client->event,
+                       e_error(wclient->event,
                                "fd_send(%s, %d) failed: %m",
-                               socket_path, client->fd_ctrl);
+                               socket_path, wclient->fd_ctrl);
                } else {
-                       e_error(client->event,
+                       e_error(wclient->event,
                                "fd_send(%s, %d) failed to send byte",
-                               socket_path, client->fd_ctrl);
+                               socket_path, wclient->fd_ctrl);
                }
-               client_worker_disconnect(client);
+               client_worker_disconnect(wclient);
                return -1;
        }
 
-       client->ctrl_output = o_stream_create_fd(client->fd_ctrl, SIZE_MAX);
+       wclient->ctrl_output = o_stream_create_fd(wclient->fd_ctrl, SIZE_MAX);
 
        /* send protocol version handshake */
-       if (o_stream_send_str(client->ctrl_output, handshake) < 0) {
-               e_error(client->event,
+       if (o_stream_send_str(wclient->ctrl_output, handshake) < 0) {
+               e_error(wclient->event,
                        "Error sending handshake to imap-urlauth worker: %m");
-               client_worker_disconnect(client);
+               client_worker_disconnect(wclient);
                return -1;
        }
 
-       client->ctrl_input =
-               i_stream_create_fd(client->fd_ctrl, MAX_INBUF_SIZE);
-       client->ctrl_io =
-               io_add(client->fd_ctrl, IO_READ, client_worker_input, client);
+       wclient->ctrl_input =
+               i_stream_create_fd(wclient->fd_ctrl, MAX_INBUF_SIZE);
+       wclient->ctrl_io =
+               io_add(wclient->fd_ctrl, IO_READ, client_worker_input, wclient);
        return 0;
 }
 
-void client_worker_disconnect(struct client *client)
+void client_worker_disconnect(struct client *wclient)
 {
-       client->worker_state = IMAP_URLAUTH_WORKER_STATE_INACTIVE;
-
-       io_remove(&client->ctrl_io);
-       o_stream_destroy(&client->ctrl_output);
-       i_stream_destroy(&client->ctrl_input);
-       if (client->fd_ctrl >= 0) {
-               net_disconnect(client->fd_ctrl);
-               client->fd_ctrl = -1;
+       wclient->worker_state = IMAP_URLAUTH_WORKER_STATE_INACTIVE;
+
+       io_remove(&wclient->ctrl_io);
+       o_stream_destroy(&wclient->ctrl_output);
+       i_stream_destroy(&wclient->ctrl_input);
+       if (wclient->fd_ctrl >= 0) {
+               net_disconnect(wclient->fd_ctrl);
+               wclient->fd_ctrl = -1;
        }
 }
 
 static int
-client_worker_input_line(struct client *client, const char *response)
+client_worker_input_line(struct client *wclient, const char *response)
 {
+       struct client *client = wclient;
        const char *const *apps;
        unsigned int count, i;
        bool restart;
        string_t *str;
        int ret;
 
-       switch (client->worker_state) {
+       switch (wclient->worker_state) {
        case IMAP_URLAUTH_WORKER_STATE_INACTIVE:
                if (strcasecmp(response, "OK") != 0) {
-                       client_disconnect(client, "Worker handshake failed");
+                       client_disconnect(wclient, "Worker handshake failed");
                        return -1;
                }
-               client->worker_state = IMAP_URLAUTH_WORKER_STATE_CONNECTED;
+               wclient->worker_state = IMAP_URLAUTH_WORKER_STATE_CONNECTED;
 
                str = t_str_new(256);
                str_append(str, "ACCESS\t");
@@ -133,11 +135,11 @@ client_worker_input_line(struct client *client, const char *response)
                }
                str_append(str, "\n");
 
-               ret = o_stream_send(client->ctrl_output,
+               ret = o_stream_send(wclient->ctrl_output,
                                    str_data(str), str_len(str));
                i_assert(ret < 0 || (size_t)ret == str_len(str));
                if (ret < 0) {
-                       client_disconnect(client,
+                       client_disconnect(wclient,
                                "Failed to send ACCESS control command to worker");
                        return -1;
                }
@@ -145,11 +147,11 @@ client_worker_input_line(struct client *client, const char *response)
 
        case IMAP_URLAUTH_WORKER_STATE_CONNECTED:
                if (strcasecmp(response, "OK") != 0) {
-                       client_disconnect(client,
+                       client_disconnect(wclient,
                                "Failed to negotiate access parameters");
                        return -1;
                }
-               client->worker_state = IMAP_URLAUTH_WORKER_STATE_ACTIVE;
+               wclient->worker_state = IMAP_URLAUTH_WORKER_STATE_ACTIVE;
                break;
 
        case IMAP_URLAUTH_WORKER_STATE_ACTIVE:
@@ -159,18 +161,18 @@ client_worker_input_line(struct client *client, const char *response)
                        restart = FALSE;
                } else if (strcasecmp(response, "FINISHED") != 0) {
                        /* unknown response */
-                       client_disconnect(client,
+                       client_disconnect(wclient,
                                "Worker finished with unknown response");
                        return -1;
                }
 
-               e_debug(client->event, "Worker finished successfully");
+               e_debug(wclient->event, "Worker finished successfully");
 
                if (restart) {
                        /* connect to new worker for accessing different user */
-                       client_worker_disconnect(client);
-                       if (client_worker_connect(client) < 0) {
-                               client_disconnect(client,
+                       client_worker_disconnect(wclient);
+                       if (client_worker_connect(wclient) < 0) {
+                               client_disconnect(wclient,
                                        "Failed to connect to new worker");
                                return -1;
                        }
@@ -178,7 +180,7 @@ client_worker_input_line(struct client *client, const char *response)
                        /* indicate success of "END" command */
                        client_send_line(client, "OK");
                } else {
-                       client_disconnect(client, "Client disconnected");
+                       client_disconnect(wclient, "Client disconnected");
                }
                return -1;
        default:
@@ -187,30 +189,30 @@ client_worker_input_line(struct client *client, const char *response)
        return 0;
 }
 
-static void client_worker_input(struct client *client)
+static void client_worker_input(struct client *wclient)
 {
-       struct istream *input = client->ctrl_input;
+       struct istream *input = wclient->ctrl_input;
        const char *line;
 
        if (input->closed) {
                /* disconnected */
-               client_disconnect(client, "Worker disconnected unexpectedly");
+               client_disconnect(wclient, "Worker disconnected unexpectedly");
                return;
        }
 
        switch (i_stream_read(input)) {
        case -1:
                /* disconnected */
-               client_disconnect(client, "Worker disconnected unexpectedly");
+               client_disconnect(wclient, "Worker disconnected unexpectedly");
                return;
        case -2:
                /* input buffer full */
-               client_disconnect(client, "Worker sent too large input");
+               client_disconnect(wclient, "Worker sent too large input");
                return;
        }
 
        while ((line = i_stream_next_line(input)) != NULL) {
-               if (client_worker_input_line(client, line) < 0)
+               if (client_worker_input_line(wclient, line) < 0)
                        return;
        }
 }

diff --git a/src/imap-urlauth/imap-urlauth-worker-client.h b/src/imap-urlauth/imap-urlauth-worker-client.h
index 6f6d6bdd39a1e5c1045ae7c2e65fa05ac0447b6f..8896ae1cf66408640a276b89c2a1c3396ca17f57 100644 (file)
--- a/src/imap-urlauth/imap-urlauth-worker-client.h
+++ b/src/imap-urlauth/imap-urlauth-worker-client.h
@@ -3,7 +3,7 @@
 
 #include "imap-urlauth-worker-common.h"
 
-int client_worker_connect(struct client *client);
-void client_worker_disconnect(struct client *client);
+int client_worker_connect(struct client *wclient);
+void client_worker_disconnect(struct client *wclient);
 
 #endif