From 42243c105b6a067b9e680ba84c417c972eaa4d3f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Degros?= <fdegros@chromium.org>
Date: Mon, 29 Jun 2020 00:29:00 +1000
Subject: [PATCH] Better error reporting via exceptions

Added exception class ZipError to carry libzip error code.

Made DataNode exception-transparent.

Removed some try-catch thanks to the use of unique_ptr.

If the ZIP archive cannot be opened and mounted, fuse-zip now returns
different error codes depending on the underlying error condition.

Ensured that C++ exceptions cannot escape from the following C-style
FUSE callbacks: fusezip_open, fusezip_create, fusezip_mknod,
fusezip_read, fusezip_write, fusezip_release, fusezip_ftruncate,
fusezip_truncate and fusezip_rename. This pattern could (should) be
applied to the rest of these FUSE callbacks.

Avoid logging filenames in syslog. Filenames can contain PII.
---
 lib/dataNode.cpp    |  30 ++----
 lib/fileNode.cpp    |  33 ------
 lib/fuse-zip.cpp    | 243 ++++++++++++++++++++++----------------------
 lib/fuse-zip.h      |   4 +-
 lib/fuseZipData.cpp |  74 ++++++++------
 lib/util.h          |  50 +++++++++
 main.cpp            |  17 ++--
 7 files changed, 231 insertions(+), 220 deletions(-)

diff --git a/lib/dataNode.cpp b/lib/dataNode.cpp
index 17c94c2..0efd7bc 100644
--- a/lib/dataNode.cpp
+++ b/lib/dataNode.cpp
@@ -27,9 +27,6 @@
 #include <cstring>
 #include <ctime>
 #include <memory>
-#include <stdexcept>
-
-#include <syslog.h>
 
 #include "dataNode.h"
 #include "extraField.h"
@@ -118,21 +115,13 @@ int DataNode::open(struct zip *zip) {
     }
     if (_state == NodeState::CLOSED) {
         _open_count = 1;
-        try {
-            assert(zip != NULL);
-            if (_size > std::numeric_limits<size_t>::max()) {
-                return -ENOMEM;
-            }
-            assert(_id != FAKE_ID);
-            _buffer.reset(new BigBuffer(zip, _id, static_cast<size_t>(_size)));
-            _state = NodeState::OPENED;
-        }
-        catch (std::bad_alloc&) {
+        assert(zip != NULL);
+        if (_size > std::numeric_limits<size_t>::max()) {
             return -ENOMEM;
         }
-        catch (std::exception&) {
-            return -EIO;
-        }
+        assert(_id != FAKE_ID);
+        _buffer.reset(new BigBuffer(zip, _id, static_cast<size_t>(_size)));
+        _state = NodeState::OPENED;
     }
     return 0;
 }
@@ -184,15 +173,10 @@ int DataNode::truncate(size_t offset) {
         if (_state != NodeState::NEW) {
             _state = NodeState::CHANGED;
         }
-        try {
-            _buffer->truncate(offset);
-            return 0;
-        }
-        catch (const std::bad_alloc &) {
-            return EIO;
-        }
+        _buffer->truncate(offset);
         _mtime = currentTime();
         _metadataChanged = true;
+        return 0;
     } else {
         return EBADF;
     }
diff --git a/lib/fileNode.cpp b/lib/fileNode.cpp
index bd1538c..efe1105 100644
--- a/lib/fileNode.cpp
+++ b/lib/fileNode.cpp
@@ -30,8 +30,6 @@
 #include <memory>
 #include <stdexcept>
 
-#include <syslog.h>
-
 #include "fileNode.h"
 #include "extraField.h"
 
@@ -54,22 +52,14 @@ FileNode *FileNode::createFile (struct zip *zip, const char *fname,
         uid_t owner, gid_t group, mode_t mode, dev_t dev) {
     auto data = DataNode::createNew(mode, owner, group, dev);
     FileNode *n = new FileNode(zip, fname, NEW_NODE_INDEX, std::move(data));
-    if (n == NULL) {
-        return NULL;
-    }
     n->parse_name();
-
     return n;
 }
 
 FileNode *FileNode::createSymlink(struct zip *zip, const char *fname) {
     auto data = DataNode::createNew(S_IFLNK | 0777, 0, 0, 0);
     FileNode *n = new FileNode(zip, fname, NEW_NODE_INDEX, std::move(data));
-    if (n == NULL) {
-        return NULL;
-    }
     n->parse_name();
-
     return n;
 }
 
@@ -80,12 +70,8 @@ FileNode *FileNode::createIntermediateDir(struct zip *zip,
         const char *fname) {
     auto data = DataNode::createTmpDir(S_IFDIR | 0755, 0, 0, 0);
     FileNode *n = new FileNode(zip, fname, TMP_DIR_INDEX, std::move(data));
-    if (n == NULL) {
-        return NULL;
-    }
     n->m_commentChanged = false;
     n->parse_name();
-
     return n;
 }
 
@@ -95,21 +81,14 @@ FileNode *FileNode::createDir(struct zip *zip, const char *fname,
     // FUSE does not pass S_IFDIR bit here
     auto data = DataNode::createNew(S_IFDIR | mode, owner, group, 0);
     FileNode *n = new FileNode(zip, fname, id, std::move(data));
-    if (n == NULL) {
-        return NULL;
-    }
     n->m_commentChanged = false;
     n->parse_name();
-
     return n;
 }
 
 FileNode *FileNode::createRootNode(struct zip *zip) {
     auto data = DataNode::createNew(S_IFDIR | 0755, 0, 0, 0);
     FileNode *n = new FileNode(zip, "", ROOT_NODE_INDEX, std::move(data));
-    if (n == NULL) {
-        return NULL;
-    }
     n->name = n->full_name.c_str();
 
     int len = 0;
@@ -133,13 +112,8 @@ FileNode *FileNode::createNodeForZipEntry(struct zip *zip,
     assert(id >= 0);
     auto data = DataNode::createExisting(zip, static_cast<zip_uint64_t>(id), mode);
     FileNode *n = new FileNode(zip, fname, id, data);
-    if (n == NULL) {
-        return NULL;
-    }
-
     n->parse_name();
     n->readComment();
-
     return n;
 }
 
@@ -147,13 +121,8 @@ FileNode *FileNode::createHardlink(struct zip *zip,
             const char *fname, zip_int64_t id, FileNode *target) {
     assert(id >= 0);
     FileNode *n = new FileNode(zip, fname, id, target->_data);
-    if (n == NULL) {
-        return NULL;
-    }
-
     n->parse_name();
     n->readComment();
-
     return n;
 }
 
@@ -427,8 +396,6 @@ bool FileNode::setComment(const char *value, uint16_t length) {
     char *newComment = NULL;
     if (value != NULL) {
         newComment = new char[length];
-        if (newComment == NULL)
-            return false;
         memcpy(newComment, value, length);
     }
 
diff --git a/lib/fuse-zip.cpp b/lib/fuse-zip.cpp
index 0db402e..061cc6d 100644
--- a/lib/fuse-zip.cpp
+++ b/lib/fuse-zip.cpp
@@ -41,76 +41,67 @@
 #include <cstring>
 #include <cstdlib>
 #include <limits>
+#include <memory>
 #include <queue>
 
 #include "fuse-zip.h"
 #include "types.h"
 #include "fileNode.h"
 #include "fuseZipData.h"
+#include "util.h"
 
 static const char FILE_COMMENT_XATTR_NAME[] = "user.comment";
 static const size_t FILE_COMMENT_XATTR_NAME_LENZ = 13; // length including NULL-byte
 
 using namespace std;
 
-//TODO: Move printf-s out this function
+// Converts a C++ exception into a negative error code.
+// Logs the error to stderr and syslog.
+// Must be called from within a catch block.
+static int exceptionToError(const char *const action, const char *const file) {
+    const auto log = [action, file](const char *const reason) {
+        fprintf(stderr, "Cannot %s '%s': %s\n", action, file, reason);
+        syslog(LOG_ERR, "Cannot %s: %s", action, reason);
+    };
+
+    try {
+        throw;
+    } catch (const std::bad_alloc &) {
+        log("No memory");
+        return -ENOMEM;
+    } catch (const std::exception &e) {
+        log(e.what());
+        return -EIO;
+    } catch (...) {
+        log("Unknown error");
+        return -EIO;
+    }
+}
+
 FuseZipData *initFuseZip(const char *program, const char *fileName,
-        bool readonly, bool force_precise_time) {
-    FuseZipData *data = NULL;
+                         bool readonly, bool force_precise_time) {
+    (void)program;
     int err;
-    struct zip *zip_file;
-    
-    int flags = (readonly) ? ZIP_RDONLY : ZIP_CREATE;
-    if ((zip_file = zip_open(fileName, flags, &err)) == NULL) {
-        zip_error_t error;
-        zip_error_init_with_code(&error, err);
-        fprintf(stderr, "%s: cannot open ZIP archive %s: %s\n", program, fileName, zip_error_strerror(&error));
-        zip_error_fini(&error);
-        return data;
-    }
+    const int flags = readonly ? ZIP_RDONLY : ZIP_CREATE;
+    struct zip *const zip_file = zip_open(fileName, flags, &err);
 
-    try {
-        // current working directory
-        char *cwd = (char*)malloc(PATH_MAX + 1);
-        if (cwd == NULL) {
-            throw std::bad_alloc();
-        }
-        if (getcwd(cwd, PATH_MAX) == NULL) {
-            perror(NULL);
-            free(cwd);
-            return data;
-        }
+    if (!zip_file)
+        throw ZipError("Cannot open ZIP archive", err);
 
-        data = new FuseZipData(fileName, zip_file, cwd, force_precise_time);
-        free(cwd);
-        if (data == NULL) {
-            throw std::bad_alloc();
-        }
-        try {
-            data->build_tree(readonly);
-        }
-        catch (...) {
-            delete data;
-            throw;
-        }
-    }
-    catch (std::bad_alloc&) {
-        syslog(LOG_ERR, "no enough memory");
-        fprintf(stderr, "%s: no enough memory\n", program);
-        return NULL;
-    }
-    catch (const std::exception &e) {
-        syslog(LOG_ERR, "error opening ZIP file: %s", e.what());
-        fprintf(stderr, "%s: unable to open ZIP file: %s\n", program, e.what());
-        return NULL;
-    }
-    return data;
+    // current working directory
+    char cwd[PATH_MAX + 1];
+    if (!getcwd(cwd, PATH_MAX))
+        throw std::runtime_error("Cannot get current directory");
+
+    std::unique_ptr<FuseZipData> data(
+        new FuseZipData(fileName, zip_file, cwd, force_precise_time));
+    data->build_tree(readonly);
+    return data.release();
 }
 
 void *fusezip_init(struct fuse_conn_info *conn) {
     (void) conn;
     FuseZipData *data = (FuseZipData*)fuse_get_context()->private_data;
-    syslog(LOG_INFO, "Mounting file system on %s (cwd=%s)", data->m_archiveName, data->m_cwd.c_str());
     return data;
 }
 
@@ -126,7 +117,6 @@ void fusezip_destroy(void *data) {
     FuseZipData *d = (FuseZipData*)data;
     d->save ();
     delete d;
-    syslog(LOG_INFO, "File system unmounted");
 }
 
 FileNode *get_file_node(const char *fname) {
@@ -208,7 +198,7 @@ int fusezip_statfs(const char *path, struct statvfs *buf) {
     return 0;
 }
 
-int fusezip_open(const char *path, struct fuse_file_info *fi) {
+int fusezip_open(const char *path, struct fuse_file_info *fi) try {
     if (*path == '\0') {
         return -ENOENT;
     }
@@ -221,18 +211,13 @@ int fusezip_open(const char *path, struct fuse_file_info *fi) {
     }
     fi->fh = (uint64_t)node;
 
-    try {
-        return node->open();
-    }
-    catch (std::bad_alloc&) {
-        return -ENOMEM;
-    }
-    catch (std::exception&) {
-        return -EIO;
-    }
+    return node->open();
+} catch (...) {
+    return exceptionToError("open file", path);
 }
 
-int fusezip_create(const char *path, mode_t mode, struct fuse_file_info *fi) {
+int fusezip_create(const char *path, mode_t mode,
+                   struct fuse_file_info *fi) try {
     if (*path == '\0') {
         return -EACCES;
     }
@@ -240,18 +225,20 @@ int fusezip_create(const char *path, mode_t mode, struct fuse_file_info *fi) {
     if (node != NULL) {
         return -EEXIST;
     }
-    node = FileNode::createFile (get_zip(), path + 1,
-            fuse_get_context()->uid, fuse_get_context()->gid, mode);
+    node = FileNode::createFile(get_zip(), path + 1, fuse_get_context()->uid,
+                                fuse_get_context()->gid, mode);
     if (node == NULL) {
         return -ENOMEM;
     }
-    get_data()->insertNode (node);
+    get_data()->insertNode(node);
     fi->fh = (uint64_t)node;
 
     return node->open();
+} catch (...) {
+    return exceptionToError("create file", path);
 }
 
-int fusezip_mknod(const char *path, mode_t mode, dev_t dev) {
+int fusezip_mknod(const char *path, mode_t mode, dev_t dev) try {
     if (*path == '\0') {
         return -EACCES;
     }
@@ -259,47 +246,55 @@ int fusezip_mknod(const char *path, mode_t mode, dev_t dev) {
     if (node != NULL) {
         return -EEXIST;
     }
-    node = FileNode::createFile (get_zip(), path + 1,
-            fuse_get_context()->uid, fuse_get_context()->gid, mode, dev);
+    node = FileNode::createFile(get_zip(), path + 1, fuse_get_context()->uid,
+                                fuse_get_context()->gid, mode, dev);
     if (node == NULL) {
         return -ENOMEM;
     }
-    get_data()->insertNode (node);
+    get_data()->insertNode(node);
 
     return 0;
+} catch (...) {
+    return exceptionToError("mknod", path);
 }
 
-int fusezip_read(const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi) {
-    (void) path;
-
+int fusezip_read(const char *path, char *buf, size_t size, off_t offset,
+                 struct fuse_file_info *fi) try {
     if (offset < 0)
         return -EINVAL;
-    return ((FileNode*)fi->fh)->read(buf, size, static_cast<size_t>(offset));
+    return reinterpret_cast<FileNode *>(fi->fh)->read(
+        buf, size, static_cast<size_t>(offset));
+} catch (...) {
+    return exceptionToError("read file", path);
 }
 
-int fusezip_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi) {
-    (void) path;
-
+int fusezip_write(const char *path, const char *buf, size_t size, off_t offset,
+                  struct fuse_file_info *fi) try {
     if (offset < 0)
         return -EINVAL;
-    return ((FileNode*)fi->fh)->write(buf, size, static_cast<size_t>(offset));
+    return reinterpret_cast<FileNode *>(fi->fh)->write(
+        buf, size, static_cast<size_t>(offset));
+} catch (...) {
+    return exceptionToError("write file", path);
 }
 
-int fusezip_release (const char *path, struct fuse_file_info *fi) {
-    (void) path;
-
-    return ((FileNode*)fi->fh)->close();
+int fusezip_release(const char *path, struct fuse_file_info *fi) try {
+    return reinterpret_cast<FileNode *>(fi->fh)->close();
+} catch (...) {
+    return exceptionToError("close file", path);
 }
 
-int fusezip_ftruncate(const char *path, off_t offset, struct fuse_file_info *fi) {
-    (void) path;
-
+int fusezip_ftruncate(const char *path, off_t offset,
+                      struct fuse_file_info *fi) try {
     if (offset < 0)
         return -EINVAL;
-    return -((FileNode*)fi->fh)->truncate(static_cast<size_t>(offset));
+    return -reinterpret_cast<FileNode *>(fi->fh)->truncate(
+        static_cast<size_t>(offset));
+} catch (...) {
+    return exceptionToError("truncate file", path);
 }
 
-int fusezip_truncate(const char *path, off_t offset) {
+int fusezip_truncate(const char *path, off_t offset) try {
     if (*path == '\0') {
         return -EACCES;
     }
@@ -321,6 +316,8 @@ int fusezip_truncate(const char *path, off_t offset) {
         return -res;
     }
     return node->close();
+} catch (...) {
+    return exceptionToError("truncate file", path);
 }
 
 int fusezip_unlink(const char *path) {
@@ -371,7 +368,7 @@ int fusezip_mkdir(const char *path, mode_t mode) {
     return 0;
 }
 
-int fusezip_rename(const char *path, const char *new_path) {
+int fusezip_rename(const char *path, const char *new_path) try {
     if (*path == '\0') {
         return -ENOENT;
     }
@@ -385,7 +382,7 @@ int fusezip_rename(const char *path, const char *new_path) {
     FileNode *new_node = get_file_node(new_path + 1);
     if (new_node != NULL) {
         int res = get_data()->removeNode(new_node);
-        if (res !=0) {
+        if (res != 0) {
             return -res;
         }
     }
@@ -403,48 +400,46 @@ int fusezip_rename(const char *path, const char *new_path) {
         new_name.push_back('/');
     }
 
-    try {
-        struct zip *z = get_zip();
-        // Renaming directory and its content recursively
-        if (node->is_dir()) {
-            queue<FileNode*> q;
-            q.push(node);
-            while (!q.empty()) {
-                FileNode *n = q.front();
-                q.pop();
-                for (nodelist_t::const_iterator i = n->childs.begin(); i != n->childs.end(); ++i) {
-                    FileNode *nn = *i;
-                    q.push(nn);
-                    char *name = (char*)malloc(len + nn->full_name.size() - oldLen + (nn->is_dir() ? 2 : 1));
-                    if (name == NULL) {
-                        //TODO: check that we are have enough memory before entering this loop
-                        return -ENOMEM;
-                    }
-                    strcpy(name, new_name.c_str());
-                    strcpy(name + len, nn->full_name.c_str() + oldLen);
-                    if (nn->is_dir()) {
-                        strcat(name, "/");
-                    }
-                    if (nn->present_in_zip()) {
-                        zip_file_rename(z, nn->id(), name, ZIP_FL_ENC_GUESS);
-                    }
-                    // changing child list may cause loop iterator corruption
-                    get_data()->renameNode (nn, name, false);
-                    
-                    free(name);
+    struct zip *z = get_zip();
+    // Renaming directory and its content recursively
+    if (node->is_dir()) {
+        queue<FileNode *> q;
+        q.push(node);
+        while (!q.empty()) {
+            FileNode *n = q.front();
+            q.pop();
+            for (FileNode *const nn : n->childs) {
+                q.push(nn);
+                char *name = (char *)malloc(len + nn->full_name.size() -
+                                            oldLen + (nn->is_dir() ? 2 : 1));
+                if (name == NULL) {
+                    // TODO: check that we are have enough memory before
+                    // entering this loop
+                    return -ENOMEM;
                 }
+                strcpy(name, new_name.c_str());
+                strcpy(name + len, nn->full_name.c_str() + oldLen);
+                if (nn->is_dir()) {
+                    strcat(name, "/");
+                }
+                if (nn->present_in_zip()) {
+                    zip_file_rename(z, nn->id(), name, ZIP_FL_ENC_GUESS);
+                }
+                // changing child list may cause loop iterator corruption
+                get_data()->renameNode(nn, name, false);
+
+                free(name);
             }
         }
-        if (node->present_in_zip()) {
-            zip_file_rename(z, node->id(), new_name.c_str(), ZIP_FL_ENC_GUESS);
-        }
-        get_data()->renameNode (node, new_name.c_str(), true);
-
-        return 0;
     }
-    catch (...) {
-        return -EIO;
+    if (node->present_in_zip()) {
+        zip_file_rename(z, node->id(), new_name.c_str(), ZIP_FL_ENC_GUESS);
     }
+    get_data()->renameNode(node, new_name.c_str(), true);
+
+    return 0;
+} catch (...) {
+    return exceptionToError("rename", path);
 }
 
 int fusezip_utimens(const char *path, const struct timespec tv[2]) {
diff --git a/lib/fuse-zip.h b/lib/fuse-zip.h
index c52cc62..0e9730f 100644
--- a/lib/fuse-zip.h
+++ b/lib/fuse-zip.h
@@ -42,8 +42,6 @@ class FuseZipData *initFuseZip(const char *program, const char *fileName,
 /**
  * Initialize filesystem
  *
- * Report current working dir and archive file name to syslog.
- *
  * @return filesystem-private data
  */
 void *fusezip_init(struct fuse_conn_info *conn);
@@ -51,7 +49,7 @@ void *fusezip_init(struct fuse_conn_info *conn);
 /**
  * Destroy filesystem
  *
- * Save all modified data back to ZIP archive and report to syslog about completion.
+ * Save all modified data back to ZIP archive.
  * Note that filesystem unmounted before this method finishes
  * (see https://bitbucket.org/agalanin/fuse-zip/issues/7).
  */
diff --git a/lib/fuseZipData.cpp b/lib/fuseZipData.cpp
index 6852678..d9ff5cb 100644
--- a/lib/fuseZipData.cpp
+++ b/lib/fuseZipData.cpp
@@ -18,7 +18,6 @@
 ////////////////////////////////////////////////////////////////////////////
 
 #include <zip.h>
-#include <syslog.h>
 #include <cassert>
 #include <cerrno>
 #include <cstring>
@@ -37,21 +36,24 @@ FuseZipData::FuseZipData(const char *archiveName, struct zip *z, const char *cwd
 
 FuseZipData::~FuseZipData() {
     if (chdir(m_cwd.c_str()) != 0) {
-        syslog(LOG_ERR, "Unable to chdir() to archive directory %s: %s. Trying to save file into $TMP or /tmp...",
+        fprintf(stderr, "Cannot chdir to archive directory '%s': %s\n",
                 m_cwd.c_str(), strerror(errno));
         const char *tmpDir = getenv("TMP");
         if (tmpDir == NULL || chdir(tmpDir) != 0) {
             if (tmpDir != NULL) {
-                syslog(LOG_WARNING, "Unable to chdir() to %s: %s.", tmpDir, strerror(errno));
+                fprintf(stderr, "Cannot chdir to '%s': %s\n", tmpDir,
+                        strerror(errno));
             }
             if (chdir("/tmp") != 0) {
-                syslog(LOG_ERR, "Unable to chdir() to /tmp: %s!", strerror(errno));
+                fprintf(stderr, "Cannot chdir to '/tmp': %s\n",
+                        strerror(errno));
             }
         }
     }
     int res = zip_close(m_zip);
     if (res != 0) {
-        syslog(LOG_ERR, "Error while closing archive: %s", zip_strerror(m_zip));
+        fprintf(stderr, "Error while closing archive: %s\n",
+                zip_strerror(m_zip));
     }
     for (filemap_t::iterator i = files.begin(); i != files.end(); ++i) {
         delete i->second;
@@ -103,7 +105,8 @@ void FuseZipData::build_tree(bool readonly) {
         if (notHLink)
             attachNode(i, name, mode, readonly, needPrefix, origNames);
         else if (!readonly)
-            throw std::runtime_error("hard links are supported only in read-only mode");
+            throw ZipError("Hard links are supported only in read-only mode",
+                           ZIP_ER_OPNOTSUPP);
     }
     // Connect nodes to tree. Missing intermediate nodes created on demand.
     for (filemap_t::const_iterator i = files.begin(); i != files.end(); ++i)
@@ -126,7 +129,7 @@ void FuseZipData::connectNodeToTree (FileNode *node) {
         files[parent->full_name.c_str()] = parent;
         connectNodeToTree (parent);
     } else if (!parent->is_dir()) {
-        throw std::runtime_error ("bad archive structure");
+        throw ZipError("Bad archive structure", ZIP_ER_INCONS);
     }
     // connecting to parent
     node->parent = parent;
@@ -241,8 +244,8 @@ void FuseZipData::attachNode(zip_int64_t id, const char *name, mode_t mode, bool
     convertFileName(name, readonly, needPrefix, converted);
     const char *cname = converted.c_str();
     if (files.find(cname) != files.end()) {
-        syslog(LOG_ERR, "duplicated file name: %s", cname);
-        throw std::runtime_error("duplicate file names");
+        throw ZipError(std::string("Duplicated file name: ") + cname,
+                       ZIP_ER_EXISTS);
     }
     FileNode *node = FileNode::createNodeForZipEntry(m_zip, cname, id, mode);
     if (node == NULL) {
@@ -263,7 +266,7 @@ bool FuseZipData::attachHardlink(zip_int64_t sid, const char *name, mode_t mode,
         field = zip_file_extra_field_get_by_id(m_zip, id, FZ_EF_PKWARE_UNIX, 0, &len, ZIP_FL_LOCAL);
     if (!field) {
         // ignoring hardlink without PKWARE UNIX field
-        syslog(LOG_INFO, "%s: PKWARE UNIX field is absent for hardlink\n", name);
+        fprintf(stderr, "%s: PKWARE UNIX field is absent for hardlink\n", name);
         return false;
     }
 
@@ -276,13 +279,13 @@ bool FuseZipData::attachHardlink(zip_int64_t sid, const char *name, mode_t mode,
     if (!ExtraField::parsePkWareUnixField(len, field, mode, mt, at,
                 uid, gid, dev, link, link_len))
     {
-        syslog(LOG_WARNING, "%s: unable to parse PKWARE UNIX field\n", name);
+        fprintf(stderr, "%s: unable to parse PKWARE UNIX field\n", name);
         return false;
     }
 
     if (link_len == 0 || !link)
     {
-        syslog(LOG_ERR, "%s: hard link target is empty\n", name);
+        fprintf(stderr, "%s: hard link target is empty\n", name);
         return true;
     }
 
@@ -291,7 +294,8 @@ bool FuseZipData::attachHardlink(zip_int64_t sid, const char *name, mode_t mode,
     auto it = origNames.find(linkStr.c_str());
     if (it == origNames.end())
     {
-        syslog(LOG_ERR, "%s: unable to find link target %s\n", name, linkStr.c_str());
+        fprintf(stderr, "%s: unable to find link target %s\n", name,
+                linkStr.c_str());
         return true;
     }
 
@@ -304,7 +308,8 @@ bool FuseZipData::attachHardlink(zip_int64_t sid, const char *name, mode_t mode,
         }
         else
         {
-            syslog(LOG_ERR, "%s: file format differs with link target %s\n", name, linkStr.c_str());
+            fprintf(stderr, "%s: file format differs with link target %s\n",
+                    name, linkStr.c_str());
             return true;
         }
     }
@@ -313,8 +318,8 @@ bool FuseZipData::attachHardlink(zip_int64_t sid, const char *name, mode_t mode,
     convertFileName(name, readonly, needPrefix, converted);
     const char *cname = converted.c_str();
     if (files.find(cname) != files.end()) {
-        syslog(LOG_ERR, "duplicated file name: %s", cname);
-        throw std::runtime_error("duplicate file names");
+        throw ZipError(std::string("Duplicated file name: ") + cname,
+                       ZIP_ER_EXISTS);
     }
     FileNode *node = FileNode::createHardlink(m_zip, cname, sid, it->second);
     if (node == NULL) {
@@ -345,10 +350,10 @@ int FuseZipData::removeNode(FileNode *node) {
 
 void FuseZipData::validateFileName(const char *fname) {
     if (fname[0] == 0) {
-        throw std::runtime_error("empty file name");
+        throw ZipError("Empty file name", ZIP_ER_INCONS);
     }
     if (strstr(fname, "//") != NULL) {
-        throw std::runtime_error(std::string("bad file name (two slashes): ") + fname);
+        throw ZipError(std::string("Bad file name: ") + fname, ZIP_ER_INCONS);
     }
 }
 
@@ -367,7 +372,9 @@ void FuseZipData::convertFileName(const char *fname, bool readonly,
     // add prefix
     if (fname[0] == '/') {
         if (!readonly) {
-            throw std::runtime_error("absolute paths are not supported in read-write mode");
+            throw ZipError(
+                "Absolute paths are not supported in read-write mode",
+                ZIP_ER_OPNOTSUPP);
         } else {
             assert(needPrefix);
             converted.append(ROOT_PREFIX);
@@ -377,7 +384,9 @@ void FuseZipData::convertFileName(const char *fname, bool readonly,
         bool parentRelative = false;
         while (strncmp(fname, "../", 3) == 0) {
             if (!readonly) {
-                throw std::runtime_error("paths relative to parent directory are not supported in read-write mode");
+                throw ZipError("Paths relative to parent directory are not "
+                               "supported in read-write mode",
+                               ZIP_ER_OPNOTSUPP);
             }
             assert(needPrefix);
             converted.append(UP_PREFIX);
@@ -400,14 +409,15 @@ void FuseZipData::convertFileName(const char *fname, bool readonly,
     while (start[0] != 0 && (cur = strchr(start + 1, '/')) != NULL) {
         if ((cur - start == 1 && start[0] == '.') ||
             (cur - start == 2 && start[0] == '.' && start[1] == '.')) {
-            throw std::runtime_error(std::string("bad file name: ") + orig);
+            throw ZipError(std::string("Bad file name: ") + orig,
+                           ZIP_ER_INCONS);
         }
         converted.append(start, static_cast<size_t>(cur - start + 1));
         start = cur + 1;
     }
     // end of string is reached
     if (strcmp(start, ".") == 0 || strcmp(start, "..") == 0) {
-        throw std::runtime_error(std::string("bad file name: ") + orig);
+        throw ZipError(std::string("Bad file name: ") + orig, ZIP_ER_INCONS);
     }
     converted.append(start);
 }
@@ -471,7 +481,8 @@ void FuseZipData::save () {
             if (node->isCommentChanged()) {
                 int res = node->saveComment();
                 if (res != 0) {
-                    syslog(LOG_ERR, "Error while saving archive comment: %d", res);
+                    fprintf(stderr, "Error %d while saving archive comment\n",
+                            res);
                 }
             }
             continue;
@@ -483,8 +494,8 @@ void FuseZipData::save () {
             int res = node->save();
             if (res != 0) {
                 saveMetadata = false;
-                syslog(LOG_ERR, "Error while saving file %s in ZIP archive: %d",
-                        node->full_name.c_str(), res);
+                fprintf(stderr, "Error %d while saving file '%s'\n", res,
+                        node->full_name.c_str());
             }
         }
         if (saveMetadata) {
@@ -493,23 +504,24 @@ void FuseZipData::save () {
                 zip_int64_t idx = zip_dir_add(m_zip,
                         node->full_name.c_str(), ZIP_FL_ENC_GUESS);
                 if (idx < 0) {
-                    syslog(LOG_ERR, "Unable to save directory %s in ZIP archive",
-                        node->full_name.c_str());
+                    fprintf(stderr, "Cannot save directory '%s'\n",
+                            node->full_name.c_str());
                     continue;
                 }
                 node->set_id(idx);
             }
             int res = node->saveMetadata(m_force_precise_time);
             if (res != 0) {
-                syslog(LOG_ERR, "Error while saving metadata for file %s in ZIP archive: %d",
-                        node->full_name.c_str(), res);
+                fprintf(stderr,
+                        "Error %d while saving metadata for file '%s'\n", res,
+                        node->full_name.c_str());
             }
         }
         if (node->isCommentChanged()) {
             int res = node->saveComment();
             if (res != 0) {
-                syslog(LOG_ERR, "Error while saving comment for file %s in ZIP archive: %d",
-                        node->full_name.c_str(), res);
+                fprintf(stderr, "Error %d while saving comment for file '%s'\n",
+                        res, node->full_name.c_str());
             }
         }
     }
diff --git a/lib/util.h b/lib/util.h
index 94ac191..1fe63be 100644
--- a/lib/util.h
+++ b/lib/util.h
@@ -20,8 +20,58 @@
 #ifndef UTIL_H
 #define UTIL_H
 
+#include <stdexcept>
+#include <string>
+#include <utility>
+
 #include <time.h>
+#include <zip.h>
 
 struct timespec currentTime();
 
+/** An exception carrying a libzip error code. */
+class ZipError : public std::runtime_error {
+  public:
+    ZipError(std::string message, zip_t *const archive)
+        : std::runtime_error(MakeMessage(std::move(message), archive)),
+          code_(zip_error_code_zip(zip_get_error(archive))) {}
+
+    ZipError(std::string message, zip_file_t *const file)
+        : std::runtime_error(MakeMessage(std::move(message), file)),
+          code_(zip_error_code_zip(zip_file_get_error(file))) {}
+
+    ZipError(std::string message, const int code)
+        : std::runtime_error(MakeMessage(std::move(message), code)),
+          code_(code) {}
+
+    /** Gets the libzip error code. */
+    int code() const { return code_; }
+
+    static std::string MakeMessage(std::string message, zip_t *const archive) {
+        message += ": ";
+        message += zip_strerror(archive);
+        return message;
+    }
+
+    static std::string MakeMessage(std::string message,
+                                   zip_file_t *const file) {
+        message += ": ";
+        message += zip_file_strerror(file);
+        return message;
+    }
+
+    static std::string MakeMessage(std::string message, const int code) {
+        message += ": ";
+        zip_error_t ze;
+        zip_error_init_with_code(&ze, code);
+        message += zip_error_strerror(&ze);
+        zip_error_fini(&ze);
+        return message;
+    }
+
+  private:
+    /** libzip error code. */
+    const int code_;
+};
+
 #endif
diff --git a/main.cpp b/main.cpp
index cb19ac5..1503523 100644
--- a/main.cpp
+++ b/main.cpp
@@ -41,6 +41,7 @@
 
 #include "fuse-zip.h"
 #include "fuseZipData.h"
+#include "util.h"
 
 #if (LIBZIP_VERSION_MAJOR < 1)
     #error "libzip >= 1.0 is required!"
@@ -191,7 +192,7 @@ static const struct fuse_opt fusezip_opts[] = {
     {NULL, 0, 0}
 };
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[]) try {
     if (sizeof(void*) > sizeof(uint64_t)) {
         fprintf(stderr,"%s: This program cannot be run on your system because of FUSE design limitation\n", PROGRAM);
         return EXIT_FAILURE;
@@ -237,11 +238,7 @@ int main(int argc, char *argv[]) {
         }
 
         openlog(PROGRAM, LOG_PID, LOG_USER);
-        if ((data = initFuseZip(PROGRAM, param.fileName, param.readonly, param.force_precise_time))
-                == NULL) {
-            fuse_opt_free_args(&args);
-            return EXIT_FAILURE;
-        }
+        data = initFuseZip(PROGRAM, param.fileName, param.readonly, param.force_precise_time);
     }
 
     static struct fuse_operations fusezip_oper;
@@ -301,5 +298,13 @@ int main(int argc, char *argv[]) {
     res = fuse_loop(fuse);
     fuse_teardown(fuse, mountpoint);
     return (res == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+} catch (const ZipError& e) {
+  fprintf(stderr,"%s: %s\n", PROGRAM, e.what());
+  // Shift libzip error codes in order to avoid collision with FUSE errors.
+  const int ZIP_ER_BASE = 10;
+  return ZIP_ER_BASE + e.code();
+} catch (const std::exception& e) {
+  fprintf(stderr,"%s: %s\n", PROGRAM, e.what());
+  return EXIT_FAILURE;
 }
 
-- 
2.29.1.341.ge80a0c044ae-goog