lib-fs: Use fs_set_error_errno() where appropriate

diff --git a/src/lib-fs/fs-posix.c b/src/lib-fs/fs-posix.c
index 3c12387bc21df4e7d1e40afefce18343d2d45747..56b24479f1cb1281eb1231132fe477a4954cd745 100644 (file)
--- a/src/lib-fs/fs-posix.c
+++ b/src/lib-fs/fs-posix.c
@@ -170,7 +170,8 @@ fs_posix_get_mode(struct posix_fs_file *file, const char *path, mode_t *mode_r)
           errors. */
        while (stat(path, &st) < 0) {
                if (errno != ENOENT) {
-                       fs_set_error(file->file.event, "stat(%s) failed: %m", path);
+                       fs_set_error_errno(file->file.event,
+                                          "stat(%s) failed: %m", path);
                        return -1;
                }
                p = strrchr(path, '/');
@@ -210,7 +211,8 @@ static int fs_posix_mkdir_parents(struct posix_fs_file *file, const char *path)
        else if (errno == EEXIST)
                return 1;
        else {
-               fs_set_error(file->file.event, "mkdir_parents(%s) failed: %m", dir);
+               fs_set_error_errno(file->file.event,
+                                  "mkdir_parents(%s) failed: %m", dir);
                return -1;
        }
 }
@@ -239,7 +241,8 @@ static int fs_posix_rmdir_parents(struct posix_fs_file *file, const char *path)
                        /* some other not-unexpected error */
                        break;
                } else {
-                       fs_set_error(file->file.event, "rmdir(%s) failed: %m", path);
+                       fs_set_error_errno(file->file.event,
+                                          "rmdir(%s) failed: %m", path);
                        return -1;
                }
        }
@@ -277,7 +280,8 @@ static int fs_posix_create(struct posix_fs_file *file)
                try_count++;
        }
        if (fd == -1) {
-               fs_set_error(file->file.event, "safe_mkstemp(%s) failed: %m", str_c(str));
+               fs_set_error_errno(file->file.event,
+                                  "safe_mkstemp(%s) failed: %m", str_c(str));
                return -1;
        }
        file->temp_path = i_strdup(str_c(str));
@@ -294,12 +298,14 @@ static int fs_posix_open(struct posix_fs_file *file)
        case FS_OPEN_MODE_READONLY:
                file->fd = open(path, O_RDONLY);
                if (file->fd == -1)
-                       fs_set_error(file->file.event, "open(%s) failed: %m", path);
+                       fs_set_error_errno(file->file.event,
+                                          "open(%s) failed: %m", path);
                break;
        case FS_OPEN_MODE_APPEND:
                file->fd = open(path, O_RDWR | O_APPEND);
                if (file->fd == -1)
-                       fs_set_error(file->file.event, "open(%s) failed: %m", path);
+                       fs_set_error_errno(file->file.event,
+                                          "open(%s) failed: %m", path);
                break;
        case FS_OPEN_MODE_CREATE_UNIQUE_128:
        case FS_OPEN_MODE_CREATE:
@@ -437,15 +443,17 @@ static ssize_t fs_posix_read(struct fs_file *_file, void *buf, size_t size)
        if (file->seek_to_beginning) {
                file->seek_to_beginning = FALSE;
                if (lseek(file->fd, 0, SEEK_SET) < 0) {
-                       fs_set_error(_file->event, "lseek(%s, 0) failed: %m",
-                                    file->full_path);
+                       fs_set_error_errno(_file->event,
+                                          "lseek(%s, 0) failed: %m",
+                                          file->full_path);
                        return -1;
                }
        }
 
        ret = read(file->fd, buf, size);
        if (ret < 0)
-               fs_set_error(_file->event, "read(%s) failed: %m", file->full_path);
+               fs_set_error_errno(_file->event, "read(%s) failed: %m",
+                                  file->full_path);
        fs_posix_file_close(_file);
        return ret;
 }
@@ -504,8 +512,8 @@ static int fs_posix_write_finish_link(struct posix_fs_file *file)
                try_count++;
        }
        if (ret < 0) {
-               fs_set_error(file->file.event, "link(%s, %s) failed: %m",
-                            file->temp_path, file->full_path);
+               fs_set_error_errno(file->file.event, "link(%s, %s) failed: %m",
+                                  file->temp_path, file->full_path);
        }
        return ret;
 }
@@ -519,8 +527,9 @@ static int fs_posix_write_finish(struct posix_fs_file *file)
        if ((file->open_flags & FS_OPEN_FLAG_FSYNC) != 0 &&
            !fs->disable_fsync) {
                if (fdatasync(file->fd) < 0) {
-                       fs_set_error(file->file.event, "fdatasync(%s) failed: %m",
-                                    file->full_path);
+                       fs_set_error_errno(file->file.event,
+                                          "fdatasync(%s) failed: %m",
+                                          file->full_path);
                        return -1;
                }
        }
@@ -534,8 +543,9 @@ static int fs_posix_write_finish(struct posix_fs_file *file)
                        i_fatal("gettimeofday() failed: %m");
                tv[1] = tv[0];
                if ((utimes(file->temp_path, tv)) < 0) {
-                       fs_set_error(file->file.event, "utimes(%s) failed: %m",
-                                    file->temp_path);
+                       fs_set_error_errno(file->file.event,
+                                          "utimes(%s) failed: %m",
+                                          file->temp_path);
                        return -1;
                }
        }
@@ -547,8 +557,9 @@ static int fs_posix_write_finish(struct posix_fs_file *file)
                ret = fs_posix_write_finish_link(file);
                old_errno = errno;
                if (unlink(file->temp_path) < 0) {
-                       fs_set_error(file->file.event, "unlink(%s) failed: %m",
-                                    file->temp_path);
+                       fs_set_error_errno(file->file.event,
+                                          "unlink(%s) failed: %m",
+                                          file->temp_path);
                }
                errno = old_errno;
                if (ret < 0) {
@@ -567,8 +578,9 @@ static int fs_posix_write_finish(struct posix_fs_file *file)
                        try_count++;
                }
                if (ret < 0) {
-                       fs_set_error(file->file.event, "rename(%s, %s) failed: %m",
-                                    file->temp_path, file->full_path);
+                       fs_set_error_errno(file->file.event,
+                                          "rename(%s, %s) failed: %m",
+                                          file->temp_path, file->full_path);
                        return -1;
                }
                break;
@@ -596,8 +608,8 @@ static int fs_posix_write(struct fs_file *_file, const void *data, size_t size)
 
        if (file->open_mode != FS_OPEN_MODE_APPEND) {
                if (write_full(file->fd, data, size) < 0) {
-                       fs_set_error(_file->event, "write(%s) failed: %m",
-                                    file->full_path);
+                       fs_set_error_errno(_file->event, "write(%s) failed: %m",
+                                          file->full_path);
                        return -1;
                }
                return fs_posix_write_finish(file);
@@ -606,7 +618,8 @@ static int fs_posix_write(struct fs_file *_file, const void *data, size_t size)
        /* atomic append - it should either succeed or fail */
        ret = write(file->fd, data, size);
        if (ret < 0) {
-               fs_set_error(_file->event, "write(%s) failed: %m", file->full_path);
+               fs_set_error_errno(_file->event, "write(%s) failed: %m",
+                                  file->full_path);
                return -1;
        }
        if ((size_t)ret != size) {
@@ -697,8 +710,8 @@ fs_posix_lock(struct fs_file *_file, unsigned int secs, struct fs_lock **lock_r)
                                             &fs_lock.file_lock);
                }
                if (ret < 0) {
-                       fs_set_error(_file->event, "flock(%s) failed: %m",
-                                    file->full_path);
+                       fs_set_error_errno(_file->event, "flock(%s) failed: %m",
+                                          file->full_path);
                }
 #endif
                break;
@@ -713,9 +726,9 @@ fs_posix_lock(struct fs_file *_file, unsigned int secs, struct fs_lock **lock_r)
                                          DOTLOCK_CREATE_FLAG_NONBLOCK,
                                          &fs_lock.dotlock);
                if (ret < 0) {
-                       fs_set_error(_file->event,
-                                    "file_dotlock_create(%s) failed: %m",
-                                    file->full_path);
+                       fs_set_error_errno(_file->event,
+                                          "file_dotlock_create(%s) failed: %m",
+                                          file->full_path);
                }
                break;
        }
@@ -748,8 +761,8 @@ static int fs_posix_exists(struct fs_file *_file)
 
        if (stat(file->full_path, &st) < 0) {
                if (errno != ENOENT) {
-                       fs_set_error(_file->event, "stat(%s) failed: %m",
-                                    file->full_path);
+                       fs_set_error_errno(_file->event, "stat(%s) failed: %m",
+                                          file->full_path);
                        return -1;
                }
                return 0;
@@ -767,12 +780,14 @@ static int fs_posix_stat(struct fs_file *_file, struct stat *st_r)
           fs-sis after fs_copy(). */
        if (file->fd != -1 && _file->output == NULL) {
                if (fstat(file->fd, st_r) < 0) {
-                       fs_set_error(_file->event, "fstat(%s) failed: %m", file->full_path);
+                       fs_set_error_errno(_file->event, "fstat(%s) failed: %m",
+                                          file->full_path);
                        return -1;
                }
        } else {
                if (stat(file->full_path, st_r) < 0) {
-                       fs_set_error(_file->event, "stat(%s) failed: %m", file->full_path);
+                       fs_set_error_errno(_file->event, "stat(%s) failed: %m",
+                                          file->full_path);
                        return -1;
                }
        }
@@ -803,8 +818,8 @@ static int fs_posix_copy(struct fs_file *_src, struct fs_file *_dest)
                try_count++;
        }
        if (ret < 0) {
-               fs_set_error(_src->event, "link(%s, %s) failed: %m",
-                            src->full_path, dest->full_path);
+               fs_set_error_errno(_src->event, "link(%s, %s) failed: %m",
+                                  src->full_path, dest->full_path);
                return -1;
        }
        return 0;
@@ -828,8 +843,8 @@ static int fs_posix_rename(struct fs_file *_src, struct fs_file *_dest)
                try_count++;
        }
        if (ret < 0) {
-               fs_set_error(_src->event, "rename(%s, %s) failed: %m",
-                            src->full_path, dest->full_path);
+               fs_set_error_errno(_src->event, "rename(%s, %s) failed: %m",
+                                  src->full_path, dest->full_path);
                return -1;
        }
        return 0;
@@ -842,13 +857,15 @@ static int fs_posix_delete(struct fs_file *_file)
 
        if (unlink(file->full_path) < 0) {
                if (!UNLINK_EISDIR(errno)) {
-                       fs_set_error(_file->event, "unlink(%s) failed: %m", file->full_path);
+                       fs_set_error_errno(_file->event, "unlink(%s) failed: %m",
+                                          file->full_path);
                        return -1;
                }
                /* attempting to delete a directory. convert it to rmdir()
                   automatically. */
                if (rmdir(file->full_path) < 0) {
-                       fs_set_error(_file->event, "rmdir(%s) failed: %m", file->full_path);
+                       fs_set_error_errno(_file->event, "rmdir(%s) failed: %m",
+                                          file->full_path);
                        return -1;
                }
        }
@@ -879,7 +896,8 @@ fs_posix_iter_init(struct fs_iter *_iter, const char *path,
        iter->dir = opendir(iter->path);
        if (iter->dir == NULL && errno != ENOENT) {
                iter->err = errno;
-               fs_set_error(_iter->event, "opendir(%s) failed: %m", iter->path);
+               fs_set_error_errno(_iter->event,
+                                  "opendir(%s) failed: %m", iter->path);
        }
 }
 
@@ -942,7 +960,8 @@ static const char *fs_posix_iter_next(struct fs_iter *_iter)
        }
        if (errno != 0) {
                iter->err = errno;
-               fs_set_error(_iter->event, "readdir(%s) failed: %m", iter->path);
+               fs_set_error_errno(_iter->event,
+                                  "readdir(%s) failed: %m", iter->path);
        }
        return NULL;
 }
@@ -955,7 +974,8 @@ static int fs_posix_iter_deinit(struct fs_iter *_iter)
 
        if (iter->dir != NULL && closedir(iter->dir) < 0 && iter->err == 0) {
                iter->err = errno;
-               fs_set_error(_iter->event, "closedir(%s) failed: %m", iter->path);
+               fs_set_error_errno(_iter->event,
+                                  "closedir(%s) failed: %m", iter->path);
        }
        if (iter->err != 0) {
                errno = iter->err;

diff --git a/src/lib-fs/fs-randomfail.c b/src/lib-fs/fs-randomfail.c
index 6acdd5e08bf675a53e3d531c44c1d206a6c9453b..182992d7e0b1974c7e0385ca5312ca7761cef390 100644 (file)
--- a/src/lib-fs/fs-randomfail.c
+++ b/src/lib-fs/fs-randomfail.c
@@ -504,7 +504,7 @@ static int fs_randomfail_iter_deinit(struct fs_iter *_iter)
        int ret;
 
        if ((ret = fs_iter_deinit(&iter->super, &error)) < 0)
-               fs_set_error(_iter->event, "%s", error);
+               fs_set_error_errno(_iter->event, "%s", error);
        if (iter->fail_pos == 1) {
                fs_set_error(_iter->event, RANDOMFAIL_ERROR);
                errno = EIO;

diff --git a/src/lib-fs/fs-wrapper.c b/src/lib-fs/fs-wrapper.c
index 81e75e4e27c12c6cdc370c6b888a593277dea412..ea8130b409a0fd2caa6d27473f5d1acb88baba87 100644 (file)
--- a/src/lib-fs/fs-wrapper.c
+++ b/src/lib-fs/fs-wrapper.c
@@ -166,6 +166,6 @@ int fs_wrapper_iter_deinit(struct fs_iter *_iter)
        int ret;
 
        if ((ret = fs_iter_deinit(&iter->parent, &error)) < 0)
-               fs_set_error(_iter->event, "%s", error);
+               fs_set_error_errno(_iter->event, "%s", error);
        return ret;
 }