Their behavior is clearer when result is expressed as enum than int.
}
static void
-director_flush_user_continue(int result, struct director_kill_context *ctx)
+director_flush_user_continue(enum program_client_exit_status result,
+ struct director_kill_context *ctx)
{
struct director *dir = ctx->dir;
ctx->callback_pending = FALSE;
struct user *user = user_directory_lookup(ctx->tag->users,
ctx->username_hash);
- if (result == 0) {
+ if (result == PROGRAM_CLIENT_EXIT_STATUS_FAILURE) {
struct istream *is = iostream_temp_finish(&ctx->reply, SIZE_MAX);
char *data;
i_stream_set_return_partial_line(is, TRUE);
/* ctx is freed later via user->kill_ctx */
e_debug(dir->event, "Flushing user %u finished, result=%d",
ctx->username_hash, result);
- director_user_kill_finish_delayed(dir, user, result == 1);
+ director_user_kill_finish_delayed(dir, user,
+ result == PROGRAM_CLIENT_EXIT_STATUS_SUCCESS);
}
}
user->username_hash,
user->host->ip_str,
error);
- director_flush_user_continue(0, ctx);
+ director_flush_user_continue(PROGRAM_CLIENT_EXIT_STATUS_FAILURE,
+ ctx);
return;
}
program_client_callback(pclient,
(pclient->error != PROGRAM_CLIENT_ERROR_NONE ?
- -1 : (int)pclient->exit_status),
+ PROGRAM_CLIENT_EXIT_STATUS_INTERNAL_FAILURE :
+ pclient->exit_status),
pclient->context);
}
if (pclient->error != PROGRAM_CLIENT_ERROR_NONE)
return -1;
- return (int)pclient->exit_status;
+ return pclient->exit_status;
}
#undef program_client_run_async
};
typedef void program_client_fd_callback_t(void *context, struct istream *input);
-typedef void program_client_callback_t(int, void *);
+typedef void program_client_callback_t(enum program_client_exit_status status,
+ void *context);
struct program_client *
program_client_local_create(const char *bin_path, const char *const *args,
void program_client_set_env(struct program_client *pclient,
const char *name, const char *value);
-/* Since script service cannot return system exit code, the exit value shall be
- -1, 0, or 1. -1 is internal error, 0 is failure and 1 is success */
-int program_client_run(struct program_client *pclient);
+enum program_client_exit_status
+program_client_run(struct program_client *pclient);
void program_client_run_async(struct program_client *pclient,
program_client_callback_t *, void*);
#define program_client_run_async(pclient, callback, context) \
program_client_run_async(pclient, (program_client_callback_t*)callback, \
- (char*)context - CALLBACK_TYPECHECK(callback, \
- void (*)(int, typeof(context))))
+ 1 ? context : CALLBACK_TYPECHECK(callback, \
+ void (*)(enum program_client_exit_status, typeof(context))))
#endif
test_end();
}
-static void test_program_async_callback(int result, int *ret)
+static void test_program_async_callback(enum program_client_exit_status result,
+ int *ret)
{
- *ret = result;
+ *ret = (int)result;
test_program_io_loop_stop();
}
test_end();
}
-static void test_program_async_callback(int result, int *ret)
+static void test_program_async_callback(enum program_client_exit_status result,
+ int *ret)
{
- *ret = result;
+ *ret = (int)result;
io_loop_stop(current_ioloop);
}
}
static void
-smtp_submit_sendmail_callback(int status, struct smtp_submit *subm)
+smtp_submit_sendmail_callback(enum program_client_exit_status status,
+ struct smtp_submit *subm)
{
- if (status < 0) {
+ if (status == PROGRAM_CLIENT_EXIT_STATUS_INTERNAL_FAILURE) {
smtp_submit_callback(subm, -1,
"Failed to execute sendmail");
return;
}
- if (status == 0) {
+ if (status == PROGRAM_CLIENT_EXIT_STATUS_FAILURE) {
smtp_submit_callback(subm, -1,
"Sendmail program returned error");
return;