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;
}
const char *subsfile_list_next(struct subsfile_list_context *ctx)
{
const char *line;
unsigned int i;
int fd;
if (ctx->failed || ctx->input == NULL)
return NULL;
for (i = 0;; i++) {
line = next_line(ctx->list, ctx->path, ctx->input, &ctx->failed,
i < SUBSCRIPTION_FILE_ESTALE_RETRY_COUNT);
if (ctx->input->stream_errno != ESTALE ||
i == SUBSCRIPTION_FILE_ESTALE_RETRY_COUNT)
break;
/* Reopen the subscription file and re-send everything.
this isn't the optimal behavior, but it's allowed by
IMAP and this way we don't have to read everything into
memory or try to play any guessing games. */
i_stream_destroy(&ctx->input);
fd = nfs_safe_open(ctx->path, O_RDONLY);
if (fd == -1) {
/* In case of ENOENT all the subscriptions got lost.
Just return end of subscriptions list in that
case. */
if (errno != ENOENT) {
subsread_set_syscall_error(ctx->list, "open()",
ctx->path);
ctx->failed = TRUE;
}
return NULL;
}
ctx->input = i_stream_create_fd_autoclose(&fd,
ctx->list->mailbox_name_max_length+1);
i_stream_set_return_partial_line(ctx->input, TRUE);
}
if (ctx->version > 1 && line != NULL)
line = subsfile_list_unescaped(ctx, line);
return line;
}
static int
do_open(struct maildir_mailbox *mbox, const char *path,
struct maildir_open_context *ctx)
{
ctx->fd = nfs_safe_open(path, O_RDONLY);
if (ctx->fd != -1) {
ctx->path = i_strdup(path);
return 1;
}
if (errno == ENOENT)
return 0;
if (errno == EACCES) {
mail_storage_set_critical(&mbox->storage->storage, "%s",
mail_error_eacces_msg("open", path));
} else {
mail_storage_set_critical(&mbox->storage->storage,
"open(%s) failed: %m", path);
}
return -1;
}
int subsfile_set_subscribed(struct mailbox_list *list, const char *path,
const char *temp_prefix, const char *name,
bool set)
{
const struct mail_storage_settings *mail_set = list->mail_set;
struct dotlock_settings dotlock_set;
struct dotlock *dotlock;
struct mailbox_permissions perm;
const char *line, *dir, *fname, *escaped_name;
struct istream *input = NULL;
struct ostream *output;
int fd_in, fd_out;
enum mailbox_list_path_type type;
bool found, changed = FALSE, failed = FALSE;
unsigned int version = 2;
if (strcasecmp(name, "INBOX") == 0)
name = "INBOX";
memset(&dotlock_set, 0, sizeof(dotlock_set));
dotlock_set.use_excl_lock = mail_set->dotlock_use_excl;
dotlock_set.nfs_flush = mail_set->mail_nfs_storage;
dotlock_set.temp_prefix = temp_prefix;
dotlock_set.timeout = SUBSCRIPTION_FILE_LOCK_TIMEOUT;
dotlock_set.stale_timeout = SUBSCRIPTION_FILE_CHANGE_TIMEOUT;
mailbox_list_get_root_permissions(list, &perm);
fd_out = file_dotlock_open_group(&dotlock_set, path, 0,
perm.file_create_mode,
perm.file_create_gid,
perm.file_create_gid_origin, &dotlock);
if (fd_out == -1 && errno == ENOENT) {
/* directory hasn't been created yet. */
type = list->set.control_dir != NULL ?
MAILBOX_LIST_PATH_TYPE_CONTROL :
MAILBOX_LIST_PATH_TYPE_DIR;
fname = strrchr(path, '/');
if (fname != NULL) {
dir = t_strdup_until(path, fname);
if (mailbox_list_mkdir_root(list, dir, type) < 0)
return -1;
}
fd_out = file_dotlock_open_group(&dotlock_set, path, 0,
perm.file_create_mode,
perm.file_create_gid,
perm.file_create_gid_origin,
&dotlock);
}
if (fd_out == -1) {
if (errno == EAGAIN) {
mailbox_list_set_error(list, MAIL_ERROR_TEMP,
"Timeout waiting for subscription file lock");
} else {
subswrite_set_syscall_error(list, "file_dotlock_open()",
path);
}
return -1;
}
fd_in = nfs_safe_open(path, O_RDONLY);
if (fd_in == -1 && errno != ENOENT) {
subswrite_set_syscall_error(list, "open()", path);
file_dotlock_delete(&dotlock);
return -1;
}
if (fd_in != -1) {
input = i_stream_create_fd_autoclose(&fd_in, list->mailbox_name_max_length+1);
i_stream_set_return_partial_line(input, TRUE);
subsfile_list_read_header(list, input, &version);
}
found = FALSE;
output = o_stream_create_fd_file(fd_out, 0, FALSE);
o_stream_cork(output);
if (version >= 2)
o_stream_send_str(output, version2_header);
if (version < 2 || name[0] == '\0')
escaped_name = name;
else {
const char *const *tmp;
char separators[2];
string_t *str = t_str_new(64);
separators[0] = mailbox_list_get_hierarchy_sep(list);
separators[1] = '\0';
tmp = t_strsplit(name, separators);
str_append_tabescaped(str, *tmp);
for (tmp++; *tmp != NULL; tmp++) {
str_append_c(str, '\t');
str_append_tabescaped(str, *tmp);
}
escaped_name = str_c(str);
}
if (input != NULL) {
while ((line = next_line(list, path, input,
&failed, FALSE)) != NULL) {
if (strcmp(line, escaped_name) == 0) {
found = TRUE;
if (!set) {
changed = TRUE;
continue;
}
}
o_stream_nsend_str(output, line);
o_stream_nsend(output, "\n", 1);
}
i_stream_destroy(&input);
}
if (!failed && set && !found) {
/* append subscription */
line = t_strconcat(escaped_name, "\n", NULL);
o_stream_nsend_str(output, line);
changed = TRUE;
}
if (changed && !failed) {
if (o_stream_nfinish(output) < 0) {
subswrite_set_syscall_error(list, "write()", path);
failed = TRUE;
} else if (mail_set->parsed_fsync_mode != FSYNC_MODE_NEVER) {
if (fsync(fd_out) < 0) {
subswrite_set_syscall_error(list, "fsync()",
path);
failed = TRUE;
}
}
} else {
o_stream_ignore_last_errors(output);
}
o_stream_destroy(&output);
if (failed || !changed) {
if (file_dotlock_delete(&dotlock) < 0) {
subswrite_set_syscall_error(list,
"file_dotlock_delete()", path);
failed = TRUE;
}
} else {
enum dotlock_replace_flags flags =
DOTLOCK_REPLACE_FLAG_VERIFY_OWNER;
if (file_dotlock_replace(&dotlock, flags) < 0) {
subswrite_set_syscall_error(list,
"file_dotlock_replace()", path);
failed = TRUE;
}
}
return failed ? -1 : (changed ? 1 : 0);
}
int mail_transaction_log_file_open(struct mail_transaction_log_file *file)
{
struct mail_index *index = file->log->index;
unsigned int i;
bool ignore_estale;
int ret;
for (i = 0;; i++) {
if (!index->readonly) {
file->fd = nfs_safe_open(file->filepath,
O_RDWR | O_APPEND);
} else {
file->fd = nfs_safe_open(file->filepath, O_RDONLY);
}
if (file->fd == -1 && errno == EACCES) {
file->fd = nfs_safe_open(file->filepath, O_RDONLY);
index->readonly = TRUE;
}
if (file->fd == -1) {
if (errno == ENOENT)
return 0;
log_file_set_syscall_error(file, "open()");
return -1;
}
ignore_estale = i < MAIL_INDEX_ESTALE_RETRY_COUNT;
if (mail_transaction_log_file_stat(file, ignore_estale) < 0)
ret = -1;
else if (mail_transaction_log_file_is_dupe(file)) {
/* probably our already opened .log file has been
renamed to .log.2 and we're trying to reopen it.
also possible that hit a race condition where .log
and .log.2 are linked. */
return 0;
} else {
ret = mail_transaction_log_file_read_hdr(file,
ignore_estale);
}
if (ret > 0) {
/* success */
break;
}
if (ret == 0) {
/* corrupted */
if (index->readonly) {
/* don't delete */
} else {
i_unlink_if_exists(file->filepath);
}
return 0;
}
if (errno != ESTALE ||
i == MAIL_INDEX_ESTALE_RETRY_COUNT) {
/* syscall error */
return -1;
}
/* ESTALE - try again */
buffer_free(&file->buffer);
}
mail_transaction_log_file_add_to_list(file);
return 1;
}
static int
mail_transaction_log_file_create2(struct mail_transaction_log_file *file,
int new_fd, bool reset,
struct dotlock **dotlock)
{
struct mail_index *index = file->log->index;
struct stat st;
const char *path2;
buffer_t *writebuf;
int fd, ret;
bool rename_existing, need_lock;
need_lock = file->log->head != NULL && file->log->head->locked;
if (fcntl(new_fd, F_SETFL, O_APPEND) < 0) {
log_file_set_syscall_error(file, "fcntl(O_APPEND)");
return -1;
}
if (file->log->nfs_flush) {
/* although we check also mtime and file size below, it's done
only to fix broken log files. we don't bother flushing
attribute cache just for that. */
nfs_flush_file_handle_cache(file->filepath);
}
/* log creation is locked now - see if someone already created it.
note that if we're rotating, we need to keep the log locked until
the file has been rewritten. and because fcntl() locks are stupid,
if we go and open()+close() the file and we had it already opened,
its locks are lost. so we use stat() to check if the file has been
recreated, although it almost never is. */
if (reset)
rename_existing = FALSE;
else if (nfs_safe_stat(file->filepath, &st) < 0) {
if (errno != ENOENT) {
log_file_set_syscall_error(file, "stat()");
return -1;
}
rename_existing = FALSE;
} else if (st.st_ino == file->st_ino &&
CMP_DEV_T(st.st_dev, file->st_dev) &&
/* inode/dev checks are enough when we're rotating the file,
but not when we're replacing a broken log file */
st.st_mtime == file->last_mtime &&
(uoff_t)st.st_size == file->last_size) {
/* no-one else recreated the file */
rename_existing = TRUE;
} else {
/* recreated. use the file if its header is ok */
fd = nfs_safe_open(file->filepath, O_RDWR | O_APPEND);
if (fd == -1) {
if (errno != ENOENT) {
log_file_set_syscall_error(file, "open()");
return -1;
}
} else {
file->fd = fd;
file->last_size = 0;
if (mail_transaction_log_file_read_hdr(file,
FALSE) > 0 &&
mail_transaction_log_file_stat(file, FALSE) == 0) {
/* yes, it was ok */
file_dotlock_delete(dotlock);
mail_transaction_log_file_add_to_list(file);
return 0;
}
file->fd = -1;
if (close(fd) < 0)
log_file_set_syscall_error(file, "close()");
}
rename_existing = FALSE;
}
if (index->fd == -1 && !rename_existing) {
/* creating the initial index */
reset = TRUE;
}
if (mail_transaction_log_init_hdr(file->log, &file->hdr) < 0)
return -1;
if (reset) {
/* don't reset modseqs. if we're reseting due to rebuilding
indexes we'll probably want to keep uidvalidity and in such
cases we really don't want to shrink modseqs. */
file->hdr.prev_file_seq = 0;
file->hdr.prev_file_offset = 0;
}
writebuf = buffer_create_dynamic(pool_datastack_create(), 128);
buffer_append(writebuf, &file->hdr, sizeof(file->hdr));
if (index->ext_hdr_init_data != NULL && reset)
log_write_ext_hdr_init_data(index, writebuf);
if (write_full(new_fd, writebuf->data, writebuf->used) < 0) {
log_file_set_syscall_error(file, "write_full()");
return -1;
}
if (file->log->index->fsync_mode == FSYNC_MODE_ALWAYS) {
/* the header isn't important, so don't bother calling
fdatasync() unless it's required */
if (fdatasync(new_fd) < 0) {
log_file_set_syscall_error(file, "fdatasync()");
return -1;
}
}
file->fd = new_fd;
ret = mail_transaction_log_file_stat(file, FALSE);
if (need_lock) {
/* we'll need to preserve the lock */
if (mail_transaction_log_file_lock(file) < 0)
ret = -1;
}
/* if we return -1 the dotlock deletion code closes the fd */
file->fd = -1;
if (ret < 0)
return -1;
/* keep two log files */
if (rename_existing) {
/* rename() would be nice and easy way to do this, except then
there's a race condition between the rename and
file_dotlock_replace(). during that time the log file
doesn't exist, which could cause problems. */
path2 = t_strconcat(file->filepath, ".2", NULL);
if (i_unlink_if_exists(path2) < 0) {
/* try to link() anyway */
}
if (nfs_safe_link(file->filepath, path2, FALSE) < 0 &&
errno != ENOENT && errno != EEXIST) {
mail_index_set_error(index, "link(%s, %s) failed: %m",
file->filepath, path2);
/* ignore the error. we don't care that much about the
second log file and we're going to overwrite this
first one. */
}
/* NOTE: here's a race condition where both .log and .log.2
point to the same file. our reading code should ignore that
though by comparing the inodes. */
}
if (file_dotlock_replace(dotlock,
DOTLOCK_REPLACE_FLAG_DONT_CLOSE_FD) <= 0)
return -1;
/* success */
file->fd = new_fd;
mail_transaction_log_file_add_to_list(file);
i_assert(!need_lock || file->locked);
return 1;
}
int subsfile_set_subscribed(struct mailbox_list *list, const char *path,
const char *temp_prefix, const char *name, bool set)
{
const struct mail_storage_settings *mail_set = list->mail_set;
struct dotlock_settings dotlock_set;
struct dotlock *dotlock;
const char *line, *origin;
struct istream *input;
struct ostream *output;
int fd_in, fd_out;
mode_t mode;
gid_t gid;
bool found, changed = FALSE, failed = FALSE;
if (strcasecmp(name, "INBOX") == 0)
name = "INBOX";
memset(&dotlock_set, 0, sizeof(dotlock_set));
dotlock_set.use_excl_lock = mail_set->dotlock_use_excl;
dotlock_set.nfs_flush = mail_set->mail_nfs_storage;
dotlock_set.temp_prefix = temp_prefix;
dotlock_set.timeout = SUBSCRIPTION_FILE_LOCK_TIMEOUT;
dotlock_set.stale_timeout = SUBSCRIPTION_FILE_CHANGE_TIMEOUT;
mailbox_list_get_permissions(list, NULL, &mode, &gid, &origin);
fd_out = file_dotlock_open_group(&dotlock_set, path, 0,
mode, gid, origin, &dotlock);
if (fd_out == -1 && errno == ENOENT) {
/* directory hasn't been created yet. */
if (mailbox_list_create_parent_dir(list, NULL, path) < 0)
return -1;
fd_out = file_dotlock_open_group(&dotlock_set, path, 0,
mode, gid, origin, &dotlock);
}
if (fd_out == -1) {
if (errno == EAGAIN) {
mailbox_list_set_error(list, MAIL_ERROR_TEMP,
"Timeout waiting for subscription file lock");
} else {
subswrite_set_syscall_error(list, "file_dotlock_open()",
path);
}
return -1;
}
fd_in = nfs_safe_open(path, O_RDONLY);
if (fd_in == -1 && errno != ENOENT) {
subswrite_set_syscall_error(list, "open()", path);
(void)file_dotlock_delete(&dotlock);
return -1;
}
input = fd_in == -1 ? NULL :
i_stream_create_fd(fd_in, list->mailbox_name_max_length+1,
TRUE);
output = o_stream_create_fd_file(fd_out, 0, FALSE);
o_stream_cork(output);
found = FALSE;
while ((line = next_line(list, path, input,
&failed, FALSE)) != NULL) {
if (strcmp(line, name) == 0) {
found = TRUE;
if (!set) {
changed = TRUE;
continue;
}
}
(void)o_stream_send_str(output, line);
(void)o_stream_send(output, "\n", 1);
}
if (!failed && set && !found) {
/* append subscription */
line = t_strconcat(name, "\n", NULL);
(void)o_stream_send_str(output, line);
changed = TRUE;
}
if (changed && !failed) {
if (o_stream_flush(output) < 0) {
subswrite_set_syscall_error(list, "write()", path);
failed = TRUE;
} else if (mail_set->parsed_fsync_mode != FSYNC_MODE_NEVER) {
if (fsync(fd_out) < 0) {
subswrite_set_syscall_error(list, "fsync()",
path);
failed = TRUE;
}
}
}
if (input != NULL)
i_stream_destroy(&input);
o_stream_destroy(&output);
if (failed || !changed) {
if (file_dotlock_delete(&dotlock) < 0) {
subswrite_set_syscall_error(list,
"file_dotlock_delete()", path);
failed = TRUE;
}
} else {
enum dotlock_replace_flags flags =
DOTLOCK_REPLACE_FLAG_VERIFY_OWNER;
if (file_dotlock_replace(&dotlock, flags) < 0) {
subswrite_set_syscall_error(list,
"file_dotlock_replace()", path);
failed = TRUE;
}
}
return failed ? -1 : (changed ? 1 : 0);
}
static int
acl_backend_vfile_read(struct acl_object *aclobj, bool global, const char *path,
struct acl_vfile_validity *validity, bool try_retry,
bool *is_dir_r)
{
struct istream *input;
struct stat st;
struct acl_rights rights;
const char *line, *error;
unsigned int linenum;
int fd, ret = 0;
*is_dir_r = FALSE;
fd = nfs_safe_open(path, O_RDONLY);
if (fd == -1) {
if (errno == ENOENT || errno == ENOTDIR) {
if (aclobj->backend->debug)
i_debug("acl vfile: file %s not found", path);
validity->last_mtime = ACL_VFILE_VALIDITY_MTIME_NOTFOUND;
} else if (errno == EACCES) {
if (aclobj->backend->debug)
i_debug("acl vfile: no access to file %s",
path);
acl_object_remove_all_access(aclobj);
validity->last_mtime = ACL_VFILE_VALIDITY_MTIME_NOACCESS;
} else {
i_error("open(%s) failed: %m", path);
return -1;
}
validity->last_size = 0;
validity->last_read_time = ioloop_time;
return 1;
}
if (fstat(fd, &st) < 0) {
if (errno == ESTALE && try_retry) {
i_close_fd(&fd);
return 0;
}
i_error("fstat(%s) failed: %m", path);
i_close_fd(&fd);
return -1;
}
if (S_ISDIR(st.st_mode)) {
/* we opened a directory. */
*is_dir_r = TRUE;
i_close_fd(&fd);
return 0;
}
if (aclobj->backend->debug)
i_debug("acl vfile: reading file %s", path);
input = i_stream_create_fd(fd, (size_t)-1, FALSE);
i_stream_set_return_partial_line(input, TRUE);
linenum = 1;
while ((line = i_stream_read_next_line(input)) != NULL) {
T_BEGIN {
ret = acl_rights_parse_line(line, aclobj->rights_pool,
&rights, &error);
rights.global = global;
if (ret < 0) {
i_error("ACL file %s line %u: %s",
path, linenum, error);
} else {
array_append(&aclobj->rights, &rights, 1);
}
} T_END;
if (ret < 0)
break;
linenum++;
}
if (ret < 0) {
/* parsing failure */
} else if (input->stream_errno != 0) {
if (input->stream_errno == ESTALE && try_retry)
ret = 0;
else {
ret = -1;
i_error("read(%s) failed: %m", path);
}
} else {
if (fstat(fd, &st) < 0) {
if (errno == ESTALE && try_retry)
ret = 0;
else {
ret = -1;
i_error("fstat(%s) failed: %m", path);
}
} else {
ret = 1;
validity->last_read_time = ioloop_time;
validity->last_mtime = st.st_mtime;
validity->last_size = st.st_size;
}
}
i_stream_unref(&input);
if (close(fd) < 0) {
if (errno == ESTALE && try_retry)
return 0;
i_error("close(%s) failed: %m", path);
return -1;
}
return ret;
}
