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