lib-program-client, global: Rename struct program_client_settings to program_client_p...

Also rename the parameter/variable names.

diff --git a/src/lib-program-client/program-client-local.c b/src/lib-program-client/program-client-local.c
index 97fb5f1a6406dc17548246d38db3603c9a240854..3bb0b69cd60cbb88d6855e7229d01643e4ba21fd 100644 (file)
--- a/src/lib-program-client/program-client-local.c
+++ b/src/lib-program-client/program-client-local.c
@@ -257,14 +257,14 @@ program_client_local_connect(struct program_client *pclient)
 
                /* if we want to allow root, then we will not drop
                   root privileges */
-               restrict_access(&pclient->set.restrict_set,
-                               (pclient->set.allow_root ?
+               restrict_access(&pclient->params.restrict_set,
+                               (pclient->params.allow_root ?
                                        RESTRICT_ACCESS_FLAG_ALLOW_ROOT : 0),
-                               pclient->set.home);
+                               pclient->params.home);
 
                exec_child(plclient->bin_path, pclient->args, &pclient->envs,
                           fd_in[0], fd_out[1], child_extra_fds,
-                          pclient->set.drop_stderr, event);
+                          pclient->params.drop_stderr, event);
                i_unreached();
        }
 
@@ -431,7 +431,7 @@ program_client_local_kill(struct program_client_local *plclient)
        e_debug(pclient->event,
                "Execution timed out after %u milliseconds: "
                "Sending TERM signal",
-               pclient->set.input_idle_timeout_msecs);
+               pclient->params.input_idle_timeout_msecs);
 
        /* send sigterm, keep on waiting */
        plclient->sent_term = TRUE;
@@ -485,8 +485,8 @@ program_client_local_disconnect(struct program_client *pclient, bool force)
 
        /* Calculate timeout */
        runtime = timeval_diff_msecs(&ioloop_timeval, &pclient->start_time);
-       if (force || (pclient->set.input_idle_timeout_msecs > 0 &&
-                     runtime >= pclient->set.input_idle_timeout_msecs)) {
+       if (force || (pclient->params.input_idle_timeout_msecs > 0 &&
+                     runtime >= pclient->params.input_idle_timeout_msecs)) {
                e_debug(pclient->event,
                        "Terminating program immediately");
 
@@ -494,8 +494,8 @@ program_client_local_disconnect(struct program_client *pclient, bool force)
                return;
        }
 
-       if (runtime > 0 && runtime < pclient->set.input_idle_timeout_msecs)
-               timeout = pclient->set.input_idle_timeout_msecs - runtime;
+       if (runtime > 0 && runtime < pclient->params.input_idle_timeout_msecs)
+               timeout = pclient->params.input_idle_timeout_msecs - runtime;
 
        e_debug(pclient->event,
                "Waiting for program to finish after %lld msecs "
@@ -535,7 +535,7 @@ program_client_local_switch_ioloop(struct program_client *pclient)
 struct program_client *
 program_client_local_create(const char *bin_path,
                            const char *const *args,
-                           const struct program_client_settings *set)
+                           const struct program_client_parameters *params)
 {
        struct program_client_local *plclient;
        const char *label;
@@ -545,7 +545,7 @@ program_client_local_create(const char *bin_path,
 
        pool = pool_alloconly_create("program client local", 1024);
        plclient = p_new(pool, struct program_client_local, 1);
-       program_client_init(&plclient->client, pool, label, args, set);
+       program_client_init(&plclient->client, pool, label, args, params);
        plclient->client.connect = program_client_local_connect;
        plclient->client.close_output = program_client_local_close_output;
        plclient->client.switch_ioloop = program_client_local_switch_ioloop;

diff --git a/src/lib-program-client/program-client-private.h b/src/lib-program-client/program-client-private.h
index 697cef1541e7920e375b6f0aa926e4ffa2e2cc6c..9c6a441b3969e2fc111c55192ebca8f53d02b1c6 100644 (file)
--- a/src/lib-program-client/program-client-private.h
+++ b/src/lib-program-client/program-client-private.h
@@ -24,7 +24,7 @@ struct program_client_extra_fd {
 
 struct program_client {
        pool_t pool;
-       struct program_client_settings set;
+       struct program_client_parameters params;
 
        const char **args;
        ARRAY_TYPE(const_string) envs;
@@ -69,7 +69,7 @@ void program_client_set_label(struct program_client *pclient,
 void program_client_init(struct program_client *pclient, pool_t pool,
                         const char *initial_label,
                         const char *const *args,
-                        const struct program_client_settings *set)
+                        const struct program_client_parameters *params)
                         ATTR_NULL(5);
 
 void program_client_init_streams(struct program_client *pclient);

diff --git a/src/lib-program-client/program-client-remote.c b/src/lib-program-client/program-client-remote.c
index aa2a0fb23e2d9411a3f18901aa1b3c0edd2a8e54..922e58531458a971b1ef2dd48b5658c593a928b6 100644 (file)
--- a/src/lib-program-client/program-client-remote.c
+++ b/src/lib-program-client/program-client-remote.c
@@ -376,7 +376,7 @@ program_client_net_connect_timeout(struct program_client_remote *prclient)
 
        e_error(pclient->event, "connect(%s) failed: "
                "Timeout in %u milliseconds", prclient->address,
-               pclient->set.client_connect_timeout_msecs);
+               pclient->params.client_connect_timeout_msecs);
 
        /* Set error to timeout here */
        pclient->error = PROGRAM_CLIENT_ERROR_CONNECT_TIMEOUT;
@@ -425,7 +425,7 @@ program_client_net_connect_real(struct program_client_remote *prclient)
        program_client_set_label(pclient, label);
 
        e_debug(pclient->event, "Trying to connect (timeout %u msecs)",
-               pclient->set.client_connect_timeout_msecs);
+               pclient->params.client_connect_timeout_msecs);
 
        /* Try to connect */
        int fd;
@@ -444,9 +444,9 @@ program_client_net_connect_real(struct program_client_remote *prclient)
        pclient->io = io_add(fd, IO_WRITE,
                             program_client_net_connected, prclient);
 
-       if (pclient->set.client_connect_timeout_msecs != 0) {
+       if (pclient->params.client_connect_timeout_msecs != 0) {
                pclient->to = timeout_add(
-                       pclient->set.client_connect_timeout_msecs,
+                       pclient->params.client_connect_timeout_msecs,
                        program_client_net_connect_timeout, prclient);
        }
 }
@@ -491,15 +491,15 @@ program_client_net_connect_resolved(const struct dns_lookup_result *result,
                result->ips_count);
 
        /* Reduce timeout */
-       if (pclient->set.client_connect_timeout_msecs > 0) {
-               if (pclient->set.client_connect_timeout_msecs <=
+       if (pclient->params.client_connect_timeout_msecs > 0) {
+               if (pclient->params.client_connect_timeout_msecs <=
                    result->msecs) {
                        /* We ran out of time */
                        program_client_fail(
                                pclient, PROGRAM_CLIENT_ERROR_CONNECT_TIMEOUT);
                        return;
                }
-               pclient->set.client_connect_timeout_msecs -= result->msecs;
+               pclient->params.client_connect_timeout_msecs -= result->msecs;
        }
 
        /* Then connect */
@@ -525,13 +525,13 @@ static int program_client_net_connect_init(struct program_client *pclient)
                prclient->ips_count = 1;
        } else {
                prclient->resolved = FALSE;
-               if (pclient->set.dns_client_socket_path != NULL) {
+               if (pclient->params.dns_client_socket_path != NULL) {
                        e_debug(pclient->event,
                                "Performing asynchronous DNS lookup");
                        prclient->dns_set.dns_client_socket_path =
-                               pclient->set.dns_client_socket_path;
+                               pclient->params.dns_client_socket_path;
                        prclient->dns_set.timeout_msecs =
-                               pclient->set.client_connect_timeout_msecs;
+                               pclient->params.client_connect_timeout_msecs;
                        prclient->dns_set.event_parent = pclient->event;
                        (void)dns_lookup(prclient->address, &prclient->dns_set,
                                         program_client_net_connect_resolved,
@@ -617,7 +617,7 @@ program_client_remote_switch_ioloop(struct program_client *pclient)
 
 struct program_client *
 program_client_unix_create(const char *socket_path, const char *const *args,
-                          const struct program_client_settings *set,
+                          const struct program_client_parameters *params,
                           bool noreply)
 {
        struct program_client_remote *prclient;
@@ -628,7 +628,7 @@ program_client_unix_create(const char *socket_path, const char *const *args,
 
        pool = pool_alloconly_create("program client unix", 1024);
        prclient = p_new(pool, struct program_client_remote, 1);
-       program_client_init(&prclient->client, pool, label, args, set);
+       program_client_init(&prclient->client, pool, label, args, params);
        prclient->client.connect = program_client_unix_connect;
        prclient->client.close_output = program_client_remote_close_output;
        prclient->client.disconnect = program_client_remote_disconnect;
@@ -642,7 +642,7 @@ program_client_unix_create(const char *socket_path, const char *const *args,
 struct program_client *
 program_client_net_create(const char *host, in_port_t port,
                          const char *const *args,
-                         const struct program_client_settings *set,
+                         const struct program_client_parameters *params,
                          bool noreply)
 {
        struct program_client_remote *prclient;
@@ -653,11 +653,11 @@ program_client_net_create(const char *host, in_port_t port,
 
        pool = pool_alloconly_create("program client net", 1024);
        prclient = p_new(pool, struct program_client_remote, 1);
-       program_client_init(&prclient->client, pool, label, args, set);
+       program_client_init(&prclient->client, pool, label, args, params);
        prclient->client.connect = program_client_net_connect_init;
        prclient->client.close_output = program_client_remote_close_output;
        prclient->client.disconnect = program_client_remote_disconnect;
-       prclient->client.set.use_dotstream = TRUE;
+       prclient->client.params.use_dotstream = TRUE;
        prclient->address = p_strdup(pool, host);
        prclient->port = port;
        prclient->have_hostname = TRUE;
@@ -669,7 +669,7 @@ struct program_client *
 program_client_net_create_ips(const struct ip_addr *ips, size_t ips_count,
                              in_port_t port,
                              const char *const *args,
-                             const struct program_client_settings *set,
+                             const struct program_client_parameters *params,
                              bool noreply)
 {
        struct program_client_remote *prclient;
@@ -682,12 +682,12 @@ program_client_net_create_ips(const struct ip_addr *ips, size_t ips_count,
 
        pool = pool_alloconly_create("program client net", 1024);
        prclient = p_new(pool, struct program_client_remote, 1);
-       program_client_init(&prclient->client, pool, label, args, set);
+       program_client_init(&prclient->client, pool, label, args, params);
        prclient->client.connect = program_client_net_connect_init;
        prclient->client.close_output = program_client_remote_close_output;
        prclient->client.disconnect = program_client_remote_disconnect;
        prclient->client.switch_ioloop = program_client_remote_switch_ioloop;
-       prclient->client.set.use_dotstream = TRUE;
+       prclient->client.params.use_dotstream = TRUE;
        prclient->address = p_strdup(pool, net_ip2addr(ips));
        prclient->ips = p_memdup(pool, ips,
                                 sizeof(struct ip_addr)*ips_count);

diff --git a/src/lib-program-client/program-client.c b/src/lib-program-client/program-client.c
index 8a8076db182559774f94feb587c0e34d122e283d..59720b18cc22ccee717e3225e186ac4a03b2168d 100644 (file)
--- a/src/lib-program-client/program-client.c
+++ b/src/lib-program-client/program-client.c
@@ -47,7 +47,7 @@ program_client_timeout(struct program_client *pclient)
 {
        e_error(pclient->event,
                "Execution timed out (> %u msecs)",
-               pclient->set.input_idle_timeout_msecs);
+               pclient->params.input_idle_timeout_msecs);
        program_client_fail(pclient, PROGRAM_CLIENT_ERROR_RUN_TIMEOUT);
 }
 
@@ -56,7 +56,7 @@ program_client_connect_timeout(struct program_client *pclient)
 {
        e_error(pclient->event,
                "Connection timed out (> %u msecs)",
-               pclient->set.client_connect_timeout_msecs);
+               pclient->params.client_connect_timeout_msecs);
        program_client_fail(pclient, PROGRAM_CLIENT_ERROR_CONNECT_TIMEOUT);
 }
 
@@ -65,9 +65,9 @@ program_client_connect(struct program_client *pclient)
 {
        e_debug(pclient->event, "Establishing connection");
 
-       if (pclient->set.client_connect_timeout_msecs != 0) {
+       if (pclient->params.client_connect_timeout_msecs != 0) {
                pclient->to = timeout_add(
-                       pclient->set.client_connect_timeout_msecs,
+                       pclient->params.client_connect_timeout_msecs,
                        program_client_connect_timeout, pclient);
        }
 
@@ -401,7 +401,7 @@ void program_client_connected(struct program_client *pclient)
                struct istream *input = pclient->raw_program_input;
 
                /* initialize dot input stream if required */
-               if (pclient->set.use_dotstream)
+               if (pclient->params.use_dotstream)
                        input = i_stream_create_dot(input, ISTREAM_DOT_TRIM_TRAIL |
                                                           ISTREAM_DOT_LOOSE_EOT);
                else
@@ -413,7 +413,7 @@ void program_client_connected(struct program_client *pclient)
                struct ostream *output = pclient->raw_program_output;
 
                /* initialize dot output stream if required */
-               if (pclient->set.use_dotstream)
+               if (pclient->params.use_dotstream)
                        output = o_stream_create_dot(output, FALSE);
                else
                        o_stream_ref(output);
@@ -422,9 +422,9 @@ void program_client_connected(struct program_client *pclient)
 
        pclient->start_time = ioloop_timeval;
        timeout_remove(&pclient->to);
-       if (pclient->set.input_idle_timeout_msecs != 0) {
+       if (pclient->params.input_idle_timeout_msecs != 0) {
                pclient->to =
-                       timeout_add(pclient->set.input_idle_timeout_msecs,
+                       timeout_add(pclient->params.input_idle_timeout_msecs,
                                    program_client_timeout, pclient);
        }
 
@@ -465,7 +465,7 @@ void program_client_connected(struct program_client *pclient)
 
 void program_client_init(struct program_client *pclient, pool_t pool,
                         const char *initial_label, const char *const *args,
-                        const struct program_client_settings *set)
+                        const struct program_client_parameters *params)
 {
        pclient->pool = pool;
        if (args != NULL)
@@ -473,17 +473,17 @@ void program_client_init(struct program_client *pclient, pool_t pool,
        pclient->fd_in = -1;
        pclient->fd_out = -1;
 
-       if (set == NULL)
+       if (params == NULL)
                pclient->event = event_create(NULL);
        else {
-               pclient->set = *set;
-               pclient->debug = set->debug;
-               pclient->set.dns_client_socket_path =
-                       p_strdup(pool, set->dns_client_socket_path);
-               pclient->set.home = p_strdup(pool, set->home);
-
-               pclient->event = event_create(set->event);
-               event_set_forced_debug(pclient->event, set->debug);
+               pclient->params = *params;
+               pclient->debug = params->debug;
+               pclient->params.dns_client_socket_path =
+                       p_strdup(pool, params->dns_client_socket_path);
+               pclient->params.home = p_strdup(pool, params->home);
+
+               pclient->event = event_create(params->event);
+               event_set_forced_debug(pclient->event, params->debug);
        }
 
        program_client_set_label(pclient, initial_label);
@@ -666,17 +666,17 @@ void program_client_switch_ioloop(struct program_client *pclient)
 }
 
 int program_client_create(const char *uri, const char *const *args,
-                         const struct program_client_settings *set,
+                         const struct program_client_parameters *params,
                          bool noreply, struct program_client **pc_r,
                          const char **error_r)
 {
        const char *suffix;
 
        if (str_begins(uri, "exec:", &suffix)) {
-               *pc_r = program_client_local_create(suffix, args, set);
+               *pc_r = program_client_local_create(suffix, args, params);
                return 0;
        } else if (str_begins(uri, "unix:", &suffix)) {
-               *pc_r = program_client_unix_create(suffix, args, set, noreply);
+               *pc_r = program_client_unix_create(suffix, args, params, noreply);
                return 0;
        } else if (str_begins(uri, "tcp:", &suffix)) {
                const char *host;
@@ -689,7 +689,7 @@ int program_client_create(const char *uri, const char *const *args,
                                "must be host:port in '%s'", suffix);
                        return -1;
                }
-               *pc_r = program_client_net_create(host, port, args, set,
+               *pc_r = program_client_net_create(host, port, args, params,
                                                  noreply);
                return 0;
        } else {

diff --git a/src/lib-program-client/program-client.h b/src/lib-program-client/program-client.h
index f8b4197e5fad29b2291d80430669a660b07b8687..7dcdb1488b8332ec9cc08a877e8cad6249344a13 100644 (file)
--- a/src/lib-program-client/program-client.h
+++ b/src/lib-program-client/program-client.h
@@ -12,7 +12,7 @@ enum program_client_exit_status {
        PROGRAM_CLIENT_EXIT_STATUS_SUCCESS = 1,
 };
 
-struct program_client_settings {
+struct program_client_parameters {
        unsigned int client_connect_timeout_msecs;
        unsigned int input_idle_timeout_msecs;
        /* initialize with
@@ -42,24 +42,24 @@ typedef void program_client_callback_t(enum program_client_exit_status status,
 
 struct program_client *
 program_client_local_create(const char *bin_path, const char *const *args,
-                           const struct program_client_settings *set)
+                           const struct program_client_parameters *params)
                            ATTR_NULL(3);
 struct program_client *
 program_client_unix_create(const char *socket_path, const char *const *args,
-                          const struct program_client_settings *set,
+                          const struct program_client_parameters *params,
                           bool noreply) ATTR_NULL(3);
 struct program_client *
 program_client_net_create(const char *host, in_port_t port,
                          const char *const *args,
-                         const struct program_client_settings *set,
+                         const struct program_client_parameters *params,
                          bool noreply) ATTR_NULL(4);
 struct program_client *
 program_client_net_create_ips(const struct ip_addr *ips, size_t ips_count,
                              in_port_t port, const char *const *args,
-                             const struct program_client_settings *set,
+                             const struct program_client_parameters *params,
                              bool noreply) ATTR_NULL(5);
 int program_client_create(const char *uri, const char *const *args,
-                         const struct program_client_settings *set,
+                         const struct program_client_parameters *params,
                          bool noreply, struct program_client **pc_r,
                          const char **error_r) ATTR_NULL(3);
 

diff --git a/src/lib-program-client/test-program-client-local.c b/src/lib-program-client/test-program-client-local.c
index c8152b2f5fdfc3e30e87a5ad7b0920e1fd416dab..6aaed792dbfc12bdc91465e0fd314f2e6dfd8662 100644 (file)
--- a/src/lib-program-client/test-program-client-local.c
+++ b/src/lib-program-client/test-program-client-local.c
@@ -23,7 +23,7 @@ static const char *pclient_test_io_string =
        "dis parturient montes, nascetur ridiculus mus. Aliquam \n"
        "laoreet arcu a hendrerit consequat. Duis vitae erat tellus.";
 
-static struct program_client_settings pc_set = {
+static struct program_client_parameters pc_params = {
        .client_connect_timeout_msecs = 10000,
        .input_idle_timeout_msecs = 5000,
        .debug = FALSE,
@@ -45,7 +45,7 @@ static void test_program_success(void)
 
        test_begin("test_program_success");
 
-       pc = program_client_local_create("/bin/echo", args, &pc_set);
+       pc = program_client_local_create("/bin/echo", args, &pc_params);
 
        buffer_t *output = buffer_create_dynamic(default_pool, 16);
        struct ostream *os = test_ostream_create(output);
@@ -72,7 +72,7 @@ static void test_program_io_sync(void)
 
        test_begin("test_program_io (sync)");
 
-       pc = program_client_local_create("/bin/cat", args, &pc_set);
+       pc = program_client_local_create("/bin/cat", args, &pc_params);
 
        struct istream *is = test_istream_create(pclient_test_io_string);
        program_client_set_input(pc, is);
@@ -115,7 +115,7 @@ static void test_program_io_async(void)
        prev_ioloop = current_ioloop;
        ioloop = io_loop_create();
 
-       pc = program_client_local_create("/bin/cat", args, &pc_set);
+       pc = program_client_local_create("/bin/cat", args, &pc_params);
 
        struct istream *is = test_istream_create(pclient_test_io_string);
        program_client_set_input(pc, is);
@@ -153,7 +153,7 @@ static void test_program_failure(void)
 
        test_begin("test_program_failure");
 
-       pc = program_client_local_create("/bin/false", args, &pc_set);
+       pc = program_client_local_create("/bin/false", args, &pc_params);
 
        buffer_t *output = buffer_create_dynamic(default_pool, 16);
        struct ostream *os = test_ostream_create(output);
@@ -189,7 +189,7 @@ static void test_program_io_big(void)
 
        test_begin("test_program_io (big)");
 
-       pc = program_client_local_create("/bin/sh", args, &pc_set);
+       pc = program_client_local_create("/bin/sh", args, &pc_params);
 
        /* make big input with only a small reference string */
        struct istream *is1 = test_istream_create(pclient_test_io_string);
@@ -228,7 +228,7 @@ static void test_program_io_big(void)
 
 static void test_program_wait_no_io(void)
 {
-       struct program_client_settings set = pc_set;
+       struct program_client_parameters params = pc_params;
        struct program_client *pc;
 
        /* nasty program that reads data in bits with intermittent delays
@@ -240,9 +240,9 @@ static void test_program_wait_no_io(void)
 
        test_begin("test_program_wait (no timeout, no I/O)");
 
-       set.client_connect_timeout_msecs = 0;
-       set.input_idle_timeout_msecs = 0;
-       pc = program_client_local_create("/bin/sh", args, &set);
+       params.client_connect_timeout_msecs = 0;
+       params.input_idle_timeout_msecs = 0;
+       pc = program_client_local_create("/bin/sh", args, &params);
 
        test_assert(program_client_run(pc) == 1);
 
@@ -271,7 +271,7 @@ int main(int argc, char *argv[])
        while ((c = getopt(argc, argv, "D")) > 0) {
                switch (c) {
                case 'D':
-                       pc_set.debug = TRUE;
+                       pc_params.debug = TRUE;
                        break;
                default:
                        i_fatal("Usage: %s [-D]", argv[0]);

diff --git a/src/lib-program-client/test-program-client-net.c b/src/lib-program-client/test-program-client-net.c
index b4fdd1259e53169afbabbe1b702dc02e2439711d..c7743ed176934f8326203c9602a205a0b5e5cbd9 100644 (file)
--- a/src/lib-program-client/test-program-client-net.c
+++ b/src/lib-program-client/test-program-client-net.c
@@ -27,7 +27,7 @@ static const char *pclient_test_io_string =
        "dis parturient montes, nascetur ridiculus mus. Aliquam \r\n"
        "laoreet arcu a hendrerit consequat. Duis vitae erat tellus.";
 
-static struct program_client_settings pc_set = {
+static struct program_client_parameters pc_params = {
        .client_connect_timeout_msecs = 5000,
        .input_idle_timeout_msecs = 10000,
        .debug = FALSE,
@@ -337,7 +337,7 @@ static void test_program_success(void)
        test_begin("test_program_success");
 
        pc = program_client_net_create("127.0.0.1", test_globals.port, args,
-                                      &pc_set, FALSE);
+                                      &pc_params, FALSE);
 
        buffer_t *output = buffer_create_dynamic(default_pool, 16);
        struct ostream *os = test_ostream_create(output);
@@ -367,7 +367,7 @@ static void test_program_io_common(const char *const *args)
        int ret = -2;
 
        pc = program_client_net_create("127.0.0.1", test_globals.port, args,
-                                      &pc_set, FALSE);
+                                      &pc_params, FALSE);
 
        struct istream *is = test_istream_create(pclient_test_io_string);
        program_client_set_input(pc, is);
@@ -426,7 +426,7 @@ static void test_program_failure(void)
        test_begin("test_program_failure");
 
        pc = program_client_net_create("127.0.0.1", test_globals.port, args,
-                                      &pc_set, FALSE);
+                                      &pc_params, FALSE);
 
        buffer_t *output = buffer_create_dynamic(default_pool, 16);
        struct ostream *os = test_ostream_create(output);
@@ -461,7 +461,7 @@ static void test_program_noreply(void)
        test_begin("test_program_noreply");
 
        pc = program_client_net_create("127.0.0.1", test_globals.port, args,
-                                      &pc_set, TRUE);
+                                      &pc_params, TRUE);
 
        program_client_run_async(pc, test_program_async_callback, &ret);
 
@@ -498,7 +498,7 @@ static void test_program_refused(void)
 
        pc = program_client_net_create_ips(ips, N_ELEMENTS(ips),
                                           test_globals.port, args,
-                                          &pc_set, TRUE);
+                                          &pc_params, TRUE);
 
        test_expect_errors(N_ELEMENTS(ips)-1);
        program_client_run_async(pc, test_program_async_callback, &ret);
@@ -533,7 +533,7 @@ int main(int argc, char *argv[])
        while ((c = getopt(argc, argv, "D")) > 0) {
                switch (c) {
                case 'D':
-                       pc_set.debug = TRUE;
+                       pc_params.debug = TRUE;
                        break;
                default:
                        i_fatal("Usage: %s [-D]", argv[0]);

diff --git a/src/lib-program-client/test-program-client-unix.c b/src/lib-program-client/test-program-client-unix.c
index 4e9b3b59f55a76d7df38036aada4bc2c944e7124..e9a58bf4f6c286999ea3b9f162a57efb02c66276 100644 (file)
--- a/src/lib-program-client/test-program-client-unix.c
+++ b/src/lib-program-client/test-program-client-unix.c
@@ -26,7 +26,7 @@ static const char *pclient_test_io_string =
        "dis parturient montes, nascetur ridiculus mus. Aliquam \n"
        "laoreet arcu a hendrerit consequat. Duis vitae erat tellus.";
 
-static struct program_client_settings pc_set = {
+static struct program_client_parameters pc_params = {
        .client_connect_timeout_msecs = 1000,
        .input_idle_timeout_msecs = 5000,
        .debug = FALSE,
@@ -289,7 +289,7 @@ static void test_program_success(void)
 
        test_begin("test_program_success");
 
-       pc = program_client_unix_create(TEST_SOCKET, args, &pc_set, FALSE);
+       pc = program_client_unix_create(TEST_SOCKET, args, &pc_params, FALSE);
 
        buffer_t *output = buffer_create_dynamic(default_pool, 16);
        struct ostream *os = test_ostream_create(output);
@@ -315,7 +315,7 @@ static void test_program_io_common(const char *const *args)
        struct program_client *pc;
        int ret;
 
-       pc = program_client_unix_create(TEST_SOCKET, args, &pc_set, FALSE);
+       pc = program_client_unix_create(TEST_SOCKET, args, &pc_params, FALSE);
 
        struct istream *is = test_istream_create(pclient_test_io_string);
        program_client_set_input(pc, is);
@@ -370,7 +370,7 @@ static void test_program_failure(void)
 
        test_begin("test_program_failure");
 
-       pc = program_client_unix_create(TEST_SOCKET, args, &pc_set, FALSE);
+       pc = program_client_unix_create(TEST_SOCKET, args, &pc_params, FALSE);
 
        buffer_t *output = buffer_create_dynamic(default_pool, 16);
        struct ostream *os = test_ostream_create(output);
@@ -401,7 +401,7 @@ static void test_program_noreply(void)
 
        test_begin("test_program_noreply");
 
-       pc = program_client_unix_create(TEST_SOCKET, args, &pc_set, TRUE);
+       pc = program_client_unix_create(TEST_SOCKET, args, &pc_params, TRUE);
 
        program_client_run_async(pc, test_program_async_callback, &ret);
 
@@ -425,7 +425,7 @@ static void test_program_sync(void)
 
        test_begin("test_program_sync");
 
-       pc = program_client_unix_create(TEST_SOCKET, args, &pc_set, TRUE);
+       pc = program_client_unix_create(TEST_SOCKET, args, &pc_params, TRUE);
        ret = program_client_run(pc);
        test_assert(ret == 1);
 
@@ -451,7 +451,7 @@ static void test_program_async_wait(void)
        test_begin("test_program_async_wait");
 
        test_globals.async_client = program_client_unix_create(TEST_SOCKET,
-                       args, &pc_set, TRUE);
+                       args, &pc_params, TRUE);
 
        program_client_run_async(test_globals.async_client,
                                 test_program_async_wait_finish,
@@ -481,7 +481,7 @@ int main(int argc, char *argv[])
        while ((c = getopt(argc, argv, "D")) > 0) {
                switch (c) {
                case 'D':
-                       pc_set.debug = TRUE;
+                       pc_params.debug = TRUE;
                        break;
                default:
                        i_fatal("Usage: %s [-D]", argv[0]);

diff --git a/src/lib-smtp/smtp-submit.c b/src/lib-smtp/smtp-submit.c
index fde982e673f2a8f8e2a19ae41d7b3f56ebe82e6c..7537ed424dc549a3bdf189bc706ca1f608188be0 100644 (file)
--- a/src/lib-smtp/smtp-submit.c
+++ b/src/lib-smtp/smtp-submit.c
@@ -386,7 +386,7 @@ smtp_submit_send_sendmail(struct smtp_submit *subm)
        ARRAY_TYPE(const_string) args;
        struct smtp_address *rcpt;
        unsigned int i;
-       struct program_client_settings pc_set;
+       struct program_client_parameters pc_params;
        struct program_client *pc;
 
        sendmail_args = t_strsplit(set->sendmail_path, " ");
@@ -409,16 +409,16 @@ smtp_submit_send_sendmail(struct smtp_submit *subm)
        }
        array_append_zero(&args);
 
-       i_zero(&pc_set);
-       pc_set.client_connect_timeout_msecs = set->submission_timeout * 1000;
-       pc_set.input_idle_timeout_msecs = set->submission_timeout * 1000;
-       pc_set.debug = set->mail_debug;
-       pc_set.event = subm->event;
-       pc_set.allow_root = subm->session->allow_root;
-       restrict_access_init(&pc_set.restrict_set);
+       i_zero(&pc_params);
+       pc_params.client_connect_timeout_msecs = set->submission_timeout * 1000;
+       pc_params.input_idle_timeout_msecs = set->submission_timeout * 1000;
+       pc_params.debug = set->mail_debug;
+       pc_params.event = subm->event;
+       pc_params.allow_root = subm->session->allow_root;
+       restrict_access_init(&pc_params.restrict_set);
 
        pc = program_client_local_create
-               (sendmail_bin, array_front(&args), &pc_set);
+               (sendmail_bin, array_front(&args), &pc_params);
 
        program_client_set_input(pc, subm->input);
        i_stream_unref(&subm->input);

diff --git a/src/plugins/quota/quota.c b/src/plugins/quota/quota.c
index 64fc9ccbc2be47167fe665e2ae85b08f56b17022..48f1e939161806fa60660c0f8a43bfdf968a50e1 100644 (file)
--- a/src/plugins/quota/quota.c
+++ b/src/plugins/quota/quota.c
@@ -1008,13 +1008,13 @@ static void quota_warning_execute(struct quota_root *root, const char *cmd,
 {
        const char *socket_path, *const *args, *error, *scheme, *ptr;
 
-       struct program_client_settings set = {
+       struct program_client_parameters params = {
                .client_connect_timeout_msecs = 1000,
                .debug = event_want_debug(root->quota->event),
        };
        struct program_client *pc;
 
-       restrict_access_init(&set.restrict_set);
+       restrict_access_init(&params.restrict_set);
 
        e_debug(root->quota->event, "Executing warning: %s (because %s)", cmd, reason);
 
@@ -1046,7 +1046,7 @@ static void quota_warning_execute(struct quota_root *root, const char *cmd,
 
        args++;
 
-       if (program_client_create(socket_path, args, &set, TRUE,
+       if (program_client_create(socket_path, args, &params, TRUE,
                                  &pc, &error) < 0) {
                e_error(root->quota->event,
                        "program_client_create(%s) failed: %s", socket_path,

diff --git a/src/plugins/welcome/welcome-plugin.c b/src/plugins/welcome/welcome-plugin.c
index 55bff472745e0fe88b2e33f01974a5f6657a63b5..44f1c9b236d0ea7304e1ed06ce716d654506adb0 100644 (file)
--- a/src/plugins/welcome/welcome-plugin.c
+++ b/src/plugins/welcome/welcome-plugin.c
@@ -52,7 +52,7 @@ static void script_execute(struct mail_user *user, const char *cmd, bool wait)
        if (mail_user_get_home(user, &home) < 0)
                home = NULL;
 
-       struct program_client_settings set = {
+       struct program_client_parameters params = {
                .client_connect_timeout_msecs = 1000,
                .event = user->event,
                .debug = event_want_debug(user->event),
@@ -71,7 +71,7 @@ static void script_execute(struct mail_user *user, const char *cmd, bool wait)
        }
 
        struct welcome_client_list *wclient = i_new(struct welcome_client_list, 1);
-       wclient->client = program_client_unix_create(socket_path, args, &set, !wait);
+       wclient->client = program_client_unix_create(socket_path, args, &params, !wait);
 
        if (wait) {
                enum program_client_exit_status ret =