struct mail_index *mail_index_alloc(const char *dir, const char *prefix)
{
struct mail_index *index;
index = i_new(struct mail_index, 1);
index->dir = i_strdup(dir);
index->prefix = i_strdup(prefix);
index->fd = -1;
index->extension_pool =
pool_alloconly_create(MEMPOOL_GROWING"index extension", 1024);
p_array_init(&index->extensions, index->extension_pool, 5);
i_array_init(&index->sync_lost_handlers, 4);
i_array_init(&index->module_contexts,
I_MIN(5, mail_index_module_register.id));
index->mode = 0600;
index->gid = (gid_t)-1;
index->lock_method = FILE_LOCK_METHOD_FCNTL;
index->max_lock_timeout_secs = UINT_MAX;
index->keywords_ext_id =
mail_index_ext_register(index, MAIL_INDEX_EXT_KEYWORDS,
128, 2, 1);
index->keywords_pool = pool_alloconly_create("keywords", 512);
i_array_init(&index->keywords, 16);
hash_table_create(&index->keywords_hash, index->keywords_pool, 0,
strcase_hash, strcasecmp);
index->log = mail_transaction_log_alloc(index);
mail_index_modseq_init(index);
return index;
}
static void
parse_content_type(struct message_decoder_context *ctx,
struct message_header_line *hdr)
{
struct rfc822_parser_context parser;
const char *const *results;
string_t *str;
if (ctx->content_type != NULL)
return;
rfc822_parser_init(&parser, hdr->full_value, hdr->full_value_len, NULL);
rfc822_skip_lwsp(&parser);
str = t_str_new(64);
if (rfc822_parse_content_type(&parser, str) < 0)
return;
ctx->content_type = i_strdup(str_c(str));
rfc2231_parse(&parser, &results);
for (; *results != NULL; results += 2) {
if (strcasecmp(results[0], "charset") == 0) {
ctx->content_charset = i_strdup(results[1]);
break;
}
}
}
int imap_msgpart_url_create(struct mail_user *user, const struct imap_url *url,
struct imap_msgpart_url **mpurl_r,
const char **error_r)
{
const char *section = url->section == NULL ? "" : url->section;
struct imap_msgpart_url *mpurl;
struct imap_msgpart *msgpart;
i_assert(url->mailbox != NULL && url->uid != 0 &&
url->search_program == NULL);
if (imap_msgpart_parse(section, &msgpart) < 0) {
*error_r = "Invalid section";
return -1;
}
mpurl = i_new(struct imap_msgpart_url, 1);
mpurl->part = msgpart;
mpurl->user = user;
mpurl->mailbox = i_strdup(url->mailbox);
mpurl->uidvalidity = url->uidvalidity;
mpurl->uid = url->uid;
if (url->section != NULL)
mpurl->section = i_strdup(url->section);
mpurl->partial_offset = url->partial_offset;
mpurl->partial_size = url->partial_size;
imap_msgpart_set_partial(msgpart, url->partial_offset,
url->partial_size == 0 ?
(uoff_t)-1 : url->partial_size);
*mpurl_r = mpurl;
return 0;
}
struct imap_urlauth_context *
imap_urlauth_init(struct mail_user *user,
const struct imap_urlauth_config *config)
{
struct imap_urlauth_context *uctx;
unsigned int timeout;
i_assert(*config->url_host != '\0');
uctx = i_new(struct imap_urlauth_context, 1);
uctx->user = user;
uctx->url_host = i_strdup(config->url_host);
uctx->url_port = config->url_port;
if (config->access_anonymous)
uctx->access_user = i_strdup("anonymous");
else
uctx->access_user = i_strdup(config->access_user);
uctx->access_anonymous = config->access_anonymous;
if (config->access_applications != NULL &&
*config->access_applications != NULL) {
uctx->access_applications =
p_strarray_dup(default_pool,
config->access_applications);
timeout = IMAP_URLAUTH_SPECIAL_TIMEOUT_MSECS;
} else {
timeout = IMAP_URLAUTH_NORMAL_TIMEOUT_MSECS;
}
if (config->socket_path != NULL) {
uctx->conn = imap_urlauth_connection_init(config->socket_path,
user, config->session_id, timeout);
}
return uctx;
}
/*
* 合并路径，如果filename传入的是绝对路径，则直接返回filename的拷贝。
* base - 基目录
* basesz - base的字节长度，传入-1的话，将使用strlen()函数读取。
* filename - 文件名字
* 使用完后，需调用pcs_free来释放返回值
*/
char *combin_path(const char *base, int basesz, const char *filename)
{
char *result = NULL;
#ifdef WIN32
char buf[MAX_PATH] = "";
char *p = i_strdup(base, basesz),
*f = i_strdup(filename, -1);
p = fix_win_path(p);
f = fix_win_path(f);
if (PathCombine(buf, p, f)) {
result = i_strdup(buf, -1);
}
pcs_free(p);
pcs_free(f);
#else
if (basesz == -1) {
result = combin_net_disk_path(base, filename);
}
else {
char *p = i_strdup(base, basesz);
result = combin_net_disk_path(p, filename);
pcs_free(p);
}
#endif
return result;
}
struct ostream *iostream_temp_create_sized(const char *temp_path_prefix,
enum iostream_temp_flags flags,
const char *name,
size_t max_mem_size)
{
struct temp_ostream *tstream;
struct ostream *output;
tstream = i_new(struct temp_ostream, 1);
tstream->ostream.ostream.blocking = TRUE;
tstream->ostream.sendv = o_stream_temp_sendv;
tstream->ostream.send_istream = o_stream_temp_send_istream;
tstream->ostream.write_at = o_stream_temp_write_at;
tstream->ostream.seek = o_stream_temp_seek;
tstream->ostream.iostream.close = o_stream_temp_close;
tstream->temp_path_prefix = i_strdup(temp_path_prefix);
tstream->flags = flags;
tstream->max_mem_size = max_mem_size;
tstream->buf = buffer_create_dynamic(default_pool, 8192);
tstream->fd = -1;
output = o_stream_create(&tstream->ostream, NULL, -1);
tstream->name = i_strdup(name);
if (name[0] == '\0') {
o_stream_set_name(output, t_strdup_printf(
"(temp iostream in %s)", temp_path_prefix));
} else {
o_stream_set_name(output, t_strdup_printf(
"(temp iostream in %s for %s)", temp_path_prefix, name));
}
return output;
}
static int proxy_start(struct client *client,
const struct client_auth_reply *reply)
{
struct login_proxy_settings proxy_set;
i_assert(reply->destuser != NULL);
i_assert(!client->destroyed);
client->v.proxy_reset(client);
if (reply->password == NULL) {
client_log_err(client, "proxy: password not given");
client_proxy_error(client, PROXY_FAILURE_MSG);
return -1;
}
if (reply->host == NULL || *reply->host == '\0') {
client_log_err(client, "proxy: host not given");
client_proxy_error(client, PROXY_FAILURE_MSG);
return -1;
}
i_assert(client->refcount > 1);
if (client->destroyed) {
/* connection_queue_add() decided that we were the oldest
connection and killed us. */
return -1;
}
if (login_proxy_is_ourself(client, reply->host, reply->port,
reply->destuser)) {
client_log_err(client, "Proxying loops to itself");
client_proxy_error(client, PROXY_FAILURE_MSG);
return -1;
}
memset(&proxy_set, 0, sizeof(proxy_set));
proxy_set.host = reply->host;
if (reply->hostip != NULL &&
net_addr2ip(reply->hostip, &proxy_set.ip) < 0)
proxy_set.ip.family = 0;
proxy_set.port = reply->port;
proxy_set.connect_timeout_msecs = reply->proxy_timeout_msecs;
proxy_set.notify_refresh_secs = reply->proxy_refresh_secs;
proxy_set.ssl_flags = reply->ssl_flags;
if (login_proxy_new(client, &proxy_set, proxy_input) < 0) {
client_proxy_error(client, PROXY_FAILURE_MSG);
return -1;
}
client->proxy_user = i_strdup(reply->destuser);
client->proxy_master_user = i_strdup(reply->master_user);
client->proxy_password = i_strdup(reply->password);
/* disable input until authentication is finished */
if (client->io != NULL)
io_remove(&client->io);
return 0;
}
static int
fs_sis_open(struct fs *_fs, const char *path, enum fs_open_mode mode,
enum fs_open_flags flags, struct fs_file **file_r)
{
struct sis_fs *fs = (struct sis_fs *)_fs;
struct sis_fs_file *file;
struct fs_file *super;
const char *dir, *hash;
if (mode == FS_OPEN_MODE_APPEND) {
fs_set_error(_fs, "APPEND mode not supported");
return -1;
}
if (fs_open(fs->super, path, mode | flags, &super) < 0) {
fs_sis_copy_error(fs);
return -1;
}
switch (mode) {
case FS_OPEN_MODE_RDONLY:
*file_r = super;
return 0;
case FS_OPEN_MODE_CREATE:
case FS_OPEN_MODE_REPLACE:
break;
case FS_OPEN_MODE_APPEND:
i_unreached();
}
if (fs_sis_path_parse(_fs, path, &dir, &hash) < 0)
return -1;
file = i_new(struct sis_fs_file, 1);
file->file.fs = _fs;
file->file.path = i_strdup(fs_file_path(super));
file->super = super;
file->open_mode = mode;
file->hash = i_strdup(hash);
/* if hashes/<hash> already exists, open it */
file->hash_path = i_strdup_printf("%s/"HASH_DIR_NAME"/%s", dir, hash);
if (fs_open(fs->super, file->hash_path, FS_OPEN_MODE_RDONLY,
&file->hash_file) < 0 && errno != ENOENT) {
i_error("fs-sis: Couldn't open hash file: %s",
fs_last_error(fs->super));
}
if (file->hash_file != NULL) {
file->hash_input =
fs_read_stream(file->hash_file, IO_BLOCK_SIZE);
}
*file_r = &file->file;
return 0;
}
struct sieve_extprograms_config *sieve_extprograms_config_init
(const struct sieve_extension *ext)
{
struct sieve_instance *svinst = ext->svinst;
struct sieve_extprograms_config *ext_config;
const char *extname = sieve_extension_name(ext);
const char *bin_dir, *socket_dir, *input_eol;
sieve_number_t execute_timeout;
extname = strrchr(extname, '.');
i_assert(extname != NULL);
extname++;
bin_dir = sieve_setting_get
(svinst, t_strdup_printf("sieve_%s_bin_dir", extname));
socket_dir = sieve_setting_get
(svinst, t_strdup_printf("sieve_%s_socket_dir", extname));
input_eol = sieve_setting_get
(svinst, t_strdup_printf("sieve_%s_input_eol", extname));
ext_config = i_new(struct sieve_extprograms_config, 1);
ext_config->execute_timeout =
SIEVE_EXTPROGRAMS_DEFAULT_EXEC_TIMEOUT_SECS;
if ( bin_dir == NULL && socket_dir == NULL ) {
if ( svinst->debug ) {
sieve_sys_debug(svinst, "%s extension: "
"no bin or socket directory specified; extension is unconfigured "
"(both sieve_%s_bin_dir and sieve_%s_socket_dir are not set)",
sieve_extension_name(ext), extname, extname);
}
} else {
ext_config->bin_dir = i_strdup(bin_dir);
ext_config->socket_dir = i_strdup(socket_dir);
if (sieve_setting_get_duration_value
(svinst, t_strdup_printf("sieve_%s_exec_timeout", extname),
&execute_timeout)) {
ext_config->execute_timeout = execute_timeout;
}
ext_config->default_input_eol = SIEVE_EXTPROGRAMS_EOL_CRLF;
if (input_eol != NULL && strcasecmp(input_eol, "lf") == 0)
ext_config->default_input_eol = SIEVE_EXTPROGRAMS_EOL_LF;
}
if ( sieve_extension_is(ext, vnd_pipe_extension) )
ext_config->copy_ext = sieve_ext_copy_get_extension(ext->svinst);
if ( sieve_extension_is(ext, vnd_execute_extension) )
ext_config->var_ext = sieve_ext_variables_get_extension(ext->svinst);
return ext_config;
}
static int
imap_urlauth_fetch_request_callback(struct imap_urlauth_fetch_reply *reply,
void *context)
{
struct imap_urlauth_fetch *ufetch =
(struct imap_urlauth_fetch *)context;
int ret = 1;
if (ufetch->waiting_local && reply != NULL) {
i_assert(ufetch->pending_reply.url == NULL);
ufetch->pending_reply.url = i_strdup(reply->url);
ufetch->pending_reply.flags = reply->flags;
ufetch->pending_reply.bodypartstruct =
i_strdup(reply->bodypartstruct);
ufetch->pending_reply.error = i_strdup(reply->error);
if (reply->input != NULL) {
ufetch->pending_reply.input = reply->input;
i_stream_ref(ufetch->pending_reply.input);
}
ufetch->pending_reply.size = reply->size;
ufetch->pending_reply.succeeded = reply->succeeded;
ufetch->pending_reply.binary_has_nuls = reply->binary_has_nuls;
ufetch->waiting_service = TRUE;
return 0;
}
ufetch->waiting_local = FALSE;
ufetch->pending_requests--;
imap_urlauth_fetch_ref(ufetch);
if (!ufetch->failed) {
bool last = ufetch->pending_requests == 0 || reply == NULL;
ret = ufetch->callback(reply, last, ufetch->context);
}
/* report failure only once */
if (ret < 0 || reply == NULL) {
if (!ufetch->failed)
imap_urlauth_fetch_abort_local(ufetch);
ufetch->failed = TRUE;
} else if (ret == 0) {
ufetch->waiting_service = TRUE;
ufetch->pending_requests++;
}
imap_urlauth_fetch_unref(&ufetch);
return ret;
}
int imap_urlauth_fetch_url_parsed(struct imap_urlauth_fetch *ufetch,
const char *url, struct imap_url *imap_url,
enum imap_urlauth_fetch_flags url_flags)
{
struct imap_urlauth_context *uctx = ufetch->uctx;
struct mail_user *mail_user = uctx->user;
const char *error, *errormsg;
int ret = 0;
ufetch->failed = FALSE;
ufetch->pending_requests++;
imap_urlauth_fetch_ref(ufetch);
/* if access user and target user match, handle fetch request locally */
if (imap_url->userid != NULL &&
strcmp(mail_user->username, imap_url->userid) == 0) {
if (ufetch->waiting_local) {
struct imap_urlauth_fetch_url *url_local;
url_local = i_new(struct imap_urlauth_fetch_url, 1);
url_local->url = i_strdup(url);
url_local->flags = url_flags;
DLLIST2_APPEND(&ufetch->local_urls_head,
&ufetch->local_urls_tail, url_local);
} else T_BEGIN {
imap_urlauth_fetch_local(ufetch, url,
url_flags, imap_url);
} T_END;
imap_url = NULL;
/* don't try to fetch remote URLs that are already known to fail access */
} else if (!imap_urlauth_check(uctx, imap_url, TRUE, &error)) {
static void
fts_backend_solr_update_set_mailbox(struct fts_backend_update_context *_ctx,
struct mailbox *box)
{
struct solr_fts_backend_update_context *ctx =
(struct solr_fts_backend_update_context *)_ctx;
struct mailbox_status status;
struct mail_namespace *ns;
if (ctx->prev_uid != 0) {
fts_index_set_last_uid(ctx->cur_box, ctx->prev_uid);
ctx->prev_uid = 0;
}
ctx->cur_box = box;
ctx->uid_validity = 0;
i_free_and_null(ctx->id_box_name);
if (box != NULL) {
ctx->id_box_name = i_strdup(fts_box_get_root(box, &ns));
mailbox_get_open_status(box, STATUS_UIDVALIDITY, &status);
ctx->uid_validity = status.uidvalidity;
}
}
struct subsfile_list_context *
subsfile_list_init(struct mailbox_list *list, const char *path)
{
struct subsfile_list_context *ctx;
int fd;
ctx = i_new(struct subsfile_list_context, 1);
ctx->list = list;
fd = nfs_safe_open(path, O_RDONLY);
if (fd == -1) {
if (errno != ENOENT) {
subsread_set_syscall_error(list, "open()", path);
ctx->failed = TRUE;
}
} else {
ctx->input = i_stream_create_fd_autoclose(&fd,
list->mailbox_name_max_length+1);
i_stream_set_return_partial_line(ctx->input, TRUE);
subsfile_list_read_header(ctx->list, ctx->input, &ctx->version);
}
ctx->path = i_strdup(path);
ctx->name = str_new(default_pool, 128);
return ctx;
}
void connection_init_from_streams(struct connection_list *list,
struct connection *conn, const char *name,
struct istream *input, struct ostream *output)
{
i_assert(name != NULL);
conn->list = list;
conn->name = i_strdup(name);
conn->fd_in = i_stream_get_fd(input);
conn->fd_out = o_stream_get_fd(output);
i_assert(conn->fd_in >= 0);
i_assert(conn->fd_out >= 0);
i_assert(conn->io == NULL);
i_assert(conn->input == NULL);
i_assert(conn->output == NULL);
i_assert(conn->to == NULL);
conn->input = input;
i_stream_ref(conn->input);
i_stream_set_name(conn->input, conn->name);
conn->output = output;
o_stream_ref(conn->output);
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_set_name(conn->output, conn->name);
conn->io = io_add_istream(conn->input, *list->v.input, conn);
DLLIST_PREPEND(&list->connections, conn);
list->connections_count++;
if (list->v.client_connected != NULL)
list->v.client_connected(conn, TRUE);
}
static void fts_solr_set_default_ns(struct solr_fts_backend *backend)
{
struct mail_namespace *ns = backend->backend.ns;
struct fts_solr_user *fuser = FTS_SOLR_USER_CONTEXT(ns->user);
const struct fts_solr_settings *set = &fuser->set;
const char *str;
if (backend->default_ns != NULL)
return;
if (set->default_ns_prefix != NULL) {
backend->default_ns =
mail_namespace_find_prefix(ns->user->namespaces,
set->default_ns_prefix);
if (backend->default_ns == NULL) {
i_error("fts_solr: default_ns setting points to "
"nonexistent namespace");
}
}
if (backend->default_ns == NULL) {
backend->default_ns =
mail_namespace_find_inbox(ns->user->namespaces);
}
while (backend->default_ns->alias_for != NULL)
backend->default_ns = backend->default_ns->alias_for;
if (ns != backend->default_ns) {
str = solr_escape_id_str(ns->prefix);
backend->id_namespace = i_strdup(str);
}
}
int cmd_login(struct imap_client *imap_client, const struct imap_arg *args)
{
struct client *client = &imap_client->common;
const char *user, *pass;
string_t *plain_login, *base64;
/* two arguments: username and password */
if (!imap_arg_get_astring(&args[0], &user) ||
!imap_arg_get_astring(&args[1], &pass) ||
!IMAP_ARG_IS_EOL(&args[2]))
return -1;
if (!client_check_plaintext_auth(client, TRUE)) {
if (client->virtual_user == NULL)
client->virtual_user = i_strdup(user);
return 1;
}
/* authorization ID \0 authentication ID \0 pass */
plain_login = t_buffer_create(64);
buffer_append_c(plain_login, '\0');
buffer_append(plain_login, user, strlen(user));
buffer_append_c(plain_login, '\0');
buffer_append(plain_login, pass, strlen(pass));
base64 = t_buffer_create(MAX_BASE64_ENCODED_SIZE(plain_login->used));
base64_encode(plain_login->data, plain_login->used, base64);
return imap_client_auth_begin(imap_client, "PLAIN", str_c(base64));
}
struct istream *
i_stream_create_rawlog(struct istream *input, const char *rawlog_path,
int rawlog_fd, enum iostream_rawlog_flags flags)
{
struct rawlog_istream *rstream;
i_assert(rawlog_path != NULL);
i_assert(rawlog_fd != -1);
rstream = i_new(struct rawlog_istream, 1);
rstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
rstream->istream.stream_size_passthrough = TRUE;
rstream->riostream.rawlog_path = i_strdup(rawlog_path);
rstream->riostream.rawlog_fd = rawlog_fd;
iostream_rawlog_init(&rstream->riostream, flags, TRUE);
rstream->istream.read = i_stream_rawlog_read;
rstream->istream.iostream.close = i_stream_rawlog_close;
rstream->istream.iostream.destroy = i_stream_rawlog_destroy;
rstream->istream.istream.readable_fd = input->readable_fd;
rstream->istream.istream.blocking = input->blocking;
rstream->istream.istream.seekable = input->seekable;
return i_stream_create(&rstream->istream, input,
i_stream_get_fd(input));
}
void worker_connection_request(struct worker_connection *conn,
const struct indexer_request *request,
void *context)
{
i_assert(worker_connection_is_connected(conn));
i_assert(context != NULL);
i_assert(request->index || request->optimize);
if (conn->request_username == NULL)
conn->request_username = i_strdup(request->username);
else {
i_assert(strcmp(conn->request_username,
request->username) == 0);
}
aqueue_append(conn->request_queue, &context);
T_BEGIN {
string_t *str = t_str_new(128);
str_append_tabescaped(str, request->username);
str_append_c(str, '\t');
str_append_tabescaped(str, request->mailbox);
str_append_c(str, '\t');
if (request->session_id != NULL)
str_append_tabescaped(str, request->session_id);
str_printfa(str, "\t%u\t", request->max_recent_msgs);
if (request->index)
str_append_c(str, 'i');
if (request->optimize)
str_append_c(str, 'o');
str_append_c(str, '\n');
o_stream_nsend(conn->output, str_data(str), str_len(str));
} T_END;
}
int mail_session_connect_parse(const char *const *args, const char **error_r)
{
struct mail_session *session;
const char *session_id;
pid_t pid;
struct ip_addr ip;
unsigned int i;
/* <session id> <username> <service> <pid> [key=value ..] */
if (str_array_length(args) < 4) {
*error_r = "CONNECT: Too few parameters";
return -1;
}
session_id = args[0];
if (str_to_pid(args[3], &pid) < 0) {
*error_r = t_strdup_printf("CONNECT: Invalid pid %s for session ID %s",
args[3], session_id);
return -1;
}
session = hash_table_lookup(mail_sessions_hash, session_id);
if (session != NULL) {
*error_r = t_strdup_printf(
"CONNECT: Duplicate session ID %s for user %s service %s",
session_id, args[1], args[2]);
return -1;
}
session = i_malloc(sizeof(struct mail_session) + stats_alloc_size());
session->stats = (void *)(session + 1);
session->refcount = 1; /* unrefed at disconnect */
session->id = i_strdup(session_id);
session->service = str_table_ref(services, args[2]);
session->pid = pid;
session->last_update = ioloop_timeval;
session->to_idle = timeout_add(MAIL_SESSION_IDLE_TIMEOUT_MSECS,
mail_session_idle_timeout, session);
session->user = mail_user_login(args[1]);
for (i = 3; args[i] != NULL; i++) {
if (strncmp(args[i], "rip=", 4) == 0 &&
net_addr2ip(args[i] + 4, &ip) == 0)
session->ip = mail_ip_login(&ip);
}
hash_table_insert(mail_sessions_hash, session->id, session);
DLLIST_PREPEND_FULL(&stable_mail_sessions, session,
stable_prev, stable_next);
DLLIST2_APPEND_FULL(&mail_sessions_head, &mail_sessions_tail, session,
sorted_prev, sorted_next);
DLLIST_PREPEND_FULL(&session->user->sessions, session,
user_prev, user_next);
mail_user_ref(session->user);
if (session->ip != NULL) {
DLLIST_PREPEND_FULL(&session->ip->sessions, session,
ip_prev, ip_next);
mail_ip_ref(session->ip);
}
global_memory_alloc(mail_session_memsize(session));
return 0;
}
void mail_transaction_log_file_move_to_memory(struct mail_transaction_log_file
*file)
{
buffer_t *buf;
if (MAIL_TRANSACTION_LOG_FILE_IN_MEMORY(file))
return;
if (file->mmap_base != NULL) {
/* just copy to memory */
i_assert(file->buffer_offset == 0);
buf = buffer_create_dynamic(default_pool, file->mmap_size);
buffer_append(buf, file->mmap_base, file->mmap_size);
buffer_free(&file->buffer);
file->buffer = buf;
/* and lose the mmap */
if (munmap(file->mmap_base, file->mmap_size) < 0)
log_file_set_syscall_error(file, "munmap()");
file->mmap_base = NULL;
} else if (file->buffer_offset != 0) {
/* we don't have the full log in the memory. read it. */
(void)mail_transaction_log_file_read(file, 0, FALSE);
}
file->last_size = 0;
if (close(file->fd) < 0)
log_file_set_syscall_error(file, "close()");
file->fd = -1;
i_free(file->filepath);
file->filepath = i_strdup(file->log->filepath);
}
static void
message_decode_body_init_charset(struct message_decoder_context *ctx,
struct message_part *part)
{
ctx->binary_input = ctx->content_charset == NULL &&
(ctx->flags & MESSAGE_DECODER_FLAG_RETURN_BINARY) != 0 &&
(part->flags & (MESSAGE_PART_FLAG_TEXT |
MESSAGE_PART_FLAG_MESSAGE_RFC822)) == 0;
if (ctx->binary_input)
return;
if (ctx->charset_trans != NULL && ctx->content_charset != NULL &&
strcasecmp(ctx->content_charset, ctx->charset_trans_charset) == 0) {
/* already have the correct translation selected */
charset_to_utf8_reset(ctx->charset_trans);
return;
}
if (ctx->charset_trans != NULL)
charset_to_utf8_end(&ctx->charset_trans);
i_free_and_null(ctx->charset_trans_charset);
ctx->charset_trans_charset = i_strdup(ctx->content_charset != NULL ?
ctx->content_charset : "UTF-8");
if (charset_to_utf8_begin(ctx->charset_trans_charset, ctx->normalizer,
&ctx->charset_trans) < 0)
ctx->charset_trans = charset_utf8_to_utf8_begin(ctx->normalizer);
}
static struct userdb_iterate_context *
passwd_file_iterate_init(struct auth_request *auth_request,
userdb_iter_callback_t *callback, void *context)
{
struct userdb_module *_module = auth_request->userdb->userdb;
struct passwd_file_userdb_module *module =
(struct passwd_file_userdb_module *)_module;
struct passwd_file_userdb_iterate_context *ctx;
int fd;
ctx = i_new(struct passwd_file_userdb_iterate_context, 1);
ctx->ctx.auth_request = auth_request;
ctx->ctx.callback = callback;
ctx->ctx.context = context;
ctx->skip_passdb_entries = !module->pwf->userdb_warn_missing;
if (module->pwf->default_file == NULL) {
i_error("passwd-file: User iteration isn't currently supported "
"with %%variable paths");
ctx->ctx.failed = TRUE;
return &ctx->ctx;
}
ctx->path = i_strdup(module->pwf->default_file->path);
/* for now we support only a single passwd-file */
fd = open(ctx->path, O_RDONLY);
if (fd == -1) {
i_error("open(%s) failed: %m", ctx->path);
ctx->ctx.failed = TRUE;
} else {
ctx->input = i_stream_create_fd(fd, (size_t)-1, TRUE);
}
return &ctx->ctx;
}
static int
client_input_notify(struct doveadm_connection *client, const char *const *args)
{
struct replicator_user *user;
/* <username> <flags> <state> */
if (str_array_length(args) < 3) {
i_error("%s: NOTIFY: Invalid parameters", client->conn.name);
return -1;
}
user = replicator_queue_add(client->queue, args[0],
REPLICATION_PRIORITY_NONE);
if (args[1][0] == 'f')
user->last_full_sync = ioloop_time;
user->last_fast_sync = ioloop_time;
user->last_update = ioloop_time;
if (args[2][0] != '\0') {
i_free(user->state);
user->state = i_strdup(args[2]);
}
o_stream_send_str(client->conn.output, "+\n");
return 0;
}
static struct fs_file *
fs_compress_file_init(struct fs *_fs, const char *path,
enum fs_open_mode mode, enum fs_open_flags flags)
{
struct compress_fs *fs = (struct compress_fs *)_fs;
struct compress_fs_file *file;
file = i_new(struct compress_fs_file, 1);
file->file.fs = _fs;
file->file.path = i_strdup(path);
file->fs = fs;
file->open_mode = mode;
/* avoid unnecessarily creating two seekable streams */
flags &= ~FS_OPEN_FLAG_SEEKABLE;
file->file.parent = fs_file_init(_fs->parent, path, mode | flags);
if (mode == FS_OPEN_MODE_READONLY &&
(flags & FS_OPEN_FLAG_ASYNC) == 0) {
/* use async stream for parent, so fs_read_stream() won't create
another seekable stream unneededly */
file->super_read = fs_file_init(_fs->parent, path, mode | flags |
FS_OPEN_FLAG_ASYNC);
} else {
file->super_read = file->file.parent;
}
return &file->file;
}
static struct acl_object *
acl_backend_vfile_object_init(struct acl_backend *_backend,
const char *name)
{
struct acl_backend_vfile *backend =
(struct acl_backend_vfile *)_backend;
struct acl_object_vfile *aclobj;
const char *dir, *vname, *error;
aclobj = i_new(struct acl_object_vfile, 1);
aclobj->aclobj.backend = _backend;
aclobj->aclobj.name = i_strdup(name);
T_BEGIN {
if (*name == '\0' ||
mailbox_list_is_valid_name(_backend->list, name, &error)) {
vname = *name == '\0' ? "" :
mailbox_list_get_vname(_backend->list, name);
dir = acl_backend_vfile_get_local_dir(_backend, name, vname);
aclobj->local_path = dir == NULL ? NULL :
i_strconcat(dir, "/"ACL_FILENAME, NULL);
if (backend->global_path != NULL &&
_backend->global_file == NULL) {
aclobj->global_path =
i_strconcat(backend->global_path, "/", vname, NULL);
}
} else {
/* Invalid mailbox name, just use the default
global ACL files */
}
} T_END;
return &aclobj->aclobj;
}
static int fs_quota_init(struct quota_root *_root, const char *args,
const char **error_r)
{
struct fs_quota_root *root = (struct fs_quota_root *)_root;
const char *const *tmp;
if (args == NULL)
return 0;
for (tmp = t_strsplit(args, ":"); *tmp != NULL; tmp++) {
if (strcmp(*tmp, "user") == 0)
root->group_disabled = TRUE;
else if (strcmp(*tmp, "group") == 0)
root->user_disabled = TRUE;
else if (strcmp(*tmp, "inode_per_mail") == 0)
root->inode_per_mail = TRUE;
else if (strcmp(*tmp, "noenforcing") == 0)
_root->no_enforcing = TRUE;
else if (strcmp(*tmp, "hidden") == 0)
_root->hidden = TRUE;
else if (strncmp(*tmp, "mount=", 6) == 0) {
i_free(root->storage_mount_path);
root->storage_mount_path = i_strdup(*tmp + 6);
} else {
*error_r = t_strdup_printf("Invalid parameter: %s", *tmp);
return -1;
}
}
_root->auto_updating = TRUE;
return 0;
}
static void
imap_metadata_transaction_set_error(struct imap_metadata_transaction *imtrans,
enum mail_error error, const char *string)
{
i_free(imtrans->error_string);
imtrans->error_string = i_strdup(string);
imtrans->error = error;
}
void program_client_set_output_seekable
(struct program_client *pclient, const char *temp_prefix)
{
if ( pclient->output != NULL )
o_stream_unref(&pclient->output);
pclient->temp_prefix = i_strdup(temp_prefix);
pclient->output_seekable = TRUE;
}
static struct client *
client_create_standalone(const char *access_user,
const char *const *access_applications,
int fd_in, int fd_out, bool debug)
{
struct client *client;
/* always use nonblocking I/O */
net_set_nonblock(fd_in, TRUE);
net_set_nonblock(fd_out, TRUE);
client = i_new(struct client, 1);
i_array_init(&client->access_apps, 16);
client->fd_in = fd_in;
client->fd_out = fd_out;
client->fd_ctrl = -1;
if (access_user != NULL && *access_user != '\0')
client->access_user = i_strdup(access_user);
else {
client->access_user = i_strdup("anonymous");
client->access_anonymous = TRUE;
}
if (access_applications != NULL) {
const char *const *apps = access_applications;
for (; *apps != NULL; apps++) {
char *app = i_strdup(*apps);
array_append(&client->access_apps, &app, 1);
}
}
client->debug = debug;
client->input = i_stream_create_fd(fd_in, MAX_INBUF_SIZE, FALSE);
client->output = o_stream_create_fd(fd_out, (size_t)-1, FALSE);
client->io = io_add(fd_in, IO_READ, client_input, client);
client->to_idle = timeout_add(CLIENT_IDLE_TIMEOUT_MSECS,
client_idle_timeout, client);
o_stream_set_flush_callback(client->output, client_output, client);
imap_urlauth_worker_client_count++;
DLLIST_PREPEND(&imap_urlauth_worker_clients, client);
i_set_failure_prefix("imap-urlauth[%s](%s): ",
my_pid, client->access_user);
return client;
}
void mail_index_set_permissions(struct mail_index *index,
mode_t mode, gid_t gid, const char *gid_origin)
{
index->mode = mode & 0666;
index->gid = gid;
i_free(index->gid_origin);
index->gid_origin = i_strdup(gid_origin);
}
