rbczmq 1.7.1 → 1.7.2

data/ext/czmq/src/zdir.c

@@ -0,0 +1,409 @@
+/*  =========================================================================
+    zdir - work with file-system directories
+
+    -------------------------------------------------------------------------
+    Copyright (c) 1991-2013 iMatix Corporation <www.imatix.com>
+    Copyright other contributors as noted in the AUTHORS file.
+
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by the
+    Free Software Foundation; either version 3 of the License, or (at your
+    option) any later version.
+
+    This software is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTA-
+    BILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
+    Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program. If not, see http://www.gnu.org/licenses/.
+    =========================================================================*/
+
+/*
+@header
+    The zdir class gives access to the file system index. It will load
+    a directory tree (a directory plus all child directories) into a
+    zdir structure and then let you navigate that structure. It exists
+    mainly to wrap non-portable OS functions to do this.
+@discuss
+@end
+*/
+
+#include "../include/czmq.h"
+
+//  Structure of our class
+
+struct _zdir_t {
+    char *path;             //  Directory name + separator
+    zlist_t *files;         //  List of files in directory
+    zlist_t *subdirs;       //  List of subdirectories
+    time_t modified;        //  Most recent file including subdirs
+    off_t  cursize;         //  Total file size including subdirs
+    size_t count;           //  Total file count including subdirs
+};
+
+#if (defined (WIN32))
+static void
+s_win32_populate_entry (zdir_t *self, WIN32_FIND_DATA *entry)
+{
+    if (entry->cFileName [0] == '.')
+        ; //  Skip hidden files
+    else
+    //  If we have a subdirectory, go load that
+    if (entry->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+        zdir_t *subdir = zdir_new (entry->cFileName, self->path);
+        zlist_append (self->subdirs, subdir);
+    }
+    else {
+        //  Add file entry to directory list
+        zfile_t *file = zfile_new (self->path, entry->cFileName);
+        zlist_append (self->files, file);
+    }
+}
+
+#else
+static void
+s_posix_populate_entry (zdir_t *self, struct dirent *entry)
+{
+    //  Skip . and ..
+    if (streq (entry->d_name, ".")
+    ||  streq (entry->d_name, ".."))
+        return;
+
+    char fullpath [1024 + 1];
+    snprintf (fullpath, 1024, "%s/%s", self->path, entry->d_name);
+    struct stat stat_buf;
+    if (stat (fullpath, &stat_buf))
+        return;
+
+    if (entry->d_name [0] == '.')
+        ; //  Skip hidden files
+    else
+    //  If we have a subdirectory, go load that
+    if (stat_buf.st_mode & S_IFDIR) {
+        zdir_t *subdir = zdir_new (entry->d_name, self->path);
+        zlist_append (self->subdirs, subdir);
+    }
+    else {
+        //  Add file entry to directory list
+        zfile_t *file = zfile_new (self->path, entry->d_name);
+        zlist_append (self->files, file);
+    }
+}
+#endif
+
+
+//  --------------------------------------------------------------------------
+//  Constructor
+//  Create a new directory item that loads in the full tree of the
+//  specified path, optionally located under some parent path.
+
+zdir_t *
+zdir_new (const char *path, const char *parent)
+{
+    zdir_t *self = (zdir_t *) zmalloc (sizeof (zdir_t));
+    if (parent) {
+        self->path = (char *) malloc (strlen (path) + strlen (parent) + 2);
+        sprintf (self->path, "%s/%s", parent, path);
+    }
+    else
+        self->path = strdup (path);
+    self->files = zlist_new ();
+    self->subdirs = zlist_new ();
+
+#if (defined (WIN32))
+    //  On Windows, replace backslashes by normal slashes
+    char *path_clean_ptr = self->path;
+    while (*path_clean_ptr) {
+        if (*path_clean_ptr == '\\')
+            *path_clean_ptr = '/';
+        path_clean_ptr++;
+    }
+    //  Remove any trailing slash
+    if (self->path [strlen (self->path) - 1] == '/')
+        self->path [strlen (self->path) - 1] = 0;
+
+    //  Win32 wants a wildcard at the end of the path
+    char *wildcard = (char *) malloc (strlen (self->path) + 3);
+    sprintf (wildcard, "%s/*", self->path);
+    WIN32_FIND_DATA entry;
+    HANDLE handle = FindFirstFile (wildcard, &entry);
+    free (wildcard);
+
+    if (handle != INVALID_HANDLE_VALUE) {
+        //  We have read an entry, so return those values
+        s_win32_populate_entry (self, &entry);
+        while (FindNextFile (handle, &entry))
+            s_win32_populate_entry (self, &entry);
+        FindClose (handle);
+    }
+#else
+    //  Remove any trailing slash
+    if (self->path [strlen (self->path) - 1] == '/')
+        self->path [strlen (self->path) - 1] = 0;
+
+    DIR *handle = opendir (self->path);
+    if (handle) {
+        //  Calculate system-specific size of dirent block
+        int dirent_size = offsetof (struct dirent, d_name)
+                        + pathconf (self->path, _PC_NAME_MAX) + 1;
+        struct dirent *entry = (struct dirent *) malloc (dirent_size);
+        struct dirent *result;
+
+        int rc = readdir_r (handle, entry, &result);
+        while (rc == 0 && result != NULL) {
+            s_posix_populate_entry (self, entry);
+            rc = readdir_r (handle, entry, &result);
+        }
+        free (entry);
+        closedir (handle);
+    }
+#endif
+    else {
+        zdir_destroy (&self);
+        return NULL;
+    }
+    //  Update directory signatures
+    zdir_t *subdir = (zdir_t *) zlist_first (self->subdirs);
+    while (subdir) {
+        if (self->modified < subdir->modified)
+            self->modified = subdir->modified;
+        self->cursize += subdir->cursize;
+        self->count += subdir->count;
+        subdir = (zdir_t *) zlist_next (self->subdirs);
+    }
+    zfile_t *file = (zfile_t *) zlist_first (self->files);
+    while (file) {
+        if (self->modified < zfile_modified (file))
+            self->modified = zfile_modified (file);
+        self->cursize += zfile_cursize (file);
+        self->count += 1;
+        file = (zfile_t *) zlist_next (self->files);
+    }
+    return self;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Destroy a directory item
+
+void
+zdir_destroy (zdir_t **self_p)
+{
+    assert (self_p);
+    if (*self_p) {
+        zdir_t *self = *self_p;
+        while (zlist_size (self->subdirs)) {
+            zdir_t *subdir = (zdir_t *) zlist_pop (self->subdirs);
+            zdir_destroy (&subdir);
+        }
+        while (zlist_size (self->files)) {
+            zfile_t *file = (zfile_t *) zlist_pop (self->files);
+            zfile_destroy (&file);
+        }
+        zlist_destroy (&self->subdirs);
+        zlist_destroy (&self->files);
+        free (self->path);
+        free (self);
+        *self_p = NULL;
+    }
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return directory path
+
+char *
+zdir_path (zdir_t *self)
+{
+    return self->path;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return last modification time for directory.
+
+time_t
+zdir_modified (zdir_t *self)
+{
+    assert (self);
+    return self->modified;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return total hierarchy size, in bytes of data contained in all files
+//  in the directory tree.
+
+off_t
+zdir_cursize (zdir_t *self)
+{
+    assert (self);
+    return self->cursize;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return directory count
+
+size_t
+zdir_count (zdir_t *self)
+{
+    assert (self);
+    return self->count;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Returns a sorted array of zfile objects; returns a single block of memory,
+//  that you destroy by calling free(). Each entry in the array is a pointer
+//  to a zfile_t item already allocated in the zdir tree. The array ends with
+//  a null pointer. Do not destroy the original zdir tree until you are done
+//  with this array.
+
+static int  s_dir_flatten (zdir_t *self, zfile_t **files, int index);
+static bool s_dir_compare (void *item1, void *item2);
+static bool s_file_compare (void *item1, void *item2);
+
+zfile_t **
+zdir_flatten (zdir_t *self)
+{
+    int flat_size;
+    if (self)
+        flat_size = self->count + 1;
+    else
+        flat_size = 1;      //  Just null terminator
+
+    zfile_t **files = (zfile_t **) zmalloc (sizeof (zfile_t *) * flat_size);
+    uint index = 0;
+    if (self)
+        index = s_dir_flatten (self, files, index);
+    return files;
+}
+
+
+//  Flatten one directory, calls itself recursively
+
+static int
+s_dir_flatten (zdir_t *self, zfile_t **files, int index)
+{
+    //  First flatten the normal files
+    zlist_sort (self->files, s_file_compare);
+    zfile_t *file = (zfile_t *) zlist_first (self->files);
+    while (file) {
+        files [index++] = file;
+        file = (zfile_t *) zlist_next (self->files);
+    }
+    //  Now flatten subdirectories, recursively
+    zlist_sort (self->subdirs, s_dir_compare);
+    zdir_t *subdir = (zdir_t *) zlist_first (self->subdirs);
+    while (subdir) {
+        index = s_dir_flatten (subdir, files, index);
+        subdir = (zdir_t *) zlist_next (self->subdirs);
+    }
+    return index;
+}
+
+//  Compare two subdirs, true if they need swapping
+static bool
+s_dir_compare (void *item1, void *item2)
+{
+    if (strcmp (zdir_path ((zdir_t *) item1),
+                zdir_path ((zdir_t *) item2)) > 0)
+        return true;
+    else
+        return false;
+}
+
+//  Compare two files, true if they need swapping
+//  We sort by ascending name
+
+static bool
+s_file_compare (void *item1, void *item2)
+{
+    if (strcmp (zfile_filename ((zfile_t *) item1, NULL),
+                zfile_filename ((zfile_t *) item2, NULL)) > 0)
+        return true;
+    else
+        return false;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Print contents of directory
+
+void
+zdir_dump (zdir_t *self, int indent)
+{
+    assert (self);
+
+    zfile_t **files = zdir_flatten (self);
+    uint index;
+    for (index = 0;; index++) {
+        zfile_t *file = files [index];
+        if (!file)
+            break;
+        puts (zfile_filename (file, NULL));
+    }
+    free (files);
+}
+
+
+//  --------------------------------------------------------------------------
+//  Remove directory, optionally including all files that it contains, at
+//  all levels. If force is false, will only remove the directory if empty.
+//  If force is true, will remove all files and all subdirectories.
+
+void
+zdir_remove (zdir_t *self, bool force)
+{
+    //  If forced, remove all subdirectories and files
+    if (force) {
+        zfile_t *file = (zfile_t *) zlist_pop (self->files);
+        while (file) {
+            zfile_remove (file);
+            zfile_destroy (&file);
+            file = (zfile_t *) zlist_pop (self->files);
+        }
+        zdir_t *subdir = (zdir_t *) zlist_pop (self->subdirs);
+        while (subdir) {
+            zdir_remove (subdir, force);
+            zdir_destroy (&subdir);
+            subdir = (zdir_t *) zlist_pop (self->subdirs);
+        }
+        self->cursize = 0;
+        self->count = 0;
+    }
+    //  Remove if empty
+    if (zlist_size (self->files) == 0
+    &&  zlist_size (self->subdirs) == 0)
+        zsys_dir_delete (self->path);
+}
+
+
+//  --------------------------------------------------------------------------
+//  Self test of this class
+int
+zdir_test (bool verbose)
+{
+    printf (" * zdir: ");
+
+    //  @selftest
+    zdir_t *older = zdir_new (".", NULL);
+    assert (older);
+    if (verbose) {
+        printf ("\n");
+        zdir_dump (older, 0);
+    }
+    zdir_destroy (&older);
+
+    zdir_t *nosuch = zdir_new ("does-not-exist", NULL);
+    assert (nosuch == NULL);
+    //  @end
+
+    printf ("OK\n");
+    return 0;
+}

data/ext/czmq/src/zfile.c

@@ -1,5 +1,5 @@
 /*  =========================================================================
-    zfile - helper functions for working with files.
+    zfile - provides methods to work with files in a portable fashion.
 
     -------------------------------------------------------------------------
     Copyright (c) 1991-2013 iMatix Corporation <www.imatix.com>
@@ -25,196 +25,430 @@
 
 /*
 @header
-    The zfile class provides methods to work with files and directories.
+    The zfile class provides methods to work with disk files. A file object
+    provides the modified date, current size, and type of the file. You can
+    create a file object for a filename that does not yet exist. To read or
+    write data from the file, use the input and output methods, and then
+    read and write chunks. The output method lets you both read and write
+    chunks, at any offset. Finally, this class provides portable symbolic
+    links. If a filename ends in ".ln", the first line of text in the file
+    is read, and used as the underlying file for read/write operations.
+    This lets you manipulate (e.g.) copy symbolic links without copying
+    the perhaps very large files they point to.
 @discuss
+    This class is a new API, deprecating the old zfile class (which still
+    exists but is implemented in zsys now).
 @end
 */
 
 #include "../include/czmq.h"
 
+//  Structure of our class
+
+struct _zfile_t {
+    //  Properties for all file objects
+    char *fullname;         //  File name with path
+    char *link;             //  Optional linked file
+    bool exists;            //  true if file exists
+    bool stable;            //  true if file is stable
+    bool eof;               //  true if at end of file
+    FILE *handle;           //  Read/write handle
+
+    //  Properties from files that exist on file system
+    time_t modified;        //  Modification time
+    off_t  cursize;         //  Size of the file
+    mode_t mode;            //  POSIX permission bits
+};
+
 
 //  --------------------------------------------------------------------------
-//  Return true if file exists, else zero
+//  Constructor
+//  If file exists, populates properties. CZMQ supports portable symbolic
+//  links, which are files with the extension ".ln". A symbolic link is a
+//  text file containing one line, the filename of a target file. Reading
+//  data from the symbolic link actually reads from the target file.
+
+zfile_t *
+zfile_new (const char *path, const char *name)
+{
+    zfile_t *self = (zfile_t *) zmalloc (sizeof (zfile_t));
+
+    //  Format full path to file
+    self->fullname = (char *) zmalloc (strlen (path) + strlen (name) + 2);
+    sprintf (self->fullname, "%s/%s", path, name);
+
+    //  Resolve symbolic link if possible
+    if (strlen (self->fullname) > 3
+    &&  streq (self->fullname + strlen (self->fullname) - 3, ".ln")) {
+        FILE *handle = fopen (self->fullname, "r");
+        if (handle) {
+            char buffer [256];
+            if (fgets (buffer, 256, handle)) {
+                //  We have the contents of the symbolic link
+                if (buffer [strlen (buffer) - 1] == '\n')
+                    buffer [strlen (buffer) - 1] = 0;
+                self->link = strdup (buffer);
+                //  Chop ".ln" off name for external use
+                self->fullname [strlen (self->fullname) - 3] = 0;
+            }
+            fclose (handle);
+        }
+    }
+    zfile_restat (self);
+    return self;
+}
 
-bool
-zfile_exists (const char *filename)
+//  --------------------------------------------------------------------------
+//  Destroy a file item
+
+void
+zfile_destroy (zfile_t **self_p)
 {
-    assert (filename);
-    return zfile_mode (filename) != (mode_t)-1;
+    assert (self_p);
+    if (*self_p) {
+        zfile_t *self = *self_p;
+        if (self->handle)
+            fclose (self->handle);
+        free (self->fullname);
+        free (self->link);
+        free (self);
+        *self_p = NULL;
+    }
 }
 
 
 //  --------------------------------------------------------------------------
-//  Return size of file, or -1 if not found
+//  Duplicate a file item
 
-ssize_t
-zfile_size (const char *filename)
+zfile_t *
+zfile_dup (zfile_t *self)
 {
-    struct stat
-        stat_buf;
-
-    assert (filename);
-    if (stat ((char *) filename, &stat_buf) == 0)
-        return stat_buf.st_size;
-    else
-        return -1;
+    zfile_t
+        *copy;
+
+    copy = (zfile_t *) zmalloc (sizeof (zfile_t));
+    copy->fullname = strdup (self->fullname);
+    copy->modified = self->modified;
+    copy->cursize = self->cursize;
+    copy->link = self->link? strdup (self->link): NULL;
+    copy->mode = self->mode;
+    return copy;
 }
 
 
 //  --------------------------------------------------------------------------
-//  Return file mode
+//  Return file name, remove path if provided
 
-mode_t
-zfile_mode (const char *filename)
+char *
+zfile_filename (zfile_t *self, char *path)
 {
-#if (defined (__WINDOWS__))
-    DWORD dwfa = GetFileAttributes (filename);
-    if (dwfa == 0xffffffff)
-        return -1;
+    assert (self);
+    char *name = self->fullname;
+    if (path
+    &&  strlen (self->fullname) >= strlen (path)
+    &&  memcmp (self->fullname, path, strlen (path)) == 0) {
+        name += strlen (path);
+        if (*name == '/')
+            name++;
+    }
+    return name;
+}
 
-    dbyte mode = 0;
-    if (dwfa & FILE_ATTRIBUTE_DIRECTORY)
-        mode |= S_IFDIR;
-    else
-        mode |= S_IFREG;
-    if (!(dwfa & FILE_ATTRIBUTE_HIDDEN))
-        mode |= S_IREAD;
-    if (!(dwfa & FILE_ATTRIBUTE_READONLY))
-        mode |= S_IWRITE;
-
-    return mode;
-#else
+
+//  --------------------------------------------------------------------------
+//  Refresh file properties from disk; this is not done automatically
+//  on access methods, otherwise it is not possible to compare directory
+//  snapshots.
+
+void
+zfile_restat (zfile_t *self)
+{
+    assert (self);
     struct stat stat_buf;
-    if (stat ((char *) filename, &stat_buf) == 0)
-        return stat_buf.st_mode;
-    else
-        return -1;
-#endif
+    char *real_name = self->link? self->link: self->fullname;
+    if (stat (real_name, &stat_buf) == 0) {
+        self->cursize = stat_buf.st_size;
+        self->modified = stat_buf.st_mtime;
+        self->mode = zsys_file_mode (real_name);
+        self->stable = zsys_file_stable (real_name);
+    }
+    else {
+        self->cursize = 0;
+        self->modified = 0;
+        self->mode = 0;
+        self->stable = false;
+    }
 }
 
 
 //  --------------------------------------------------------------------------
-//  Delete file, return 0 if OK, -1 if not possible.
+//  Return when the file was last modified. If you want this to reflect the
+//  current situation, call zfile_restat before checking this property.
 
-int
-zfile_delete (const char *filename)
+time_t
+zfile_modified (zfile_t *self)
 {
-    assert (filename);
-#if (defined (__WINDOWS__))
-    return DeleteFile (filename) ? 0: -1;
-#else
-    return unlink (filename);
-#endif
+    assert (self);
+    return self->modified;
 }
 
 
 //  --------------------------------------------------------------------------
-//  Check if file is 'stable'
+//  Return the last-known size of the file. If you want this to reflect the
+//  current situation, call zfile_restat before checking this property.
+
+off_t
+zfile_cursize (zfile_t *self)
+{
+    assert (self);
+    return self->cursize;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return true if the file is a directory. If you want this to reflect
+//  any external changes, call zfile_restat before checking this property.
 
 bool
-zfile_stable (const char *filename)
+zfile_is_directory (zfile_t *self)
 {
-    struct stat stat_buf;
-    if (stat (filename, &stat_buf) == 0) {
-        //  File is 'stable' if more than 1 second old
-#if (defined (WIN32))
-#   define EPOCH_DIFFERENCE 11644473600LL
-        long age = (long) (zclock_time () - EPOCH_DIFFERENCE * 1000 - (stat_buf.st_mtime * 1000));
-#else
-        long age = (long) (zclock_time () - (stat_buf.st_mtime * 1000));
-#endif
-        return (age > 1000);
-    }
-    else
-        return false;           //  File doesn't exist, so not stable
+    assert (self);
+    return (self->mode & S_IFDIR) != 0;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return true if the file is a regular file. If you want this to reflect
+//  any external changes, call zfile_restat before checking this property.
+
+bool
+zfile_is_regular (zfile_t *self)
+{
+    assert (self);
+    return (self->mode & S_IFREG) != 0;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return true if the file is readable by this process. If you want this to
+//  reflect any external changes, call zfile_restat before checking this
+//  property.
+
+bool
+zfile_is_readable (zfile_t *self)
+{
+    assert (self);
+    return (self->mode & S_IREAD) != 0;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return true if the file is writeable by this process. If you want this
+//  to reflect any external changes, call zfile_restat before checking this
+//  property.
+
+bool
+zfile_is_writeable (zfile_t *self)
+{
+    assert (self);
+    return (self->mode & S_IWRITE) != 0;
 }
 
 
 //  --------------------------------------------------------------------------
-//  Create a file path if it doesn't exist
+//  Check if file has stopped changing and can be safely processed.
+//  If you want this to reflect the current situation, call zfile_restat
+//  before checking this property.
+
+bool
+zfile_is_stable (zfile_t *self)
+{
+    assert (self);
+    return self->stable;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Remove the file
+
+void
+zfile_remove (zfile_t *self)
+{
+    assert (self);
+    //  Restore ".ln" in file name if this was a symbolic link
+    if (self->link)
+        self->fullname [strlen (self->fullname)] = '.';
+    zfile_close (self);
+    zsys_file_delete (self->fullname);
+}
+
+
+//  --------------------------------------------------------------------------
+//  Open file for reading
+//  Returns 0 if OK, -1 if not found or not accessible
 
 int
-zfile_mkdir (const char *pathname)
-{
-    //  Take copy of string as we're going to mess with it
-    char *my_pathname = strdup (pathname);
-
-    //  Create parent directory levels if needed
-    char *slash = strchr (my_pathname + 1, '/');
-    do {
-        if (slash)
-            *slash = 0;         //  Cut at slash
-        mode_t mode = zfile_mode (my_pathname);
-        if (mode == (mode_t)-1) {
-            //  Does not exist, try to create it
-#if (defined (__WINDOWS__))
-            if (!CreateDirectory (my_pathname, NULL))
-#else
-            if (mkdir (my_pathname, 0775))
-#endif
-                return -1;      //  Failed
-        }
+zfile_input (zfile_t *self)
+{
+    assert (self);
+    if (self->handle)
+        zfile_close (self);
+
+    char *real_name = self->link? self->link: self->fullname;
+    self->handle = fopen (real_name, "rb");
+    if (self->handle) {
+        struct stat stat_buf;
+        if (stat (real_name, &stat_buf) == 0)
+            self->cursize = stat_buf.st_size;
         else
-        if ((mode & S_IFDIR) == 0) {
-            //  Not a directory, abort
-        }
-        if (!slash)             //  End if last segment
-            break;
-       *slash = '/';
-        slash = strchr (slash + 1, '/');
-    } while (slash);
-
-    free (my_pathname);
-    return 0;
+            self->cursize = 0;
+    }
+    return self->handle? 0: -1;
 }
 
 
 //  --------------------------------------------------------------------------
-//  Remove a file path if empty
+//  Open file for writing, creating directory if needed
+//  File is created if necessary; chunks can be written to file at any
+//  location. Returns 0 if OK, -1 if error.
 
 int
-zfile_rmdir (const char *pathname)
+zfile_output (zfile_t *self)
 {
-#if (defined (__WINDOWS__))
-    return RemoveDirectory (pathname)? 0: -1;
-#else
-    return rmdir (pathname);
-#endif
+    assert (self);
+    
+    //  Wipe symbolic link if that's what the file was
+    if (self->link) {
+        free (self->link);
+        self->link = NULL;
+    }
+    //  Create file path if it doesn't exist
+    char *file_path = strdup (self->fullname);
+    char *last_slash = strrchr (file_path, '/');
+    if (last_slash)
+        *last_slash = 0;
+    if (zsys_dir_create (file_path))
+        return -1;
+    free (file_path);
+
+    //  Create file if it doesn't exist
+    if (self->handle)
+        zfile_close (self);
+    self->handle = fopen (self->fullname, "r+b"); 
+    if (!self->handle) {
+        self->handle = fopen (self->fullname, "w+b");
+        if (!self->handle)
+            self->handle = fopen (self->fullname, "w+b");
+    }
+    return self->handle? 0: -1;
 }
 
 
 //  --------------------------------------------------------------------------
-//  Set private file creation mode; all files created from here will be
-//  readable/writable by the owner only.
+//  Read chunk from file at specified position. If this was the last chunk,
+//  sets self->eof. Returns a null chunk in case of error.
 
-static mode_t s_old_mask = 0;
+zchunk_t *
+zfile_read (zfile_t *self, size_t bytes, off_t offset)
+{
+    assert (self);
+    assert (self->handle);
+    //  Calculate real number of bytes to read
+    if (offset > self->cursize)
+        bytes = 0;
+    else
+    if (bytes > (size_t) (self->cursize - offset))
+        bytes = (size_t) (self->cursize - offset);
+
+    int rc = fseek (self->handle, (long) offset, SEEK_SET);
+    if (rc == -1)
+        return NULL;
+
+    self->eof = false;
+    zchunk_t *chunk = zchunk_read (self->handle, bytes);
+    if (chunk)
+        self->eof = zchunk_size (chunk) < bytes;
+    return chunk;
+}
 
-void
-zfile_mode_private (void)
+
+//  --------------------------------------------------------------------------
+//  Write chunk to file at specified position
+//  Return 0 if OK, else -1
+
+int
+zfile_write (zfile_t *self, zchunk_t *chunk, off_t offset)
 {
-#   if !defined(__WINDOWS__)
-    s_old_mask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
-#   endif
+    assert (self);
+    assert (self->handle);
+    int rc = fseek (self->handle, (long) offset, SEEK_SET);
+    if (rc >= 0)
+        rc = zchunk_write (chunk, self->handle);
+    return rc;
 }
 
 
 //  --------------------------------------------------------------------------
-//  Reset default file creation mode; all files created from here will use
-//  process file mode defaults.
+//  Close file, if open
 
 void
-zfile_mode_default (void)
+zfile_close (zfile_t *self)
+{
+    assert (self);
+    if (self->handle) {
+        fclose (self->handle);
+        zfile_restat (self);
+    }
+    self->handle = 0;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Return file handle, if opened
+
+FILE *
+zfile_handle (zfile_t *self)
 {
-    //  Reset process file create mask
-#   if !defined(__WINDOWS__)
-    if (s_old_mask)
-        umask (s_old_mask);
-#   endif
+    assert (self);
+    return self->handle;
+}
+
+//  Deprecated API, moved to zsys class. The zfile class works with
+//  an object instance, which is more consistent with the CLASS style
+//  and lets us do more interesting things. These functions were
+//  essentially about portability, so now sit in zsys.
+
+bool zfile_exists (const char *filename) {
+ return zsys_file_exists (filename);
+}
+ssize_t zfile_size (const char *filename) {
+    return zsys_file_size (filename);
+}
+mode_t zfile_mode (const char *filename) {
+    return zsys_file_mode (filename);
+}
+int zfile_delete (const char *filename) {
+    return zsys_file_delete (filename);
+}
+bool zfile_stable (const char *filename) {
+    return zsys_file_stable (filename);
+}
+int zfile_mkdir (const char *pathname) {
+    return zsys_dir_create (pathname);
+}
+int zfile_rmdir (const char *pathname) {
+    return zsys_dir_delete (pathname);
+}
+void zfile_mode_private (void) {
+    zsys_file_mode_private ();
+}
+void zfile_mode_default (void) {
+    zsys_file_mode_default ();
 }
 
 
 //  --------------------------------------------------------------------------
-//  Selftest
+//  Self test of this class
 
 int
 zfile_test (bool verbose)
@@ -222,16 +456,73 @@ zfile_test (bool verbose)
     printf (" * zfile: ");
 
     //  @selftest
-    int rc = zfile_delete ("nosuchfile");
-    assert (rc == -1);
-
-    bool rc_bool = zfile_exists ("nosuchfile");
-    assert (rc_bool != true);
-
-    rc = (int) zfile_size ("nosuchfile");
+    zfile_t *file = zfile_new (".", "bilbo");
+    assert (streq (zfile_filename (file, "."), "bilbo"));
+    assert (zfile_is_readable (file) == false);
+    zfile_destroy (&file);
+
+    //  Create a test file in some random subdirectory
+    file = zfile_new ("./this/is/a/test", "bilbo");
+    int rc = zfile_output (file);
+    assert (rc == 0);
+    zchunk_t *chunk = zchunk_new (NULL, 100);
+    zchunk_fill (chunk, 0, 100);
+    //  Write 100 bytes at position 1,000,000 in the file
+    rc = zfile_write (file, chunk, 1000000);
+    assert (rc == 0);
+    zchunk_destroy (&chunk);
+    zfile_close (file);
+    assert (zfile_is_readable (file));
+    assert (zfile_cursize (file) == 1000100);
+    zfile_restat (file);
+    assert (!zfile_is_stable (file));
+    zclock_sleep (1001);
+    assert (!zfile_is_stable (file));
+    zfile_restat (file);
+    assert (zfile_is_stable (file));
+
+    //  Check we can read from file
+    rc = zfile_input (file);
+    assert (rc == 0);
+    chunk = zfile_read (file, 1000100, 0);
+    assert (chunk);
+    assert (zchunk_size (chunk) == 1000100);
+    zchunk_destroy (&chunk);
+    zfile_close (file);
+
+    //  Try some fun with symbolic links
+    zfile_t *link = zfile_new ("./this/is/a/test", "bilbo.ln");
+    rc = zfile_output (link);
+    assert (rc == 0);
+    fprintf (zfile_handle (link), "./this/is/a/test/bilbo\n");
+    zfile_destroy (&link);
+
+    link = zfile_new ("./this/is/a/test", "bilbo.ln");
+    rc = zfile_input (link);
+    assert (rc == 0);
+    chunk = zfile_read (link, 1000100, 0);
+    assert (chunk);
+    assert (zchunk_size (chunk) == 1000100);
+    zchunk_destroy (&chunk);
+    zfile_destroy (&link);
+
+    //  Remove file and directory
+    zdir_t *dir = zdir_new ("./this", NULL);
+    assert (zdir_cursize (dir) == 2000200);
+    zdir_remove (dir, true);
+    assert (zdir_cursize (dir) == 0);
+    zdir_destroy (&dir);
+
+    //  Check we can no longer read from file
+    assert (zfile_is_readable (file));
+    zfile_restat (file);
+    assert (!zfile_is_readable (file));
+    rc = zfile_input (file);
     assert (rc == -1);
-
+    zfile_destroy (&file);
     //  @end
+
     printf ("OK\n");
     return 0;
 }
+