ferret 0.9.1 → 0.9.2

data/ext/frtio.h

@@ -0,0 +1,13 @@
+#ifndef FRT_IO_H
+#define FRT_IO_H
+
+extern char *join_path(char *buf, const char *base, const char *filename);
+extern bool exists(char *path);
+extern int fcount(char *path);
+extern void dir_each(char *path, void (*func)(char *fname, void *arg), void *arg);
+extern void fs_clear_locks(Store *store);
+extern void fs_clear(Store *store);
+extern void fs_clear_all(Store *store);
+
+#endif
+

data/ext/fs_store.c

@@ -1,28 +1,36 @@
+#include "store.h"
+#include "frtio.h"
+#ifdef WIN32
+# ifndef S_IRUSR
+#  define S_IRUSR _S_IREAD
+# endif
+# ifndef S_IWUSR
+# define S_IWUSR _S_IWRITE
+# endif
+# include <io.h>
+#else
+#include <unistd.h>
+# define _close close
+# define _open open
+# define _creat creat
+# define _lseek lseek
+# define _read read
+# define _stat stat
+# define _fstat fstat
+#endif
 #include <sys/types.h>
-#include <sys/dir.h>
-#include <sys/stat.h>
-#include <dirent.h>
 #include <fcntl.h>
-#include <unistd.h>
-
+#include <sys/stat.h>
 #include <errno.h>
 #include <string.h>
 #include <stdio.h>
-#include "store.h"
+
 
 static char * const FILE_OPEN_ERROR_MSG = "Couldn't open the file to read";
 static char * const SEEK_ERROR_MSG = "Seek error message";
 static char * const WRITE_ERROR_MSG = "Write error message";
 
-/**
- * Create a filepath for a file in the store using the operating systems
- * default file seperator.
- */
-static char *join_path(char *buf, const char *base, const char *filename)
-{
-  sprintf(buf, "%s/%s", base, filename);
-  return buf;
-}
+extern void store_destroy(Store *store);
 
 /**
  * Create the file +filename+ in the +store+.
@@ -31,13 +39,15 @@ static char *join_path(char *buf, const char *base, const char *filename)
  * @param filename the name of the file to create
  * @throws IO_ERROR if the file cannot be created
  */
-void fs_touch(Store *store, char *filename)
+static void fs_touch(Store *store, char *filename)
 {
-  char buf[MAX_PATH];
-  int fd = creat(join_path(buf, store->dir.path, filename), S_IRUSR|S_IWUSR);
-  if (fd == -1)
+  int f;
+  char path[MAX_FILE_PATH];
+  join_path(path, store->dir.path, filename);
+  if ((f = _creat(path, S_IRUSR|S_IWUSR)) == 0) {
     RAISE(IO_ERROR, strerror(errno));
-  close(fd);
+  }
+  _close(f);
 }
 
 /**
@@ -50,15 +60,8 @@ void fs_touch(Store *store, char *filename)
  */
 int fs_exists(Store *store, char *filename)
 {
-  char buf[MAX_PATH];
-  int fd = open(join_path(buf, store->dir.path, filename), 0);
-  if (fd < 0) {
-    if (errno != ENOENT)
-      RAISE(IO_ERROR, strerror(errno));
-    return false;
-  }
-  close(fd);
-  return true;
+  char buf[MAX_FILE_PATH];
+  return exists(join_path(buf, store->dir.path, filename));
 }
 
 /**
@@ -71,7 +74,7 @@ int fs_exists(Store *store, char *filename)
  */
 int fs_remove(Store *store, char *filename)
 {
-  char buf[MAX_PATH];
+  char buf[MAX_FILE_PATH];
   return remove(join_path(buf, store->dir.path, filename));
 }
 
@@ -86,10 +89,17 @@ int fs_remove(Store *store, char *filename)
  */
 int fs_rename(Store *store, char *from, char *to)
 {
-  char buf1[MAX_PATH], buf2[MAX_PATH];
+  char buf1[MAX_FILE_PATH], buf2[MAX_FILE_PATH];
+
+#ifdef WIN32
+  remove(join_path(buf1, store->dir.path, to));
+#endif
 
-  return rename(join_path(buf1, store->dir.path, from),
-      join_path(buf2, store->dir.path, to));
+  if (rename(join_path(buf1, store->dir.path, from),
+    join_path(buf2, store->dir.path, to)) < 0) {
+    RAISE(IO_ERROR, strerror(errno));
+  }
+  return true;
 }
 
 /**
@@ -101,20 +111,7 @@ int fs_rename(Store *store, char *from, char *to)
  */
 int fs_count(Store *store)
 {
-  int cnt = 0;
-  struct dirent *de;
-  DIR *d = opendir(store->dir.path);
-
-  if (!d) RAISE(IO_ERROR, strerror(errno));
-
-  while ((de = readdir(d)) != NULL) {
-    if (de->d_name[0] != '.') {
-      cnt++;
-    }
-  }
-  closedir(d);
-
-  return cnt;
+  return fcount(store->dir.path);
 }
 
 /**
@@ -130,39 +127,7 @@ int fs_count(Store *store)
  */
 void fs_each(Store *store, void (*func)(char *fname, void *arg), void *arg)
 {
-  struct dirent *de;
-  DIR *d = opendir(store->dir.path);
-
-  if (!d) RAISE(IO_ERROR, strerror(errno));
-
-  while ((de = readdir(d)) != NULL) {
-    if ((strncmp(de->d_name, LOCK_PREFIX, strlen(LOCK_PREFIX)) == 0) ||
-        (de->d_name[0] == '.'))
-      continue;
-    func(de->d_name, arg);
-  }
-  closedir(d);
-}
-
-/**
- * Clear all the locks in the store.
- *
- * @param store the store to clear the locks from
- * @throws IO_ERROR if there is an error opening the directory
- */
-void fs_clear_locks(Store *store)
-{
-  struct dirent *de;
-  DIR *d = opendir(store->dir.path);
-
-  if (!d) RAISE(IO_ERROR, strerror(errno));
-
-  while ((de = readdir(d)) != NULL) {
-    if (file_is_lock(de->d_name)) {
-      fs_remove(store, de->d_name);
-    }
-  }
-  closedir(d);
+  dir_each(store->dir.path, func, arg);
 }
 
 /**
@@ -171,54 +136,13 @@ void fs_clear_locks(Store *store)
  * @param p the store to destroy
  * @throws IO_ERROR if there is an error deleting the locks
  */
-void fs_destroy(void *p)
+void fs_destroy(Store *store)
 {
-  Store *store = (Store *)p;
   fs_clear_locks(store);
   free(store->dir.path);
   store_destroy(store);
 }
 
-/**
- * Clear all files from the store except the lock files.
- *
- * @param store the store to clear all the files from
- * @throws IO_ERROR if there is an error deleting the files
- */
-void fs_clear(Store *store)
-{
-  struct dirent *de;
-  DIR *d = opendir(store->dir.path);
-
-  if (!d) RAISE(IO_ERROR, strerror(errno));
-
-  while ((de = readdir(d)) != NULL) {
-    if (de->d_name[0] != '.' && !file_is_lock(de->d_name)) {
-      fs_remove(store, de->d_name);
-    }
-  }
-  closedir(d);
-}
-
-/**
- * Clear all files from the store including the lock files.
- *
- * @param store the store to clear all the files from
- * @throws IO_ERROR if there is an error deleting the files
- */
-void fs_clear_all(Store *store)
-{
-  struct dirent *de;
-  DIR *d = opendir(store->dir.path);
-
-  while ((de = readdir(d)) != NULL) {
-    if (de->d_name[0] != '.') {
-      fs_remove(store, de->d_name);
-    }
-  }
-  closedir(d);
-}
-
 /**
  * Return the length of the file +filename+ in +store+
  *
@@ -229,7 +153,7 @@ void fs_clear_all(Store *store)
  */
 int fs_length(Store *store, char *filename)
 {
-  char buf[MAX_PATH];
+  char buf[MAX_FILE_PATH];
   struct stat stt;
 
   if (stat(join_path(buf, store->dir.path, filename), &stt))
@@ -288,11 +212,12 @@ void fso_close_internal(OutStream *os)
  */
 OutStream *fs_create_output(Store *store, const char *filename)
 {
-  char buf[MAX_PATH];
+  char buf[MAX_FILE_PATH];
   FILE *f = fopen(join_path(buf, store->dir.path, filename), "wb");
+  OutStream *os;
   if (!f) RAISE(IO_ERROR, strerror(errno));
 
-  OutStream *os = os_create();
+  os = os_create();
   os->file = f;
   os->flush_internal = &fso_flush_internal;
   os->seek_internal  = &fso_seek_internal;
@@ -315,11 +240,14 @@ void fsi_read_internal(InStream *is, uchar *b, int offset, int len)
 {
   int fd = (int)is->file;
   int pos = is_pos(is);
-  if (pos != lseek(fd, 0, SEEK_CUR)) {
-    lseek(fd, pos, SEEK_SET);
+  if (pos != _lseek(fd, 0, SEEK_CUR)) {
+    _lseek(fd, pos, SEEK_SET);
   }
-  if (read(fd, b, len) != len) {
-    RAISE(EOF_ERROR, strerror(errno));
+  if (_read(fd, b, len) != len) {
+    /* win: the wrong value can be returned for some reason so double check */
+    if (_lseek(fd, 0, SEEK_CUR) != (pos + len)) {
+      RAISE(EOF_ERROR, strerror(errno));
+    }
   }
 }
 
@@ -332,8 +260,9 @@ void fsi_read_internal(InStream *is, uchar *b, int offset, int len)
  */
 void fsi_seek_internal(InStream *is, int pos)
 {
-  if (lseek((int)is->file, pos, SEEK_SET) < 0)
+  if (_lseek((int)is->file, pos, SEEK_SET) < 0) {
     RAISE(IO_ERROR, strerror(errno));
+  }
 }
 
 /**
@@ -345,18 +274,13 @@ void fsi_seek_internal(InStream *is, int pos)
 void fsi_close_internal(InStream *is)
 {
   if (!is->is_clone) {
-    if (close((int)is->file))
+    if (_close((int)is->file)) {
       RAISE(IO_ERROR, strerror(errno));
+    }
     free(is->d.path);
   }
 }
 
-/**
- * Clone the input stream. Nothing to do for a file system input stream
- */
-void fsi_clone_internal(InStream *is, InStream *new_is)
-{ }
-
 /**
  * Returns the length of the input stream +is+
  *
@@ -365,12 +289,19 @@ void fsi_clone_internal(InStream *is, InStream *new_is)
  */
 int fsi_length(InStream *is)
 {
-  struct stat stt;
-  if (fstat((int)is->file, &stt))
+  struct _stat stt;
+  if (_fstat((int)is->file, &stt)) {
     RAISE(IO_ERROR, strerror(errno));
+  }
   return stt.st_size;
 }
 
+/**
+ * Clone the input stream. Nothing to do for a file system input stream
+ */
+void fsi_clone_internal(InStream *is, InStream *new_is)
+{ }
+
 /**
  * Open an input stream in the +store+ with the name +filename+
  *
@@ -380,11 +311,14 @@ int fsi_length(InStream *is)
  */
 InStream *fs_open_input(Store *store, const char *filename)
 {
-  char buf[MAX_PATH];
-  int fd = open(join_path(buf, store->dir.path, filename), O_RDONLY);
-  if (fd < 0) RAISE(IO_ERROR, FILE_OPEN_ERROR_MSG);
-
-  InStream *is = is_create();
+  InStream *is;
+  char buf[MAX_FILE_PATH];
+  int fd = _open(join_path(buf, store->dir.path, filename), O_RDONLY);
+  if (fd < 0) {
+    RAISE(IO_ERROR, FILE_OPEN_ERROR_MSG);
+  }
+  
+  is = is_create();
   is->file = (void *)fd;
   is->d.path = estrdup(buf);
   is->is_clone = false;
@@ -407,11 +341,12 @@ int fs_lock_obtain(Lock *lock)
 {
   int f;
   int trys = LOCK_OBTAIN_TIMEOUT;
-  while (((f = open(lock->name, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR)) < 0) &&
-        (trys > 0))
+  while (((f = _open(lock->name, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR)) < 0) &&
+    (trys > 0)) {
     trys--;
+  }
   if (f >= 0) {
-    close(f);
+    _close(f);
     return true;
   } else {
     return false;
@@ -426,10 +361,11 @@ int fs_lock_obtain(Lock *lock)
  */
 int fs_lock_is_locked(Lock *lock)
 {
-  int f = open(lock->name, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR);
+  int f = _open(lock->name, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR);
   if (f >= 0) {
-    if (close(f) || remove(lock->name))
+    if (_close(f) || remove(lock->name)) {
       RAISE(IO_ERROR, strerror(errno));
+    }
     return false;
   } else {
     return true;
@@ -445,7 +381,7 @@ Lock *fs_open_lock(Store *store, char *lockname)
 {
   Lock *lock = ALLOC(Lock);
   char lname[100];
-  char buf[MAX_PATH];
+  char buf[MAX_FILE_PATH];
   sprintf(lname, "%s%s.lck", LOCK_PREFIX, lockname);
   lock->name = estrdup(join_path(buf, store->dir.path, lname));
   lock->obtain = &fs_lock_obtain;
@@ -461,6 +397,20 @@ void fs_close_lock(Lock *lock)
   free(lock);
 }
 
+#ifdef WIN32
+static HshTable stores = {
+  /* fill */0,
+  /* used */0,
+  /* mask */Hsh_MINSIZE - 1,
+  /* table */stores.smalltable,
+  /* smalltable */{0},
+  /* lookup */&h_lookup_str,
+  /* hash */NULL,
+  /* eq */NULL,
+  /* free_key */(free_ft)&dummy_free,
+  /* free_value */(free_ft)&fs_destroy
+};
+#else
 static HshTable stores = {
   fill:0,
   used:0,
@@ -469,38 +419,33 @@ static HshTable stores = {
   lookup:&h_lookup_str,
   hash:NULL,
   eq:NULL,
-  free_key:dummy_free,
-  free_value:&fs_destroy
+  free_key:(free_ft)&dummy_free,
+  free_value:(free_ft)&fs_destroy
 };
+#endif
 
 #ifndef FERRET_EXT
 static mutex_t stores_mutex = MUTEX_INITIALIZER;
 #endif
 
-void fs_close(Store *store)
+void fs_close_i(Store *store)
 {
-  mutex_lock(&store->mutex);
-  if (--(store->ref_cnt) == 0) {
-    mutex_lock(&stores_mutex);
-    h_del(&stores, store->dir.path);
-    mutex_unlock(&stores_mutex);
-  } else {
-    mutex_unlock(&store->mutex);
-  }
+  mutex_lock(&stores_mutex);
+  h_del(&stores, store->dir.path);
+  mutex_unlock(&stores_mutex);
 }
 
 Store *fs_store_create(const char *pathname)
 {
   Store *new_store = store_create();
-
-  new_store->ref_cnt       = 0;
+  
   new_store->dir.path      = estrdup(pathname);
   new_store->touch         = &fs_touch;
   new_store->exists        = &fs_exists;
   new_store->remove        = &fs_remove;
   new_store->rename        = &fs_rename;
   new_store->count         = &fs_count;
-  new_store->close         = &fs_close;
+  new_store->close_i       = &fs_close_i;
   new_store->clear         = &fs_clear;
   new_store->clear_all     = &fs_clear_all;
   new_store->clear_locks   = &fs_clear_locks;
@@ -519,15 +464,15 @@ Store *open_fs_store(const char *pathname)
   
   mutex_lock(&stores_mutex);
   store = h_get(&stores, pathname);
-  if (!store) {
+  if (store) {
+    mutex_lock(&store->mutex);
+    store->ref_cnt++;
+    mutex_unlock(&store->mutex);
+  } else {
     store = fs_store_create(pathname);
-    h_set(&stores, pathname, store);
+    h_set(&stores, store->dir.path, store);
   }
   mutex_unlock(&stores_mutex);
 
-  mutex_lock(&store->mutex);
-  store->ref_cnt++;
-  mutex_unlock(&store->mutex);
-
   return store;
 }