static void set_cache_decisions(struct mail_cache *cache,
const char *set, const char *fields,
enum mail_cache_decision_type dec)
{
struct mail_cache_field field;
const char *const *arr;
unsigned int idx;
if (fields == NULL || *fields == '\0')
return;
for (arr = t_strsplit_spaces(fields, " ,"); *arr != NULL; arr++) {
const char *name = *arr;
idx = mail_cache_register_lookup(cache, name);
if (idx != UINT_MAX) {
field = *mail_cache_register_get_field(cache, idx);
} else if (strncasecmp(name, "hdr.", 4) == 0) {
memset(&field, 0, sizeof(field));
field.name = name;
field.type = MAIL_CACHE_FIELD_HEADER;
} else {
i_error("%s: Unknown cache field name '%s', ignoring",
set, *arr);
continue;
}
field.decision = dec;
mail_cache_register_fields(cache, &field, 1);
}
}
static void driver_mysql_parse_connect_string(struct mysql_db *db,
const char *connect_string)
{
const char *const *args, *name, *value;
const char **field;
db->ssl_cipher = "HIGH";
args = t_strsplit_spaces(connect_string, " ");
for (; *args != NULL; args++) {
value = strchr(*args, '=');
if (value == NULL) {
i_fatal("mysql: Missing value in connect string: %s",
*args);
}
name = t_strdup_until(*args, value);
value++;
field = NULL;
if (strcmp(name, "host") == 0 ||
strcmp(name, "hostaddr") == 0)
field = &db->host;
else if (strcmp(name, "user") == 0)
field = &db->user;
else if (strcmp(name, "password") == 0)
field = &db->password;
else if (strcmp(name, "dbname") == 0)
field = &db->dbname;
else if (strcmp(name, "port") == 0)
db->port = atoi(value);
else if (strcmp(name, "client_flags") == 0)
db->client_flags = atoi(value);
else if (strcmp(name, "ssl_cert") == 0)
field = &db->ssl_cert;
else if (strcmp(name, "ssl_key") == 0)
field = &db->ssl_key;
else if (strcmp(name, "ssl_ca") == 0)
field = &db->ssl_ca;
else if (strcmp(name, "ssl_ca_path") == 0)
field = &db->ssl_ca_path;
else if (strcmp(name, "ssl_cipher") == 0)
field = &db->ssl_cipher;
else if (strcmp(name, "option_file") == 0)
field = &db->option_file;
else if (strcmp(name, "option_group") == 0)
field = &db->option_group;
else
i_fatal("mysql: Unknown connect string: %s", name);
if (field != NULL)
*field = p_strdup(db->pool, value);
}
if (db->host == NULL)
i_fatal("mysql: No hosts given in connect string");
db->mysql = mysql_init(NULL);
if (db->mysql == NULL)
i_fatal("mysql_init() failed");
}
static int
imapc_settings_parse_features(struct imapc_settings *set,
const char **error_r)
{
enum imapc_features features = 0;
const struct imapc_feature_list *list;
const char *const *str;
str = t_strsplit_spaces(set->imapc_features, " ,");
for (; *str != NULL; str++) {
list = imapc_feature_list;
for (; list->name != NULL; list++) {
if (strcasecmp(*str, list->name) == 0) {
features |= list->num;
break;
}
}
if (list->name == NULL) {
*error_r = t_strdup_printf("imapc_features: "
"Unknown feature: %s", *str);
return -1;
}
}
set->parsed_features = features;
return 0;
}
static void script_execute_finish(void)
{
const char *keys_str, *username, *const *keys, *value;
string_t *reply = t_str_new(512);
ssize_t ret;
keys_str = getenv(ENV_USERDB_KEYS);
if (keys_str == NULL)
i_fatal(ENV_USERDB_KEYS" environment missing");
username = getenv("USER");
if (username == NULL)
i_fatal("USER environment missing");
str_append(reply, username);
for (keys = t_strsplit_spaces(keys_str, " "); *keys != NULL; keys++) {
value = getenv(t_str_ucase(*keys));
if (value != NULL) {
str_append_c(reply, '\t');
str_tabescape_write(reply,
t_strconcat(t_str_lcase(*keys), "=",
value, NULL));
}
}
str_append_c(reply, '\n');
ret = fd_send(SCRIPT_COMM_FD, STDOUT_FILENO,
str_data(reply), str_len(reply));
if (ret < 0)
i_fatal("fd_send() failed: %m");
else if (ret != (ssize_t)str_len(reply))
i_fatal("fd_send() sent partial output");
}
static bool fts_autoindex_exclude_match(struct mailbox *box)
{
const char *const *exclude_list;
unsigned int i;
const struct mailbox_settings *set;
const char *const *special_use;
struct mail_user *user = box->storage->user;
exclude_list = fts_exclude_get_patterns(user);
if (exclude_list == NULL)
return FALSE;
set = mailbox_settings_find(mailbox_get_namespace(box),
mailbox_get_vname(box));
special_use = set == NULL ? NULL :
t_strsplit_spaces(set->special_use, " ");
for (i = 0; exclude_list[i] != NULL; i++) {
if (exclude_list[i][0] == '\\') {
/* \Special-use flag */
if (str_array_icase_find(special_use, exclude_list[i]))
return TRUE;
} else {
/* mailbox name with wildcards */
if (wildcard_match(box->name, exclude_list[i]))
return TRUE;
}
}
return FALSE;
}
static struct passdb_module *
vpopmail_preinit(pool_t pool, const char *args)
{
static bool vauth_load_initialized = FALSE;
struct vpopmail_passdb_module *module;
const char *const *tmp;
module = p_new(pool, struct vpopmail_passdb_module, 1);
module->module.default_pass_scheme = VPOPMAIL_DEFAULT_PASS_SCHEME;
module->module.blocking = TRUE;
tmp = t_strsplit_spaces(args, " ");
for (; *tmp != NULL; tmp++) {
if (strncmp(*tmp, "cache_key=", 10) == 0) {
module->module.default_cache_key =
auth_cache_parse_key(pool, *tmp + 10);
} else if (strncmp(*tmp, "webmail=", 8) == 0) {
if (net_addr2ip(*tmp + 8, &module->webmail_ip) < 0)
i_fatal("vpopmail: Invalid webmail IP address");
} else if (strcmp(*tmp, "blocking=no") == 0) {
module->module.blocking = FALSE;
} else {
i_fatal("passdb vpopmail: Unknown setting: %s", *tmp);
}
}
if (!vauth_load_initialized) {
vauth_load_initialized = TRUE;
if (vauth_open(0) != 0)
i_fatal("vpopmail: vauth_open() failed");
}
return &module->module;
}
static void cmd_mailbox_status_init(struct doveadm_mail_cmd_context *_ctx,
const char *const args[])
{
struct status_cmd_context *ctx = (struct status_cmd_context *)_ctx;
const char *fields = args[0];
if (fields == NULL || args[1] == NULL)
doveadm_mail_help_name("mailbox status");
status_parse_fields(ctx, t_strsplit_spaces(fields, " "));
ctx->search_args = doveadm_mail_mailbox_search_args_build(args+1);
if (!ctx->total_sum) {
doveadm_print_header("mailbox", "mailbox",
DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
}
if ((ctx->status_items & STATUS_MESSAGES) != 0)
doveadm_print_header_simple("messages");
if ((ctx->status_items & STATUS_RECENT) != 0)
doveadm_print_header_simple("recent");
if ((ctx->status_items & STATUS_UIDNEXT) != 0)
doveadm_print_header_simple("uidnext");
if ((ctx->status_items & STATUS_UIDVALIDITY) != 0)
doveadm_print_header_simple("uidvalidity");
if ((ctx->status_items & STATUS_UNSEEN) != 0)
doveadm_print_header_simple("unseen");
if ((ctx->status_items & STATUS_HIGHESTMODSEQ) != 0)
doveadm_print_header_simple("highestmodseq");
if ((ctx->metadata_items & MAILBOX_METADATA_VIRTUAL_SIZE) != 0)
doveadm_print_header_simple("vsize");
if ((ctx->metadata_items & MAILBOX_METADATA_GUID) != 0)
doveadm_print_header_simple("guid");
}
static int fts_filter_stopwords_read_list(struct fts_filter_stopwords *filter,
const char **error_r)
{
struct istream *input;
const char *line, **words, *path;
int ret = 0;
path = t_strdup_printf(STOPWORDS_FILE_FORMAT,
filter->stopwords_dir, filter->lang->name);
input = i_stream_create_file(path, IO_BLOCK_SIZE);
while ((line = i_stream_read_next_line(input)) != NULL) T_BEGIN {
line = t_strcut(line, STOPWORDS_COMMENT_CHAR1);
line = t_strcut(line, STOPWORDS_COMMENT_CHAR2);
words = t_strsplit_spaces(line, " \t");
for (; *words != NULL; words++) {
const char *word = p_strdup(filter->pool, *words);
hash_table_insert(filter->stopwords, word, word);
}
} T_END;
if (input->stream_errno != 0) {
*error_r = t_strdup_printf("Failed to read stopword list %s: %s",
path, i_stream_get_error(input));
ret = -1;
}
i_stream_destroy(&input);
return ret;
}
static int
imap_settings_parse_workarounds(struct imap_settings *set,
const char **error_r)
{
enum imap_client_workarounds client_workarounds = 0;
const struct imap_client_workaround_list *list;
const char *const *str;
str = t_strsplit_spaces(set->imap_client_workarounds, " ,");
for (; *str != NULL; str++) {
list = imap_client_workaround_list;
for (; list->name != NULL; list++) {
if (strcasecmp(*str, list->name) == 0) {
client_workarounds |= list->num;
break;
}
}
if (list->name == NULL) {
*error_r = t_strdup_printf("imap_client_workarounds: "
"Unknown workaround: %s", *str);
return -1;
}
}
set->parsed_workarounds = client_workarounds;
return 0;
}
static void
stats_metric_settings_to_query(const struct stats_metric_settings *set,
struct event_filter_query *query_r)
{
i_zero(query_r);
/* generate fields for event filter */
if (array_is_created(&set->filter)) {
struct event_filter_field *filter_fields;
const char *const *filters;
unsigned int i, count;
filters = array_get(&set->filter, &count);
i_assert(count % 2 == 0);
count /= 2;
filter_fields = t_new(struct event_filter_field, count + 1);
for (i = 0; i < count; i++) {
filter_fields[i].key = filters[i*2];
filter_fields[i].value = filters[i*2+1];
}
query_r->fields = filter_fields;
}
/* add query to the event filter */
query_r->categories = t_strsplit_spaces(set->categories, " ");
query_r->name = set->event_name;
query_r->source_filename = t_strcut(set->source_location, ':');
query_r->source_linenum = set->parsed_source_linenum;
}
/* <settings checks> */
static bool
master_service_ssl_settings_check(void *_set, pool_t pool ATTR_UNUSED,
const char **error_r)
{
struct master_service_ssl_settings *set = _set;
if (strcmp(set->ssl, "no") == 0) {
/* disabled */
return TRUE;
}
#ifndef HAVE_SSL
*error_r = t_strdup_printf("SSL support not compiled in but ssl=%s",
set->ssl);
return FALSE;
#else
/* we get called from many different tools, possibly with -O parameter,
and few of those tools care about SSL settings. so don't check
ssl_cert/ssl_key/etc validity here except in doveconf, because it
usually is just an extra annoyance. */
#ifdef CONFIG
if (*set->ssl_cert == '\0') {
*error_r = "ssl enabled, but ssl_cert not set";
return FALSE;
}
if (*set->ssl_key == '\0') {
*error_r = "ssl enabled, but ssl_key not set";
return FALSE;
}
#endif
if (set->ssl_verify_client_cert && *set->ssl_ca == '\0') {
*error_r = "ssl_verify_client_cert set, but ssl_ca not";
return FALSE;
}
/* Now explode the ssl_options string into individual flags */
/* First set them all to defaults */
set->parsed_opts.compression = TRUE;
set->parsed_opts.tickets = TRUE;
/* Then modify anything specified in the string */
const char **opts = t_strsplit_spaces(set->ssl_options, ", ");
const char *opt;
while ((opt = *opts++) != NULL) {
if (strcasecmp(opt, "no_compression") == 0) {
set->parsed_opts.compression = FALSE;
} else if (strcasecmp(opt, "no_ticket") == 0) {
set->parsed_opts.tickets = FALSE;
} else {
*error_r = t_strdup_printf("ssl_options: unknown flag: '%s'",
opt);
return FALSE;
}
}
return TRUE;
#endif
}
int main(int argc, char *argv[])
{
ARRAY_TYPE(const_string) aenvs;
const char *binary;
const char *const *envs;
int c, i;
master_service = master_service_init("script", 0, &argc, &argv, "+e:");
t_array_init(&aenvs, 16);
while ((c = master_getopt(master_service)) > 0) {
switch (c) {
case 'e':
envs = t_strsplit_spaces(optarg,", \t");
while (*envs != NULL) {
array_append(&aenvs, envs, 1);
envs++;
}
break;
default:
return FATAL_DEFAULT;
}
}
argc -= optind;
argv += optind;
array_append_zero(&aenvs);
accepted_envs = p_strarray_dup(default_pool, array_idx(&aenvs, 0));
master_service_init_log(master_service, "script: ");
if (argv[0] == NULL)
i_fatal("Missing script path");
restrict_access_by_env(RESTRICT_ACCESS_FLAG_ALLOW_ROOT, NULL);
restrict_access_allow_coredumps(TRUE);
master_service_init_finish(master_service);
master_service_set_service_count(master_service, 1);
if (argv[0][0] == '/')
binary = argv[0];
else
binary = t_strconcat(PKG_LIBEXECDIR"/", argv[0], NULL);
i_array_init(&exec_args, argc + 16);
array_append(&exec_args, &binary, 1);
for (i = 1; i < argc; i++) {
const char *arg = argv[i];
array_append(&exec_args, &arg, 1);
}
master_service_run(master_service, client_connected);
array_free(&exec_args);
i_free(accepted_envs);
master_service_deinit(&master_service);
return 0;
}
int openssl_get_protocol_options(const char *protocols)
{
const char *const *tmp;
int proto, op = 0, include = 0, exclude = 0;
bool neg;
tmp = t_strsplit_spaces(protocols, " ");
for (; *tmp != NULL; tmp++) {
const char *name = *tmp;
if (*name != '!')
neg = FALSE;
else {
name++;
neg = TRUE;
}
if (strcasecmp(name, SSL_TXT_SSLV2) == 0)
proto = DOVECOT_SSL_PROTO_SSLv2;
else if (strcasecmp(name, SSL_TXT_SSLV3) == 0)
proto = DOVECOT_SSL_PROTO_SSLv3;
else if (strcasecmp(name, SSL_TXT_TLSV1) == 0)
proto = DOVECOT_SSL_PROTO_TLSv1;
#ifdef SSL_TXT_TLSV1_1
else if (strcasecmp(name, SSL_TXT_TLSV1_1) == 0)
proto = DOVECOT_SSL_PROTO_TLSv1_1;
#endif
#ifdef SSL_TXT_TLSV1_2
else if (strcasecmp(name, SSL_TXT_TLSV1_2) == 0)
proto = DOVECOT_SSL_PROTO_TLSv1_2;
#endif
else {
i_fatal("Invalid ssl_protocols setting: "
"Unknown protocol '%s'", name);
}
if (neg)
exclude |= proto;
else
include |= proto;
}
if (include != 0) {
/* exclude everything, except those that are included
(and let excludes still override those) */
exclude |= DOVECOT_SSL_PROTO_ALL & ~include;
}
if ((exclude & DOVECOT_SSL_PROTO_SSLv2) != 0) op |= SSL_OP_NO_SSLv2;
if ((exclude & DOVECOT_SSL_PROTO_SSLv3) != 0) op |= SSL_OP_NO_SSLv3;
if ((exclude & DOVECOT_SSL_PROTO_TLSv1) != 0) op |= SSL_OP_NO_TLSv1;
#ifdef SSL_OP_NO_TLSv1_1
if ((exclude & DOVECOT_SSL_PROTO_TLSv1_1) != 0) op |= SSL_OP_NO_TLSv1_1;
#endif
#ifdef SSL_OP_NO_TLSv1_2
if ((exclude & DOVECOT_SSL_PROTO_TLSv1_2) != 0) op |= SSL_OP_NO_TLSv1_2;
#endif
return op;
}
static const char *
file_lock_find_proc_locks(int lock_fd ATTR_UNUSED)
{
/* do anything except Linux support this? don't bother trying it for
OSes we don't know about. */
#ifdef __linux__
static bool have_proc_locks = TRUE;
struct stat st;
char node_buf[MAX_INT_STRLEN*3 + 2 + 1];
struct istream *input;
const char *line, *lock_type = "";
pid_t pid = 0;
int fd;
if (!have_proc_locks)
return FALSE;
if (fstat(lock_fd, &st) < 0)
return "";
i_snprintf(node_buf, sizeof(node_buf), "%02x:%02x:%llu",
major(st.st_dev), minor(st.st_dev),
(unsigned long long)st.st_ino);
fd = open("/proc/locks", O_RDONLY);
if (fd == -1) {
have_proc_locks = FALSE;
return "";
}
input = i_stream_create_fd_autoclose(&fd, 512);
while (pid == 0 && (line = i_stream_read_next_line(input)) != NULL) T_BEGIN {
const char *const *args = t_strsplit_spaces(line, " ");
/* number: FLOCK/POSIX ADVISORY READ/WRITE pid
major:minor:inode region-start region-end */
if (str_array_length(args) < 8)
continue;
if (strcmp(args[5], node_buf) == 0) {
lock_type = strcmp(args[3], "READ") == 0 ?
"READ" : "WRITE";
if (str_to_pid(args[4], &pid) < 0)
pid = 0;
}
} T_END;
i_stream_destroy(&input);
if (pid == 0) {
/* not found */
return "";
}
if (pid == getpid())
return " (BUG: lock is held by our own process)";
return t_strdup_printf(" (%s lock held by pid %ld)", lock_type, (long)pid);
#else
return "";
#endif
}
static void copy_update_trashed(struct client *client, struct mailbox *box,
unsigned int count)
{
const struct mailbox_settings *set;
set = mailbox_settings_find(mailbox_get_namespace(box),
mailbox_get_vname(box));
if (set != NULL && set->special_use[0] != '\0' &&
str_array_icase_find(t_strsplit_spaces(set->special_use, " "),
"\\Trash"))
client->trashed_count += count;
}
static enum mail_log_event mail_log_parse_events(const char *str)
{
const char *const *tmp;
static enum mail_log_event event, events = 0;
for (tmp = t_strsplit_spaces(str, ", "); *tmp != NULL; tmp++) {
event = mail_log_event_find(*tmp);
if (event == 0)
i_fatal("Unknown event in mail_log_events: '%s'", *tmp);
events |= event;
}
return events;
}
static enum mail_log_field mail_log_parse_fields(const char *str)
{
const char *const *tmp;
static enum mail_log_field field, fields = 0;
for (tmp = t_strsplit_spaces(str, ", "); *tmp != NULL; tmp++) {
field = mail_log_field_find(*tmp);
if (field == 0)
i_fatal("Unknown field in mail_log_fields: '%s'", *tmp);
fields |= field;
}
return fields;
}
struct userdb_template *
userdb_template_build(pool_t pool, const char *userdb_name, const char *args)
{
struct userdb_template *tmpl;
const char *const *tmp, *key, *value, *nonull_value;
uid_t uid;
gid_t gid;
tmpl = p_new(pool, struct userdb_template, 1);
tmp = t_strsplit_spaces(args, " ");
p_array_init(&tmpl->args, pool, str_array_length(tmp));
for (; *tmp != NULL; tmp++) {
value = strchr(*tmp, '=');
if (value == NULL)
key = *tmp;
else
key = t_strdup_until(*tmp, value++);
nonull_value = value == NULL ? "" : value;
if (strcasecmp(key, "uid") == 0) {
uid = userdb_parse_uid(NULL, nonull_value);
if (uid == (uid_t)-1) {
i_fatal("%s userdb: Invalid uid: %s",
userdb_name, nonull_value);
}
value = dec2str(uid);
} else if (strcasecmp(key, "gid") == 0) {
gid = userdb_parse_gid(NULL, nonull_value);
if (gid == (gid_t)-1) {
i_fatal("%s userdb: Invalid gid: %s",
userdb_name, nonull_value);
}
value = dec2str(gid);
} else if (*key == '\0') {
i_fatal("%s userdb: Empty key (=%s)",
userdb_name, nonull_value);
}
key = p_strdup(pool, key);
value = p_strdup(pool, value);
array_append(&tmpl->args, &key, 1);
array_append(&tmpl->args, &value, 1);
}
return tmpl;
}
const char *imap_id_args_get_log_reply(const struct imap_arg *args,
const char *settings)
{
const char *const *keys, *key, *value;
string_t *reply;
bool log_all;
if (settings == NULL || *settings == '\0')
return NULL;
if (!imap_arg_get_list(args, &args))
return NULL;
log_all = strcmp(settings, "*") == 0;
reply = t_str_new(256);
keys = t_strsplit_spaces(settings, " ");
while (!IMAP_ARG_IS_EOL(&args[0]) &&
!IMAP_ARG_IS_EOL(&args[1])) {
if (!imap_arg_get_string(args, &key)) {
/* broken input */
args += 2;
continue;
}
args++;
if (strlen(key) > 30) {
/* broken: ID spec requires fields to be max. 30
octets */
args++;
continue;
}
if (log_all || str_array_icase_find(keys, key)) {
if (!imap_arg_get_nstring(args, &value))
value = "";
else if (value == NULL)
value = "NIL";
if (str_len(reply) > 0)
str_append(reply, ", ");
str_append(reply, str_sanitize(key, 30));
str_append_c(reply, '=');
str_append(reply, str_sanitize(value, 80));
}
args++;
}
return str_len(reply) == 0 ? NULL : str_c(reply);
}
static struct userdb_module *
userdb_lua_preinit(pool_t pool, const char *args)
{
struct dlua_userdb_module *module;
const char *cache_key = "%u";
bool blocking = TRUE;
module = p_new(pool, struct dlua_userdb_module, 1);
const char *const *fields = t_strsplit_spaces(args, " ");
while(*fields != NULL) {
if (str_begins(*fields, "file=")) {
module->file = p_strdup(pool, (*fields)+5);
} else if (str_begins(*fields, "blocking=")) {
const char *value = (*fields)+9;
if (strcmp(value, "yes") == 0) {
blocking = TRUE;
} else if (strcmp(value, "no") == 0) {
blocking = FALSE;
} else {
i_fatal("Invalid value %s. "
"Field blocking must be yes or no",
value);
}
} else if (str_begins(*fields, "cache_key=")) {
if (*((*fields)+10) != '\0')
cache_key = (*fields)+10;
else /* explicitly disable auth caching for lua */
cache_key = NULL;
} else {
i_fatal("Unsupported parameter %s", *fields);
}
fields++;
}
if (module->file == NULL)
i_fatal("userdb-lua: Missing mandatory file= parameter");
module->module.blocking = blocking;
if (cache_key != NULL) {
module->module.default_cache_key =
auth_cache_parse_key(pool, cache_key);
}
return &module->module;
}
static int
fts_notmuch_plugin_init_settings(struct mail_user *user,
struct fts_notmuch_settings *set, const char *str)
{
const char *const *tmp;
if (str == NULL)
str = "";
for (tmp = t_strsplit_spaces(str, " "); *tmp != NULL; tmp++) {
if (strcmp(*tmp, "debug") == 0) {
set->debug = TRUE;
} else {
i_error("fts_notmuch: Invalid setting: %s", *tmp);
return -1;
}
}
return 0;
}
static void script_execute_finish(void)
{
const char *keys_str, *username, *const *keys, *value;
string_t *reply = t_str_new(512);
ssize_t ret;
keys_str = getenv(ENV_USERDB_KEYS);
if (keys_str == NULL)
i_fatal(ENV_USERDB_KEYS" environment missing");
username = getenv("USER");
if (username == NULL)
i_fatal("USER environment missing");
str_append(reply, username);
for (keys = t_strsplit_spaces(keys_str, " "); *keys != NULL; keys++) {
value = getenv(t_str_ucase(*keys));
if (value != NULL) {
str_append_c(reply, '\t');
str_append_tabescaped(reply,
t_strconcat(t_str_lcase(*keys), "=",
value, NULL));
}
}
str_append_c(reply, '\n');
/* finish by sending the fd to the mail process */
ret = fd_send(SCRIPT_COMM_FD, STDOUT_FILENO,
str_data(reply), str_len(reply));
if (ret == (ssize_t)str_len(reply)) {
/* success */
} else {
if (ret < 0)
i_error("fd_send() failed: %m");
else
i_error("fd_send() sent partial output");
/* exit with 0 even though we failed. non-0 exit just makes
master log an unnecessary error. */
}
}
static bool client_is_trusted(struct client *client)
{
const char *const *net;
struct ip_addr net_ip;
unsigned int bits;
if (client->set->login_trusted_networks == NULL)
return FALSE;
net = t_strsplit_spaces(client->set->login_trusted_networks, ", ");
for (; *net != NULL; net++) {
if (net_parse_range(*net, &net_ip, &bits) < 0) {
i_error("login_trusted_networks: "
"Invalid network '%s'", *net);
break;
}
if (net_is_in_network(&client->ip, &net_ip, bits))
return TRUE;
}
return FALSE;
}
struct mechanisms_register *
mech_register_init(const struct auth_settings *set)
{
struct mechanisms_register *reg;
const struct mech_module *mech;
const char *const *mechanisms;
pool_t pool;
pool = pool_alloconly_create("mechanisms register", 1024);
reg = p_new(pool, struct mechanisms_register, 1);
reg->pool = pool;
reg->set = set;
reg->handshake = str_new(pool, 512);
mechanisms = t_strsplit_spaces(set->mechanisms, " ");
for (; *mechanisms != NULL; mechanisms++) {
const char *name = *mechanisms;
if (strcasecmp(name, "ANONYMOUS") == 0) {
if (*set->anonymous_username == '\0') {
i_fatal("ANONYMOUS listed in mechanisms, "
"but anonymous_username not set");
}
}
mech = mech_module_find(name);
if (mech == NULL) {
/* maybe it's a plugin. try to load it. */
auth_module_load(mech_get_plugin_name(name));
mech = mech_module_find(name);
}
if (mech == NULL)
i_fatal("Unknown authentication mechanism '%s'", name);
mech_register_add(reg, mech);
}
if (reg->modules == NULL)
i_fatal("No authentication mechanisms configured");
return reg;
}
static bool
mailbox_special_use_check(struct mailbox_settings *set, pool_t pool,
const char **error_r)
{
const char *const *uses, *str;
unsigned int i;
uses = t_strsplit_spaces(set->special_use, " ");
for (i = 0; uses[i] != NULL; i++) {
if (!mailbox_special_use_exists(uses[i])) {
*error_r = t_strdup_printf(
"mailbox %s: unknown special_use: %s",
set->name, uses[i]);
return FALSE;
}
}
/* make sure there are no extra spaces */
str = t_strarray_join(uses, " ");
if (strcmp(str, set->special_use) != 0)
set->special_use = p_strdup(pool, str);
return TRUE;
}
static void stats_metrics_add_set(struct stats_metrics *metrics,
const struct stats_metric_settings *set)
{
struct event_filter_query query;
struct metric *metric;
const char *const *fields;
metric = p_new(metrics->pool, struct metric, 1);
metric->name = p_strdup(metrics->pool, set->name);
metric->duration_stats = stats_dist_init();
fields = t_strsplit_spaces(set->fields, " ");
metric->fields_count = str_array_length(fields);
if (metric->fields_count > 0) {
metric->fields = p_new(metrics->pool, struct metric_field,
metric->fields_count);
for (unsigned int i = 0; i < metric->fields_count; i++) {
metric->fields[i].field_key =
p_strdup(metrics->pool, fields[i]);
metric->fields[i].stats = stats_dist_init();
}
}
static void ext_editheader_config_headers
(struct sieve_instance *svinst,
struct ext_editheader_config *ext_config,
const char *setting, bool forbid_add, bool forbid_delete)
{
const char *setval;
setval = sieve_setting_get(svinst, setting);
if ( setval != NULL ) {
const char **headers = t_strsplit_spaces(setval, " \t");
while ( *headers != NULL ) {
struct ext_editheader_header *header;
if ( !rfc2822_header_field_name_verify
(*headers, strlen(*headers)) ) {
sieve_sys_warning(svinst, "editheader: "
"setting %s contains invalid header field name "
"`%s' (ignored)", setting, *headers);
continue;
}
header=ext_editheader_config_header_find(ext_config, *headers);
if ( header == NULL ) {
header = array_append_space(&ext_config->headers);
header->name = p_strdup(ext_config->pool, *headers);
}
if (forbid_add)
header->forbid_add = TRUE;
if (forbid_delete)
header->forbid_delete = TRUE;
headers++;
}
}
}
static bool config_filter_match_rest(const struct config_filter *mask,
const struct config_filter *filter)
{
if (mask->local_name != NULL) {
if (filter->local_name == NULL)
return FALSE;
/* Handle multiple names seperated by spaces in local_name
* Ex: local_name "mail.domain.tld domain.tld mx.domain.tld" { ... } */
const char *const *local_name = t_strsplit_spaces(mask->local_name, " ");
bool matched = FALSE;
for (; *local_name != NULL; local_name++) {
if (dns_match_wildcard(filter->local_name, *local_name) == 0) {
matched = TRUE;
break;
}
}
if (!matched)
return FALSE;
}
/* FIXME: it's not comparing full masks */
if (mask->remote_bits != 0) {
if (filter->remote_bits == 0)
return FALSE;
if (!net_is_in_network(&filter->remote_net, &mask->remote_net,
mask->remote_bits))
return FALSE;
}
if (mask->local_bits != 0) {
if (filter->local_bits == 0)
return FALSE;
if (!net_is_in_network(&filter->local_net, &mask->local_net,
mask->local_bits))
return FALSE;
}
return TRUE;
}
struct passdb_template *passdb_template_build(pool_t pool, const char *args)
{
struct passdb_template *tmpl;
const char *const *tmp, *key, *value;
tmpl = p_new(pool, struct passdb_template, 1);
tmp = t_strsplit_spaces(args, " ");
p_array_init(&tmpl->args, pool, str_array_length(tmp));
for (; *tmp != NULL; tmp++) {
value = strchr(*tmp, '=');
if (value == NULL)
key = *tmp;
else
key = t_strdup_until(*tmp, value++);
key = p_strdup(pool, key);
value = p_strdup(pool, value);
array_append(&tmpl->args, &key, 1);
array_append(&tmpl->args, &value, 1);
}
return tmpl;
}
auth_settings_set_self_ips(struct auth_settings *set, pool_t pool,
const char **error_r)
{
const char *const *tmp;
ARRAY(struct ip_addr) ips_array;
struct ip_addr *ips;
unsigned int ips_count;
int ret;
if (*set->proxy_self == '\0') {
set->proxy_self_ips = p_new(pool, struct ip_addr, 1);
return TRUE;
}
p_array_init(&ips_array, pool, 4);
tmp = t_strsplit_spaces(set->proxy_self, " ");
for (; *tmp != NULL; tmp++) {
ret = net_gethostbyname(*tmp, &ips, &ips_count);
if (ret != 0) {
*error_r = t_strdup_printf("auth_proxy_self_ips: "
"gethostbyname(%s) failed: %s",
*tmp, net_gethosterror(ret));
}
array_append(&ips_array, ips, ips_count);
}
array_append_zero(&ips_array);
set->proxy_self_ips = array_idx(&ips_array, 0);
return TRUE;
}
static bool
