int main(int argc, char *argv[])
{
const struct setting_parser_info *set_roots[] = {
&lda_setting_parser_info,
&lmtp_setting_parser_info,
NULL
};
enum master_service_flags service_flags =
MASTER_SERVICE_FLAG_USE_SSL_SETTINGS;
enum mail_storage_service_flags storage_service_flags =
MAIL_STORAGE_SERVICE_FLAG_DISALLOW_ROOT |
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP |
MAIL_STORAGE_SERVICE_FLAG_TEMP_PRIV_DROP |
MAIL_STORAGE_SERVICE_FLAG_NO_LOG_INIT |
MAIL_STORAGE_SERVICE_FLAG_NO_IDLE_TIMEOUT |
MAIL_STORAGE_SERVICE_FLAG_AUTOEXPUNGE;
int c;
if (IS_STANDALONE()) {
service_flags |= MASTER_SERVICE_FLAG_STANDALONE |
MASTER_SERVICE_FLAG_STD_CLIENT;
} else {
service_flags |= MASTER_SERVICE_FLAG_KEEP_CONFIG_OPEN ;
}
master_service = master_service_init("lmtp", service_flags,
&argc, &argv, "D");
while ((c = master_getopt(master_service)) > 0) {
switch (c) {
case 'D':
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_ENABLE_CORE_DUMPS;
break;
default:
return FATAL_DEFAULT;
}
}
if (t_get_current_dir(&base_dir) < 0)
i_fatal("getcwd() failed: %m");
drop_privileges();
master_service_init_log(master_service,
t_strdup_printf("lmtp(%s): ", my_pid));
storage_service = mail_storage_service_init(master_service, set_roots,
storage_service_flags);
restrict_access_allow_coredumps(TRUE);
main_init();
master_service_init_finish(master_service);
master_service_run(master_service, client_connected);
main_deinit();
mail_storage_service_deinit(&storage_service);
master_service_deinit(&master_service);
return 0;
}
int main(int argc, char *argv[])
{
enum master_service_flags service_flags =
MASTER_SERVICE_FLAG_KEEP_CONFIG_OPEN;
enum mail_storage_service_flags storage_service_flags =
MAIL_STORAGE_SERVICE_FLAG_DISALLOW_ROOT |
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP |
MAIL_STORAGE_SERVICE_FLAG_TEMP_PRIV_DROP |
MAIL_STORAGE_SERVICE_FLAG_NO_IDLE_TIMEOUT;
int c;
master_service = master_service_init("indexer-worker", service_flags,
&argc, &argv, "D");
while ((c = master_getopt(master_service)) > 0) {
switch (c) {
case 'D':
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_ENABLE_CORE_DUMPS;
break;
default:
return FATAL_DEFAULT;
}
}
drop_privileges();
master_service_init_log(master_service, "indexer-worker: ");
storage_service = mail_storage_service_init(master_service, NULL,
storage_service_flags);
restrict_access_allow_coredumps(TRUE);
master_service_init_finish(master_service);
master_service_run(master_service, client_connected);
if (master_conn != NULL)
master_connection_destroy(&master_conn);
mail_storage_service_deinit(&storage_service);
master_service_deinit(&master_service);
return 0;
}
int main(int argc, char *argv[])
{
static const struct setting_parser_info *set_roots[] = {
&pop3_setting_parser_info,
NULL
};
struct master_login_settings login_set;
enum master_service_flags service_flags = 0;
enum mail_storage_service_flags storage_service_flags = 0;
const char *username = NULL;
int c;
memset(&login_set, 0, sizeof(login_set));
login_set.postlogin_timeout_secs = MASTER_POSTLOGIN_TIMEOUT_DEFAULT;
if (IS_STANDALONE() && getuid() == 0 &&
net_getpeername(1, NULL, NULL) == 0) {
printf("-ERR [SYS/PERM] pop3 binary must not be started from "
"inetd, use pop3-login instead.\n");
return 1;
}
if (IS_STANDALONE()) {
service_flags |= MASTER_SERVICE_FLAG_STANDALONE |
MASTER_SERVICE_FLAG_STD_CLIENT;
} else {
service_flags |= MASTER_SERVICE_FLAG_KEEP_CONFIG_OPEN;
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_DISALLOW_ROOT;
}
master_service = master_service_init("pop3", service_flags,
&argc, &argv, "t:u:");
while ((c = master_getopt(master_service)) > 0) {
switch (c) {
case 't':
if (str_to_uint(optarg, &login_set.postlogin_timeout_secs) < 0 ||
login_set.postlogin_timeout_secs == 0)
i_fatal("Invalid -t parameter: %s", optarg);
break;
case 'u':
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP;
username = optarg;
break;
default:
return FATAL_DEFAULT;
}
}
login_set.auth_socket_path = t_abspath("auth-master");
if (argv[optind] != NULL)
login_set.postlogin_socket_path = t_abspath(argv[optind]);
login_set.callback = login_client_connected;
login_set.failure_callback = login_client_failed;
master_service_init_finish(master_service);
master_service_set_die_callback(master_service, pop3_die);
storage_service =
mail_storage_service_init(master_service,
set_roots, storage_service_flags);
/* fake that we're running, so we know if client was destroyed
while handling its initial input */
io_loop_set_running(current_ioloop);
if (IS_STANDALONE()) {
T_BEGIN {
main_stdio_run(username);
} T_END;
} else {
struct sieve_instance *sieve_tool_init_finish
(struct sieve_tool *tool, bool init_mailstore, bool preserve_root)
{
enum mail_storage_service_flags storage_service_flags =
MAIL_STORAGE_SERVICE_FLAG_NO_CHDIR |
MAIL_STORAGE_SERVICE_FLAG_NO_LOG_INIT |
MAIL_STORAGE_SERVICE_FLAG_USE_SYSEXITS;
struct mail_storage_service_input service_input;
struct sieve_environment svenv;
const char *username = tool->username;
const char *homedir = tool->homedir;
const char *errstr;
master_service_init_finish(master_service);
if ( username == NULL ) {
sieve_tool_get_user_data(&username, &homedir);
username = tool->username = i_strdup(username);
if ( tool->homedir != NULL )
i_free(tool->homedir);
tool->homedir = i_strdup(homedir);
if ( preserve_root ) {
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_NO_RESTRICT_ACCESS;
}
} else {
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP;
}
if ( !init_mailstore )
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_NO_NAMESPACES;
memset(&service_input, 0, sizeof(service_input));
service_input.module = "mail";
service_input.service = tool->name;
service_input.username = username;
tool->storage_service = mail_storage_service_init
(master_service, NULL, storage_service_flags);
if (mail_storage_service_lookup_next
(tool->storage_service, &service_input, &tool->service_user,
&tool->mail_user_dovecot, &errstr) <= 0)
i_fatal("%s", errstr);
if ( master_service_set
(master_service, "mail_full_filesystem_access=yes") < 0 )
i_unreached();
memset((void *)&svenv, 0, sizeof(svenv));
svenv.username = username;
(void)mail_user_get_home(tool->mail_user_dovecot, &svenv.home_dir);
svenv.hostname = my_hostdomain();
svenv.base_dir = tool->mail_user_dovecot->set->base_dir;
svenv.temp_dir = tool->mail_user_dovecot->set->mail_temp_dir;
svenv.location = SIEVE_ENV_LOCATION_MS;
svenv.delivery_phase = SIEVE_DELIVERY_PHASE_POST;
/* Initialize Sieve Engine */
if ( (tool->svinst=sieve_init
(&svenv, &sieve_tool_callbacks, tool, tool->debug)) == NULL )
i_fatal("failed to initialize sieve implementation");
/* Load Sieve plugins */
if ( array_count(&tool->sieve_plugins) > 0 ) {
sieve_tool_load_plugins(tool);
}
/* Set active Sieve extensions */
if ( tool->sieve_extensions != NULL ) {
sieve_set_extensions(tool->svinst, tool->sieve_extensions);
} else if ( tool->no_config ) {
sieve_set_extensions(tool->svinst, NULL);
}
return tool->svinst;
}
static void client_connected(struct master_service_connection *conn)
{
enum mail_storage_service_flags flags =
MAIL_STORAGE_SERVICE_FLAG_NO_PLUGINS;
string_t *instr, *keys;
const char **args, *key, *value, *error, *version_line, *data_line;
struct mail_storage_service_ctx *service_ctx;
struct mail_storage_service_input input;
struct mail_storage_service_user *user;
char buf[1024];
unsigned int i, socket_count;
int fd = -1;
ssize_t ret;
alarm(SCRIPT_LOGIN_READ_TIMEOUT_SECS);
net_set_nonblock(conn->fd, FALSE);
instr = t_str_new(1024);
ret = fd_read(conn->fd, buf, sizeof(buf), &fd);
while (ret > 0) {
str_append_n(instr, buf, ret);
if (buf[ret-1] == '\n' &&
strchr(str_c(instr), '\n')[1] != '\0') {
str_truncate(instr, str_len(instr)-1);
break;
}
ret = read(conn->fd, buf, sizeof(buf));
}
version_line = str_c(instr);
data_line = strchr(version_line, '\n');
if (data_line != NULL)
version_line = t_strdup_until(version_line, data_line++);
else
version_line = NULL;
if (ret > 0 || version_line != NULL) {
if (version_line == NULL ||
!version_string_verify(version_line, "script-login",
SCRIPT_LOGIN_PROTOCOL_VERSION_MAJOR)) {
i_fatal("Client not compatible with this binary "
"(connecting to wrong socket?)");
}
}
if (ret <= 0) {
if (ret < 0)
i_fatal("read() failed: %m");
else
i_fatal("read() failed: disconnected");
}
if (fd == -1)
i_fatal("client fd not received");
alarm(0);
/* put everything to environment */
env_clean();
keys = t_str_new(256);
args = t_strsplit_tab(data_line);
if (str_array_length(args) < 3)
i_fatal("Missing input fields");
i = 0;
memset(&input, 0, sizeof(input));
input.module = "mail"; /* need to get mail_uid, mail_gid */
input.service = "script-login";
(void)net_addr2ip(args[i++], &input.local_ip);
(void)net_addr2ip(args[i++], &input.remote_ip);
input.username = args[i++];
input.userdb_fields = args + i;
env_put(t_strconcat("LOCAL_IP=", net_ip2addr(&input.local_ip), NULL));
env_put(t_strconcat("IP=", net_ip2addr(&input.remote_ip), NULL));
env_put(t_strconcat("USER="******"%s ", key);
}
}
env_put(t_strconcat(ENV_USERDB_KEYS"=", str_c(keys), NULL));
master_service_init_log(master_service,
t_strdup_printf("script-login(%s): ", input.username));
if (drop_to_userdb_privileges) {
service_ctx = mail_storage_service_init(master_service, NULL, flags);
if (mail_storage_service_lookup(service_ctx, &input, &user, &error) <= 0)
i_fatal("%s", error);
mail_storage_service_restrict_setenv(service_ctx, user);
/* we can't exec anything in a chroot */
env_remove("RESTRICT_CHROOT");
restrict_access_by_env(getenv("HOME"), TRUE);
}
if (dup2(fd, STDIN_FILENO) < 0)
i_fatal("dup2() failed: %m");
if (dup2(fd, STDOUT_FILENO) < 0)
i_fatal("dup2() failed: %m");
if (close(fd) < 0)
i_fatal("close() failed: %m");
if (conn->fd != SCRIPT_COMM_FD) {
if (dup2(conn->fd, SCRIPT_COMM_FD) < 0)
i_fatal("dup2() failed: %m");
if (close(conn->fd) < 0)
i_fatal("close() failed: %m");
}
/* close all listener sockets */
socket_count = master_service_get_socket_count(master_service);
for (i = 0; i < socket_count; i++) {
if (close(MASTER_LISTEN_FD_FIRST + i) < 0)
i_error("close(listener) failed: %m");
}
if (close(MASTER_STATUS_FD) < 0)
i_error("close(status) failed: %m");
execvp_const(exec_args[0], exec_args);
}
int main(int argc, char *argv[])
{
static const struct setting_parser_info *set_roots[] = {
&imap_urlauth_worker_setting_parser_info,
NULL
};
enum master_service_flags service_flags = 0;
enum mail_storage_service_flags storage_service_flags =
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP |
MAIL_STORAGE_SERVICE_FLAG_NO_LOG_INIT;
ARRAY_TYPE (const_string) access_apps;
const char *access_user = NULL;
int c;
if (IS_STANDALONE()) {
service_flags |= MASTER_SERVICE_FLAG_STANDALONE |
MASTER_SERVICE_FLAG_STD_CLIENT;
} else {
service_flags |= MASTER_SERVICE_FLAG_KEEP_CONFIG_OPEN;
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_DISALLOW_ROOT;
}
master_service = master_service_init("imap-urlauth-worker", service_flags,
&argc, &argv, "a:");
t_array_init(&access_apps, 4);
while ((c = master_getopt(master_service)) > 0) {
switch (c) {
case 'a': {
const char *app = t_strdup(optarg);
array_append(&access_apps, &app, 1);
break;
}
default:
return FATAL_DEFAULT;
}
}
if ( optind < argc ) {
access_user = argv[optind++];
}
if (optind != argc) {
i_fatal_status(EX_USAGE, "Unknown argument: %s", argv[optind]);
}
master_service_init_log(master_service,
t_strdup_printf("imap-urlauth[%s]: ", my_pid));
master_service_init_finish(master_service);
master_service_set_die_callback(master_service, imap_urlauth_worker_die);
random_init();
storage_service =
mail_storage_service_init(master_service,
set_roots, storage_service_flags);
/* fake that we're running, so we know if client was destroyed
while handling its initial input */
io_loop_set_running(current_ioloop);
if (IS_STANDALONE()) {
T_BEGIN {
if (array_count(&access_apps) > 0) {
(void)array_append_space(&access_apps);
main_stdio_run(access_user, array_idx(&access_apps,0));
} else {
main_stdio_run(access_user, NULL);
}
} T_END;
} else {
int main(int argc, char *argv[])
{
static const struct setting_parser_info *set_roots[] = {
&imap_setting_parser_info,
NULL
};
struct master_login_settings login_set;
enum master_service_flags service_flags = 0;
enum mail_storage_service_flags storage_service_flags = 0;
const char *username = NULL;
int c;
memset(&login_set, 0, sizeof(login_set));
login_set.postlogin_timeout_secs = MASTER_POSTLOGIN_TIMEOUT_DEFAULT;
login_set.request_auth_token = TRUE;
if (IS_STANDALONE() && getuid() == 0 &&
net_getpeername(1, NULL, NULL) == 0) {
printf("* BAD [ALERT] imap binary must not be started from "
"inetd, use imap-login instead.\n");
return 1;
}
if (IS_STANDALONE()) {
service_flags |= MASTER_SERVICE_FLAG_STANDALONE |
MASTER_SERVICE_FLAG_STD_CLIENT;
} else {
service_flags |= MASTER_SERVICE_FLAG_KEEP_CONFIG_OPEN;
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_DISALLOW_ROOT;
}
master_service = master_service_init("imap", service_flags,
&argc, &argv, "t:u:");
while ((c = master_getopt(master_service)) > 0) {
switch (c) {
case 't':
if (str_to_uint(optarg, &login_set.postlogin_timeout_secs) < 0 ||
login_set.postlogin_timeout_secs == 0)
i_fatal("Invalid -t parameter: %s", optarg);
break;
case 'u':
storage_service_flags |=
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP;
username = optarg;
break;
default:
return FATAL_DEFAULT;
}
}
master_service_set_die_callback(master_service, imap_die);
/* plugins may want to add commands, so this needs to be called early */
commands_init();
imap_fetch_handlers_init();
random_init();
storage_service =
mail_storage_service_init(master_service,
set_roots, storage_service_flags);
master_service_init_finish(master_service);
/* fake that we're running, so we know if client was destroyed
while handling its initial input */
io_loop_set_running(current_ioloop);
if (IS_STANDALONE()) {
T_BEGIN {
main_stdio_run(username);
} T_END;
} else T_BEGIN {
static void cmd_user_ver2(struct doveadm_cmd_context *cctx)
{
const char * const *optval;
const char *auth_socket_path = NULL;
struct auth_master_connection *conn;
struct authtest_input input;
const char *show_field = NULL, *expand_field = NULL;
struct mail_storage_service_ctx *storage_service = NULL;
bool have_wildcards, userdb_only = FALSE, first = TRUE;
int ret;
if (!doveadm_cmd_param_str(cctx, "socket-path", &auth_socket_path))
auth_socket_path = doveadm_settings->auth_socket_path;
(void)doveadm_cmd_param_str(cctx, "expand-field", &expand_field);
(void)doveadm_cmd_param_str(cctx, "field", &show_field);
(void)doveadm_cmd_param_bool(cctx, "userdb-only", &userdb_only);
memset(&input, 0, sizeof(input));
if (doveadm_cmd_param_array(cctx, "auth-info", &optval))
for(; *optval != NULL; optval++)
auth_user_info_parse(&input.info, *optval);
if (!doveadm_cmd_param_array(cctx, "user-mask", &optval)) {
doveadm_exit_code = EX_USAGE;
i_error("No user(s) specified");
return;
}
if (expand_field != NULL && userdb_only) {
i_error("-e can't be used with -u");
doveadm_exit_code = EX_USAGE;
return;
}
if (expand_field != NULL && show_field != NULL) {
i_error("-e can't be used with -f");
doveadm_exit_code = EX_USAGE;
return;
}
conn = doveadm_get_auth_master_conn(auth_socket_path);
have_wildcards = FALSE;
for(const char *const *val = optval; *val != NULL; val++) {
if (strchr(*val, '*') != NULL ||
strchr(*val, '?') != NULL) {
have_wildcards = TRUE;
break;
}
}
if (have_wildcards) {
cmd_user_list(conn, &input, (char*const*)optval);
auth_master_deinit(&conn);
return;
}
if (!userdb_only) {
storage_service = mail_storage_service_init(master_service, NULL,
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP |
MAIL_STORAGE_SERVICE_FLAG_NO_CHDIR |
MAIL_STORAGE_SERVICE_FLAG_NO_LOG_INIT |
MAIL_STORAGE_SERVICE_FLAG_NO_PLUGINS |
MAIL_STORAGE_SERVICE_FLAG_NO_NAMESPACES |
MAIL_STORAGE_SERVICE_FLAG_NO_RESTRICT_ACCESS);
mail_storage_service_set_auth_conn(storage_service, conn);
conn = NULL;
}
string_t *json = t_str_new(64);
o_stream_nsend_str(doveadm_print_ostream, "{");
input.info.local_ip = cctx->local_ip;
input.info.local_port = cctx->local_port;
input.info.remote_ip = cctx->remote_ip;
input.info.remote_port = cctx->remote_port;
for(const char *const *val = optval; *val != NULL; val++) {
str_truncate(json, 0);
json_append_escaped(json, *val);
input.username = *val;
if (first)
first = FALSE;
else
o_stream_nsend_str(doveadm_print_ostream, ",");
o_stream_nsend_str(doveadm_print_ostream, "\"");
o_stream_nsend_str(doveadm_print_ostream, str_c(json));
o_stream_nsend_str(doveadm_print_ostream, "\"");
o_stream_nsend_str(doveadm_print_ostream, ":{");
ret = !userdb_only ?
cmd_user_mail_input(storage_service, &input, show_field, expand_field) :
cmd_user_input(conn, &input, show_field, TRUE);
o_stream_nsend_str(doveadm_print_ostream, "}");
switch (ret) {
case -1:
doveadm_exit_code = EX_TEMPFAIL;
break;
case 0:
doveadm_exit_code = EX_NOUSER;
break;
}
}
o_stream_nsend_str(doveadm_print_ostream,"}");
if (storage_service != NULL)
mail_storage_service_deinit(&storage_service);
if (conn != NULL)
auth_master_deinit(&conn);
}
