master-settings.c revision 3af41dabbf5568989988f21c6b6b2afc236b6d47
2ronwalf/* Copyright (c) 2005-2009 Dovecot authors, see the included COPYING file */
2ronwalf
2ronwalf#include "common.h"
2ronwalf#include "array.h"
2ronwalf#include "env-util.h"
2ronwalf#include "istream.h"
2ronwalf#include "network.h"
2ronwalf#include "str.h"
2ronwalf#include "mkdir-parents.h"
2ronwalf#include "safe-mkdir.h"
2ronwalf#include "settings-parser.h"
2ronwalf#include "master-settings.h"
2ronwalf
2ronwalf#include <stddef.h>
2ronwalf#include <dirent.h>
2ronwalf#include <unistd.h>
2ronwalf#include <sys/stat.h>
2ronwalf#include <sys/wait.h>
2ronwalf
2ronwalfstatic bool master_settings_verify(void *_set, pool_t pool,
2ronwalf const char **error_r);
2ronwalf
2ronwalfextern const struct setting_parser_info service_setting_parser_info;
2ronwalf
2ronwalf#undef DEF
2ronwalf#define DEF(type, name) \
2ronwalf { type, #name, offsetof(struct file_listener_settings, name), NULL }
2ronwalf
2ronwalfstatic const struct setting_define file_listener_setting_defines[] = {
2ronwalf DEF(SET_STR, path),
2ronwalf DEF(SET_UINT_OCT, mode),
2ronwalf DEF(SET_STR, user),
2ronwalf DEF(SET_STR, group),
2ronwalf
2ronwalf SETTING_DEFINE_LIST_END
2ronwalf};
2ronwalf
2ronwalfstatic const struct file_listener_settings file_listener_default_settings = {
2ronwalf .path = "",
2ronwalf .mode = 0600,
2ronwalf .user = "",
2ronwalf .group = "",
2ronwalf};
2ronwalf
2ronwalfstatic const struct setting_parser_info file_listener_setting_parser_info = {
2ronwalf .defines = file_listener_setting_defines,
2ronwalf .defaults = &file_listener_default_settings,
2ronwalf
2ronwalf .type_offset = offsetof(struct file_listener_settings, path),
2ronwalf .struct_size = sizeof(struct file_listener_settings),
2ronwalf
2ronwalf .parent_offset = (size_t)-1,
2ronwalf .parent = &service_setting_parser_info
2ronwalf};
2ronwalf
2ronwalf#undef DEF
2ronwalf#define DEF(type, name) \
2ronwalf { type, #name, offsetof(struct inet_listener_settings, name), NULL }
2ronwalf
2ronwalfstatic const struct setting_define inet_listener_setting_defines[] = {
2ronwalf DEF(SET_STR, address),
2ronwalf DEF(SET_UINT, port),
2ronwalf DEF(SET_BOOL, ssl),
2ronwalf
2ronwalf SETTING_DEFINE_LIST_END
2ronwalf};
2ronwalf
2ronwalfstatic const struct inet_listener_settings inet_listener_default_settings = {
2ronwalf .address = "",
2ronwalf .port = 0,
2ronwalf .ssl = FALSE
2ronwalf};
2ronwalf
2ronwalfstatic const struct setting_parser_info inet_listener_setting_parser_info = {
2ronwalf .defines = inet_listener_setting_defines,
2ronwalf .defaults = &inet_listener_default_settings,
2ronwalf
2ronwalf .type_offset = (size_t)-1,
2ronwalf .struct_size = sizeof(struct inet_listener_settings),
2ronwalf
2ronwalf .parent_offset = (size_t)-1,
2ronwalf .parent = &service_setting_parser_info
2ronwalf};
2ronwalf
2ronwalf#undef DEF
2ronwalf#undef DEFLIST
2ronwalf#undef DEFLIST_UNIQUE
2ronwalf#define DEF(type, name) \
2ronwalf { type, #name, offsetof(struct service_settings, name), NULL }
2ronwalf#define DEFLIST(field, name, defines) \
2ronwalf { SET_DEFLIST, name, offsetof(struct service_settings, field), defines }
2ronwalf#define DEFLIST_UNIQUE(field, name, defines) \
2ronwalf { SET_DEFLIST_UNIQUE, name, offsetof(struct service_settings, field), defines }
2ronwalf
2ronwalfstatic const struct setting_define service_setting_defines[] = {
2ronwalf DEF(SET_STR, name),
2ronwalf DEF(SET_STR, protocol),
2ronwalf DEF(SET_STR, type),
2ronwalf DEF(SET_STR, executable),
2ronwalf DEF(SET_STR, user),
2ronwalf DEF(SET_STR, group),
2ronwalf DEF(SET_STR, privileged_group),
2ronwalf DEF(SET_STR, extra_groups),
2ronwalf DEF(SET_STR, chroot),
2ronwalf
2ronwalf DEF(SET_BOOL, drop_priv_before_exec),
2ronwalf
2ronwalf DEF(SET_UINT, process_min_avail),
2ronwalf DEF(SET_UINT, process_limit),
2ronwalf DEF(SET_UINT, client_limit),
2ronwalf DEF(SET_UINT, service_count),
2ronwalf DEF(SET_SIZE, vsz_limit),
2ronwalf
2ronwalf DEFLIST_UNIQUE(unix_listeners, "unix_listener",
2ronwalf &file_listener_setting_parser_info),
2ronwalf DEFLIST_UNIQUE(fifo_listeners, "fifo_listener",
2ronwalf &file_listener_setting_parser_info),
2ronwalf DEFLIST(inet_listeners, "inet_listener",
2ronwalf &inet_listener_setting_parser_info),
2ronwalf
2ronwalf SETTING_DEFINE_LIST_END
};
static const struct service_settings service_default_settings = {
.name = "",
.protocol = "",
.type = "",
.executable = "",
.user = "",
.group = "",
.privileged_group = "",
.extra_groups = "",
.chroot = "",
.drop_priv_before_exec = FALSE,
.process_min_avail = 0,
.process_limit = -1U,
.client_limit = 0,
.service_count = 0,
.vsz_limit = (uoff_t)-1,
.unix_listeners = ARRAY_INIT,
.fifo_listeners = ARRAY_INIT,
.inet_listeners = ARRAY_INIT
};
const struct setting_parser_info service_setting_parser_info = {
.defines = service_setting_defines,
.defaults = &service_default_settings,
.type_offset = offsetof(struct service_settings, name),
.struct_size = sizeof(struct service_settings),
.parent_offset = offsetof(struct service_settings, master_set),
.parent = &master_setting_parser_info
};
#undef DEF
#undef DEFLIST_UNIQUE
#define DEF(type, name) \
{ type, #name, offsetof(struct master_settings, name), NULL }
#define DEFLIST_UNIQUE(field, name, defines) \
{ SET_DEFLIST_UNIQUE, name, offsetof(struct master_settings, field), defines }
static const struct setting_define master_setting_defines[] = {
DEF(SET_STR, base_dir),
DEF(SET_STR, libexec_dir),
DEF(SET_STR, protocols),
DEF(SET_STR, listen),
DEF(SET_ENUM, ssl),
DEF(SET_UINT, default_process_limit),
DEF(SET_UINT, default_client_limit),
DEF(SET_SIZE, default_vsz_limit),
DEF(SET_BOOL, version_ignore),
DEF(SET_BOOL, mail_debug),
DEF(SET_BOOL, auth_debug),
DEF(SET_UINT, first_valid_uid),
DEF(SET_UINT, last_valid_uid),
DEF(SET_UINT, first_valid_gid),
DEF(SET_UINT, last_valid_gid),
DEFLIST_UNIQUE(services, "service", &service_setting_parser_info),
SETTING_DEFINE_LIST_END
};
static const struct master_settings master_default_settings = {
.base_dir = PKG_RUNDIR,
.libexec_dir = PKG_LIBEXECDIR,
.protocols = "imap pop3 lmtp",
.listen = "*, ::",
.ssl = "yes:no:required",
.default_process_limit = 100,
.default_client_limit = 1000,
.default_vsz_limit = 256*1024*1024,
.version_ignore = FALSE,
.mail_debug = FALSE,
.auth_debug = FALSE,
.first_valid_uid = 500,
.last_valid_uid = 0,
.first_valid_gid = 1,
.last_valid_gid = 0,
#ifndef CONFIG_BINARY
.services = ARRAY_INIT
#else
.services = { { &config_all_services_buf,
sizeof(struct service_settings *) } },
#endif
};
const struct setting_parser_info master_setting_parser_info = {
.module_name = "master",
.defines = master_setting_defines,
.defaults = &master_default_settings,
.type_offset = (size_t)-1,
.struct_size = sizeof(struct master_settings),
.parent_offset = (size_t)-1,
.check_func = master_settings_verify
};
/* <settings checks> */
static void fix_file_listener_paths(ARRAY_TYPE(file_listener_settings) *l,
pool_t pool, const char *base_dir,
ARRAY_TYPE(const_string) *all_listeners)
{
struct file_listener_settings *const *sets;
unsigned int base_dir_len = strlen(base_dir);
if (!array_is_created(l))
return;
array_foreach(l, sets) {
struct file_listener_settings *set = *sets;
if (*set->path != '/') {
set->path = p_strconcat(pool, base_dir, "/",
set->path, NULL);
} else if (strncmp(set->path, base_dir, base_dir_len) == 0 &&
set->path[base_dir_len] == '/') {
i_warning("You should remove base_dir prefix from "
"unix_listener: %s", set->path);
}
array_append(all_listeners, &set->path, 1);
}
}
static void add_inet_listeners(ARRAY_TYPE(inet_listener_settings) *l,
ARRAY_TYPE(const_string) *all_listeners)
{
struct inet_listener_settings *const *sets;
const char *str;
if (!array_is_created(l))
return;
array_foreach(l, sets) {
struct inet_listener_settings *set = *sets;
str = t_strdup_printf("%d:%s", set->port, set->address);
array_append(all_listeners, &str, 1);
}
}
static bool master_settings_parse_type(struct service_settings *set,
const char **error_r)
{
if (*set->type == '\0')
set->parsed_type = SERVICE_TYPE_UNKNOWN;
else if (strcmp(set->type, "log") == 0)
set->parsed_type = SERVICE_TYPE_LOG;
else if (strcmp(set->type, "config") == 0)
set->parsed_type = SERVICE_TYPE_CONFIG;
else if (strcmp(set->type, "anvil") == 0)
set->parsed_type = SERVICE_TYPE_ANVIL;
else if (strcmp(set->type, "login") == 0)
set->parsed_type = SERVICE_TYPE_LOGIN;
else {
*error_r = t_strconcat("Unknown service type: ",
set->type, NULL);
return FALSE;
}
return TRUE;
}
static void service_set_login_dump_core(struct service_settings *set)
{
const char *p;
if (set->parsed_type != SERVICE_TYPE_LOGIN)
return;
p = strstr(set->executable, " -D");
if (p != NULL && (p[3] == '\0' || p[3] == ' '))
set->login_dump_core = TRUE;
}
static bool
services_have_protocol(struct master_settings *set, const char *name)
{
struct service_settings *const *services;
array_foreach(&set->services, services) {
struct service_settings *service = *services;
if (service->protocol != NULL &&
strcmp(service->protocol, name) == 0)
return TRUE;
}
return FALSE;
}
static bool
master_settings_verify(void *_set, pool_t pool, const char **error_r)
{
struct master_settings *set = _set;
struct service_settings *const *services;
const char *const *strings;
ARRAY_TYPE(const_string) all_listeners;
unsigned int i, j, count, process_limit;
if (set->last_valid_uid != 0 &&
set->first_valid_uid > set->last_valid_uid) {
*error_r = "first_valid_uid can't be larger than last_valid_uid";
return FALSE;
}
if (set->last_valid_gid != 0 &&
set->first_valid_gid > set->last_valid_gid) {
*error_r = "first_valid_gid can't be larger than last_valid_gid";
return FALSE;
}
/* check that we have at least one service. the actual service
structure validity is checked later while creating them. */
if (!array_is_created(&set->services) ||
array_count(&set->services) == 0) {
*error_r = "No services defined";
return FALSE;
}
services = array_get(&set->services, &count);
for (i = 0; i < count; i++) {
struct service_settings *service = services[i];
if (*service->name == '\0') {
*error_r = t_strdup_printf(
"Service #%d is missing name", i);
return FALSE;
}
if (!master_settings_parse_type(service, error_r))
return FALSE;
for (j = 0; j < i; j++) {
if (strcmp(service->name, services[j]->name) == 0) {
*error_r = t_strdup_printf(
"Duplicate service name: %s",
service->name);
return FALSE;
}
}
service_set_login_dump_core(service);
}
t_array_init(&all_listeners, 64);
for (i = 0; i < count; i++) {
struct service_settings *service = services[i];
if (*service->executable == '\0') {
*error_r = t_strdup_printf("service(%s): "
"executable is empty", service->name);
return FALSE;
}
if (*service->executable != '/') {
service->executable =
p_strconcat(pool, set->libexec_dir, "/",
service->executable, NULL);
}
if (*service->chroot != '/' && *service->chroot != '\0') {
service->chroot =
p_strconcat(pool, set->base_dir, "/",
service->chroot, NULL);
}
if (service->drop_priv_before_exec &&
*service->chroot != '\0') {
*error_r = t_strdup_printf("service(%s): "
"drop_priv_before_exec=yes can't be "
"used with chroot", service->name);
return FALSE;
}
process_limit = service->process_limit;
if (process_limit == 0)
process_limit = set->default_process_limit;
if (service->process_min_avail > process_limit) {
*error_r = t_strdup_printf("service(%s): "
"process_min_avail is higher than process_limit",
service->name);
return FALSE;
}
fix_file_listener_paths(&service->unix_listeners,
pool, set->base_dir, &all_listeners);
fix_file_listener_paths(&service->fifo_listeners,
pool, set->base_dir, &all_listeners);
add_inet_listeners(&service->inet_listeners, &all_listeners);
}
/* check for duplicate listeners */
array_sort(&all_listeners, i_strcmp_p);
strings = array_get(&all_listeners, &count);
for (i = 1; i < count; i++) {
if (strcmp(strings[i-1], strings[i]) == 0) {
*error_r = t_strdup_printf("duplicate listener: %s",
strings[i]);
return FALSE;
}
}
set->protocols_split = p_strsplit(pool, set->protocols, " ");
for (i = 0; set->protocols_split[i] != NULL; i++) {
if (!services_have_protocol(set, set->protocols_split[i])) {
*error_r = t_strdup_printf("protocols: "
"Unknown protocol: %s",
set->protocols_split[i]);
return FALSE;
}
}
return TRUE;
}
/* </settings checks> */
static bool
login_want_core_dumps(const struct master_settings *set, gid_t *gid_r)
{
struct service_settings *const *services;
const char *error;
bool cores = FALSE;
uid_t uid;
*gid_r = (gid_t)-1;
array_foreach(&set->services, services) {
struct service_settings *service = *services;
if (service->parsed_type == SERVICE_TYPE_LOGIN) {
if (service->login_dump_core)
cores = TRUE;
(void)get_uidgid(service->user, &uid, gid_r, &error);
if (*service->group != '\0')
(void)get_gid(service->group, gid_r, &error);
}
}
return cores;
}
static bool
settings_have_auth_unix_listeners_in(const struct master_settings *set,
const char *dir)
{
struct service_settings *const *services;
struct file_listener_settings *const *uls;
array_foreach(&set->services, services) {
struct service_settings *service = *services;
if (array_is_created(&service->unix_listeners)) {
array_foreach(&service->unix_listeners, uls) {
struct file_listener_settings *u = *uls;
if (strncmp(u->path, dir, strlen(dir)) == 0)
return TRUE;
}
}
}
return FALSE;
}
static void unlink_sockets(const char *path, const char *prefix)
{
DIR *dirp;
struct dirent *dp;
struct stat st;
string_t *str;
unsigned int prefix_len;
dirp = opendir(path);
if (dirp == NULL) {
i_error("opendir(%s) failed: %m", path);
return;
}
prefix_len = strlen(prefix);
str = t_str_new(256);
while ((dp = readdir(dirp)) != NULL) {
if (dp->d_name[0] == '.')
continue;
if (strncmp(dp->d_name, prefix, prefix_len) != 0)
continue;
str_truncate(str, 0);
str_printfa(str, "%s/%s", path, dp->d_name);
if (lstat(str_c(str), &st) < 0) {
if (errno != ENOENT)
i_error("lstat(%s) failed: %m", str_c(str));
continue;
}
if (!S_ISSOCK(st.st_mode))
continue;
/* try to avoid unlinking sockets if someone's already
listening in them. do this only at startup, because
when SIGHUPing a child process might catch the new
connection before it notices that it's supposed
to die. null_fd == -1 check is a bit kludgy, but works.. */
if (null_fd == -1) {
int fd = net_connect_unix(str_c(str));
if (fd != -1 || errno != ECONNREFUSED) {
i_fatal("Dovecot is already running? "
"Socket already exists: %s",
str_c(str));
}
}
if (unlink(str_c(str)) < 0 && errno != ENOENT)
i_error("unlink(%s) failed: %m", str_c(str));
}
(void)closedir(dirp);
}
bool master_settings_do_fixes(const struct master_settings *set)
{
const char *login_dir, *empty_dir;
struct stat st;
gid_t gid;
/* since base dir is under /var/run by default, it may have been
deleted. */
if (mkdir_parents(set->base_dir, 0755) < 0 && errno != EEXIST) {
i_error("mkdir(%s) failed: %m", set->base_dir);
return FALSE;
}
/* allow base_dir to be a symlink, so don't use lstat() */
if (stat(set->base_dir, &st) < 0) {
i_error("stat(%s) failed: %m", set->base_dir);
return FALSE;
}
if (!S_ISDIR(st.st_mode)) {
i_error("%s is not a directory", set->base_dir);
return FALSE;
}
if ((st.st_mode & 0777) == 0777) {
/* FIXME: backwards compatibility: v1.2 was creating
base_dir with 0777 permissions.. */
i_warning("Fixing permissions of %s to be world-readable",
set->base_dir);
if (chmod(set->base_dir, 0755) < 0)
i_error("chmod(%s) failed: %m", set->base_dir);
}
/* Make sure our permanent state directory exists */
if (mkdir_parents(PKG_STATEDIR, 0750) < 0 && errno != EEXIST) {
i_error("mkdir(%s) failed: %m", PKG_STATEDIR);
return FALSE;
}
login_dir = t_strconcat(set->base_dir, "/login", NULL);
if (settings_have_auth_unix_listeners_in(set, login_dir)) {
/* we are not using external authentication, so make sure the
login directory exists with correct permissions and it's
empty. with external auth we wouldn't want to delete
existing sockets or break the permissions required by the
auth server. */
mode_t mode = login_want_core_dumps(set, &gid) ? 0770 : 0750;
if (gid != (gid_t)-1 &&
safe_mkdir(login_dir, mode, master_uid, gid) == 0) {
i_warning("Corrected permissions for login directory "
"%s", login_dir);
}
unlink_sockets(login_dir, "");
} else {
/* still make sure that login directory exists */
if (mkdir(login_dir, 0755) < 0 && errno != EEXIST) {
i_error("mkdir(%s) failed: %m", login_dir);
return FALSE;
}
}
empty_dir = t_strconcat(set->base_dir, "/empty", NULL);
if (safe_mkdir(empty_dir, 0755, master_uid, getegid()) == 0) {
i_warning("Corrected permissions for empty directory "
"%s", empty_dir);
}
return TRUE;
}