rfuse-ng 0.2.0 → 0.3.0

data/ext/rfuse.c

@@ -19,9 +19,11 @@
 #include "context.h"
 #include "file_info.h"
 
-static VALUE fuse_object; //this is a global variable where we store the fuse object
+//this is a global variable where we store the fuse object
+static VALUE fuse_object;
 
-static int unsafe_return_error(VALUE *args){
+static int unsafe_return_error(VALUE *args)
+{
   VALUE info;
   info = rb_inspect(ruby_errinfo);
   rb_backtrace();
@@ -29,35 +31,43 @@ static int unsafe_return_error(VALUE *args){
   return rb_funcall(info,rb_intern("errno"),0);
 }
 
-static int return_error(int def_error){
+static int return_error(int def_error)
+{
   /*if the raised error has a method errno the return that value else
     return def(ault)_error */
   VALUE res;
   int error = 0;
   res=rb_protect((VALUE (*)())unsafe_return_error,Qnil,&error);
-  if (error) { //this exception has no errno method or something else 
-               //went wrong
+  if (error)
+  { //this exception has no errno method or something else 
+    //went wrong
     printf ("ERROR: Not an Errno::xxx error or exception in exception!\n");
     return def_error;
-  } else {
+  }
+  else
+  {
     return FIX2INT(res);
   }
 }
 
-static VALUE unsafe_readdir(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE filler = values[1];
-  VALUE offset = values[2];
-  VALUE ffi = values[3];
+//----------------------READDIR
+
+static VALUE unsafe_readdir(VALUE *args)
+{
+  VALUE path   = args[0];
+  VALUE filler = args[1];
+  VALUE offset = args[2];
+  VALUE ffi    = args[3];
+
   struct fuse_context *ctx = fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("readdir"),5,wrap_context(ctx),path,filler,
         offset,ffi);
 }
 
-  //call readdir with an Filler object
-static int rf_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
-         off_t offset,struct fuse_file_info *ffi)
+//call readdir with an Filler object
+static int rf_readdir(const char *path, void *buf,
+  fuse_fill_dir_t filler, off_t offset,struct fuse_file_info *ffi)
 {
   VALUE fuse_module;
   VALUE rfiller_class;
@@ -71,28 +81,38 @@ static int rf_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
   args[0]=rb_str_new2(path);
 
   fuse_module = rb_const_get(rb_cObject, rb_intern("RFuse"));
+
   rfiller_class=rb_const_get(fuse_module,rb_intern("Filler"));
   rfiller_instance=rb_funcall(rfiller_class,rb_intern("new"),0);
   Data_Get_Struct(rfiller_instance,struct filler_t,fillerc);
+
   fillerc->filler=filler;//Init the filler by hand.... TODO: cleaner
   fillerc->buffer=buf;
   args[1]=rfiller_instance;
   args[2]=INT2NUM(offset);
   args[3]=wrap_file_info(ffi);
+
   res=rb_protect((VALUE (*)())unsafe_readdir,(VALUE)args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------------------------------
 
-static VALUE unsafe_readlink(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE size = values[1];
+//----------------------READLINK
+
+static VALUE unsafe_readlink(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE size = args[1];
+
   struct fuse_context *ctx = fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("readlink"),3,wrap_context(ctx),path,size);
 }
 
@@ -105,96 +125,172 @@ static int rf_readlink(const char *path, char *buf, size_t size)
   args[1]=INT2NUM(size);
   char *rbuf;
   res=rb_protect((VALUE (*)())unsafe_readlink,(VALUE)args,&error);  
-  if (error) {
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     rbuf=STR2CSTR(res);
     strncpy(buf,rbuf,size);
     return 0;
   }
 }
-//----------------------------GETATTR
-static VALUE unsafe_getattr(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
+
+//----------------------GETDIR
+
+static VALUE unsafe_getdir(VALUE *args)
+{
+  VALUE path   = args[0];
+  VALUE filler = args[1];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall(
+    fuse_object,rb_intern("getdir"),3,
+    wrap_context(ctx),path,filler
+  );
+}
+
+//call getdir with an Filler object
+static int rf_getdir(const char *path, fuse_dirh_t dh, fuse_dirfil_t df)
+{
+  VALUE fuse_module;
+  VALUE rfiller_class;
+  VALUE rfiller_instance;
+  VALUE args[2];
+  VALUE res;
+  struct filler_t *fillerc;
+  int error = 0;
+
+  //create a filler object
+  args[0]=rb_str_new2(path);
+
+  fuse_module = rb_const_get(rb_cObject, rb_intern("RFuse"));
+
+  rfiller_class    = rb_const_get(fuse_module,rb_intern("Filler"));
+  rfiller_instance = rb_funcall(rfiller_class,rb_intern("new"),0);
+
+  Data_Get_Struct(rfiller_instance,struct filler_t,fillerc);
+
+  fillerc->df = df;
+  fillerc->dh = dh;
+
+  args[1]=rfiller_instance;
+
+  res = rb_protect((VALUE (*)())unsafe_getdir, (VALUE)args, &error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+//----------------------MKNOD
+
+static VALUE unsafe_mknod(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE mode = args[1];
+  VALUE dev  = args[2];
   struct fuse_context *ctx=fuse_get_context();
-  return rb_funcall(fuse_object,rb_intern("getattr"),2,wrap_context(ctx),path);
+  return rb_funcall(fuse_object,rb_intern("mknod"),4,wrap_context(ctx),path,mode,dev);
 }
 
 //calls getattr with path and expects something like FuseStat back
-static int rf_getattr(const char *path, struct stat *stbuf)
+static int rf_mknod(const char *path, mode_t mode,dev_t dev)
 {
-  VALUE args[1];
+  VALUE args[3];
   VALUE res;
   int error = 0;
   args[0]=rb_str_new2(path);
-  res=rb_protect((VALUE (*)())unsafe_getattr,(VALUE) args,&error);
-  if (error || (res == Qnil)) {
+  args[1]=INT2FIX(mode);
+  args[2]=INT2FIX(dev);
+  res=rb_protect((VALUE (*)())unsafe_mknod,(VALUE) args,&error);
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
-    rstat2stat(res,stbuf);
+  }
+  else
+  {
     return 0;
   }
 }
-//----------------------MKDIR
-static VALUE unsafe_mkdir(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE mode = values[1];
+
+//----------------------GETATTR
+
+static VALUE unsafe_getattr(VALUE *args)
+{
+  VALUE path = args[0];
+
   struct fuse_context *ctx=fuse_get_context();
-  return rb_funcall(fuse_object,rb_intern("mkdir"),3,wrap_context(ctx),path,mode);
+
+  return rb_funcall(fuse_object,rb_intern("getattr"),2,wrap_context(ctx),path);
 }
 
 //calls getattr with path and expects something like FuseStat back
-static int rf_mkdir(const char *path, mode_t mode)
+static int rf_getattr(const char *path, struct stat *stbuf)
 {
-  VALUE args[2];
+  VALUE args[1];
   VALUE res;
   int error = 0;
   args[0]=rb_str_new2(path);
-  args[1]=INT2FIX(mode);
-  res=rb_protect((VALUE (*)())unsafe_mkdir,(VALUE) args,&error);
-  if (error) {
+  res=rb_protect((VALUE (*)())unsafe_getattr,(VALUE) args,&error);
+
+  if (error || (res == Qnil))
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
+    rstat2stat(res,stbuf);
     return 0;
-  };
+  }
 }
-//----------------------
 
-//----------------------MKNOD
-static VALUE unsafe_mknod(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE mode = values[1];
-  VALUE dev = values[2];
+//----------------------MKDIR
+
+static VALUE unsafe_mkdir(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE mode = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
-  return rb_funcall(fuse_object,rb_intern("mknod"),4,wrap_context(ctx),path,mode,dev);
+
+  return rb_funcall(fuse_object,rb_intern("mkdir"),3,wrap_context(ctx),path,mode);
 }
 
 //calls getattr with path and expects something like FuseStat back
-static int rf_mknod(const char *path, mode_t mode,dev_t dev)
+static int rf_mkdir(const char *path, mode_t mode)
 {
-  VALUE args[3];
+  VALUE args[2];
   VALUE res;
   int error = 0;
   args[0]=rb_str_new2(path);
   args[1]=INT2FIX(mode);
-  args[2]=INT2FIX(dev);
-  res=rb_protect((VALUE (*)())unsafe_mknod,(VALUE) args,&error);
-  if (error) {
+  res=rb_protect((VALUE (*)())unsafe_mkdir,(VALUE) args,&error);
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------OPEN
-static VALUE unsafe_open(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE ffi =  values[1];
- struct fuse_context *ctx=fuse_get_context();
+
+static VALUE unsafe_open(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE ffi  =  args[1];
+  struct fuse_context *ctx=fuse_get_context();
   return rb_funcall(fuse_object,rb_intern("open"),3,wrap_context(ctx),path,ffi);
 }
 
@@ -207,19 +303,25 @@ static int rf_open(const char *path,struct fuse_file_info *ffi)
   args[0]=rb_str_new2(path);
   args[1]=wrap_file_info(ffi);
   res=rb_protect((VALUE (*)())unsafe_open,(VALUE) args,&error);
-  if (error) {
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------RELEASE
-static VALUE unsafe_release(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE ffi = values[1];
+
+static VALUE unsafe_release(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE ffi  = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("release"),3,wrap_context(ctx),path,ffi);
 }
 
@@ -231,19 +333,33 @@ static int rf_release(const char *path, struct fuse_file_info *ffi)
   args[0]=rb_str_new2(path);
   args[1]=wrap_file_info(ffi);
   res=rb_protect((VALUE (*)())unsafe_release,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
+}
+
+//----------------------FSYNC
+static int rf_fsync(const char *path, int datasync, struct fuse_file_info *ffi)
+{
+  //TODO
+  return 0;
 }
-//----------------------
+
 //----------------------FLUSH
-static VALUE unsafe_flush(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE ffi=values[1];
+
+static VALUE unsafe_flush(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE ffi  = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("flush"),3,wrap_context(ctx),path,ffi);
 }
 
@@ -255,19 +371,26 @@ static int rf_flush(const char *path,struct fuse_file_info *ffi)
   args[0]=rb_str_new2(path);
   args[1]=wrap_file_info(ffi);
   res=rb_protect((VALUE (*)())unsafe_flush,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------TRUNCATE
-static VALUE unsafe_truncate(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE offset = values[1];
+
+static VALUE unsafe_truncate(VALUE *args)
+{
+  VALUE path   = args[0];
+  VALUE offset = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("truncate"),3,wrap_context(ctx),path,offset);
 }
 
@@ -279,20 +402,27 @@ static int rf_truncate(const char *path,off_t offset)
   args[0]=rb_str_new2(path);
   args[1]=INT2FIX(offset);
   res=rb_protect((VALUE (*)())unsafe_truncate,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------UTIME
-static VALUE unsafe_utime(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE actime = values[1];
-  VALUE modtime = values[2];
+
+static VALUE unsafe_utime(VALUE *args)
+{
+  VALUE path    = args[0];
+  VALUE actime  = args[1];
+  VALUE modtime = args[2];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("utime"),4,wrap_context(ctx),path,actime,modtime);
 }
 
@@ -305,20 +435,27 @@ static int rf_utime(const char *path,struct utimbuf *utim)
   args[1]=INT2NUM(utim->actime);
   args[2]=INT2NUM(utim->modtime);
   res=rb_protect((VALUE (*)())unsafe_utime,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------CHOWN
-static VALUE unsafe_chown(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE uid = values[1];
-  VALUE gid = values[2];
+
+static VALUE unsafe_chown(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE uid  = args[1];
+  VALUE gid  = args[2];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("chown"),4,wrap_context(ctx),path,uid,gid);
 }
 
@@ -331,19 +468,26 @@ static int rf_chown(const char *path,uid_t uid,gid_t gid)
   args[1]=INT2FIX(uid);
   args[2]=INT2FIX(gid);
   res=rb_protect((VALUE (*)())unsafe_chown,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------CHMOD
-static VALUE unsafe_chmod(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE mode = values[1];
+
+static VALUE unsafe_chmod(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE mode = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("chmod"),3,wrap_context(ctx),path,mode);
 }
 
@@ -355,18 +499,25 @@ static int rf_chmod(const char *path,mode_t mode)
   args[0]=rb_str_new2(path);
   args[1]=INT2FIX(mode);
   res=rb_protect((VALUE (*)())unsafe_chmod,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------UNLINK
-static VALUE unsafe_unlink(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
+
+static VALUE unsafe_unlink(VALUE *args)
+{
+  VALUE path = args[0];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("unlink"),2,wrap_context(ctx),path);
 }
 
@@ -377,18 +528,25 @@ static int rf_unlink(const char *path)
   int error = 0;
   args[0]=rb_str_new2(path);
   res=rb_protect((VALUE (*)())unsafe_unlink,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------RMDIR
-static VALUE unsafe_rmdir(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
+
+static VALUE unsafe_rmdir(VALUE *args)
+{
+  VALUE path = args[0];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("rmdir"),2,wrap_context(ctx),path);
 }
 
@@ -397,21 +555,27 @@ static int rf_rmdir(const char *path)
   VALUE args[1];
   VALUE res;
   int error = 0;
-  args[0]=rb_str_new2(path);
-  res=rb_protect((VALUE (*)())unsafe_rmdir,(VALUE) args,&error);
-  if (error) {
+  args[0] = rb_str_new2(path);
+  res = rb_protect((VALUE (*)())unsafe_rmdir, (VALUE) args ,&error);
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------SYMLINK
+
 static VALUE unsafe_symlink(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE as = values[1];
+  VALUE path = args[0];
+  VALUE as   = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("symlink"),3,wrap_context(ctx),path,as);
 }
 
@@ -423,19 +587,26 @@ static int rf_symlink(const char *path,const char *as)
   args[0]=rb_str_new2(path);
   args[1]=rb_str_new2(as);
   res=rb_protect((VALUE (*)())unsafe_symlink,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------RENAME
-static VALUE unsafe_rename(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE as = values[1];
+
+static VALUE unsafe_rename(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE as   = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("rename"),3,wrap_context(ctx),path,as);
 }
 
@@ -447,19 +618,26 @@ static int rf_rename(const char *path,const char *as)
   args[0]=rb_str_new2(path);
   args[1]=rb_str_new2(as);
   res=rb_protect((VALUE (*)())unsafe_rename,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------LINK
-static VALUE unsafe_link(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE as = values[1];
+
+static VALUE unsafe_link(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE as   = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("link"),3,wrap_context(ctx),path,as);
 }
 
@@ -471,21 +649,28 @@ static int rf_link(const char *path,const char * as)
   args[0]=rb_str_new2(path);
   args[1]=rb_str_new2(as);
   res=rb_protect((VALUE (*)())unsafe_link,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------READ
-static VALUE unsafe_read(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE size = values[1];
-  VALUE offset = values[2];
-  VALUE ffi = values[3];
+
+static VALUE unsafe_read(VALUE *args)
+{
+  VALUE path   = args[0];
+  VALUE size   = args[1];
+  VALUE offset = args[2];
+  VALUE ffi    = args[3];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("read"),5,
         wrap_context(ctx),path,size,offset,ffi);
 }
@@ -497,66 +682,94 @@ static int rf_read(const char *path,char * buf, size_t size,off_t offset,struct
   int error = 0;
   long length=0;
   char* rbuf;
+
   args[0]=rb_str_new2(path);
   args[1]=INT2NUM(size);
   args[2]=INT2NUM(offset);
   args[3]=wrap_file_info(ffi);
+
   res=rb_protect((VALUE (*)())unsafe_read,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
-    rbuf=rb_str2cstr(res,&length); //TODO protect this, too
-    if (length<=size) {
+  }
+  else
+  {
+    length = NUM2LONG(rb_funcall(res, rb_intern("length"), 0));
+    rbuf = rb_str2cstr(res, &length);
+    if (length<=size)
+    {
       memcpy(buf,rbuf,length);
       return length;
-    } else {
-      memcpy(buf,rbuf,size); //TODO: This could be dangerous. 
-                               //Perhaps raise an exception or return an error
-      return size;
     }
-  };
+    else
+    {
+      //This cannot happen => IO error.
+      return -(return_error(ENOENT));
+    }
+  }
 }
-//----------------------
+
 //----------------------WRITE
-static VALUE unsafe_write(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE buffer = values[1];
-  VALUE size = values[2];
-  VALUE offset = values[3];
-  VALUE ffi = values[4];
+
+static VALUE unsafe_write(VALUE *args)
+{
+  VALUE path   = args[0];
+  VALUE buffer = args[1];
+  VALUE offset = args[2];
+  VALUE ffi    = args[3];
+
   struct fuse_context *ctx=fuse_get_context();
-  return rb_funcall(fuse_object,rb_intern("write"),6,
-        wrap_context(ctx),path,buffer,size,offset,ffi);
+
+  return rb_funcall(fuse_object,rb_intern("write"),5,
+        wrap_context(ctx),path,buffer,offset,ffi);
 }
 
-static int rf_write(const char *path,const char *buf,size_t size, off_t offset,struct fuse_file_info *ffi)
+static int rf_write(const char *path,const char *buf,size_t size,
+  off_t offset,struct fuse_file_info *ffi)
 {
-  VALUE args[5];
+  VALUE args[4];
   VALUE res;
   int error = 0;
+
   args[0]=rb_str_new2(path);
-  args[1]=rb_str_new2(buf);
-  args[2]=INT2NUM(size);
-  args[3]=INT2NUM(offset);
-  args[4]=wrap_file_info(ffi);
-  res=rb_protect((VALUE (*)())unsafe_write,(VALUE) args,&error);
-  if (error) {
+  args[1]=rb_str_new(buf, size);
+  args[2]=INT2NUM(offset);
+  args[3]=wrap_file_info(ffi);
+
+  res = rb_protect((VALUE (*)())unsafe_write,(VALUE) args, &error);
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
-    return 0;
-  };
+  }
+  else
+  {
+    return NUM2INT(res);
+  }
+}
+
+//----------------------STATFS
+static int rf_statfs(const char * path, struct statvfs * vfsinfo)
+{
+  // TODO
+  return 0;
 }
-//----------------------
+
 //----------------------SETXATTR
-static VALUE unsafe_setxattr(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE name = values[1];
-  VALUE value = values[2];
-  VALUE size = values[3];
-  VALUE flags = values[4];
+
+static VALUE unsafe_setxattr(VALUE *args)
+{
+
+  VALUE path  = args[0];
+  VALUE name  = args[1];
+  VALUE value = args[2];
+  VALUE size  = args[3];
+  VALUE flags = args[4];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("setxattr"),6,
         wrap_context(ctx),path,name,value,size,flags);
 }
@@ -567,26 +780,35 @@ static int rf_setxattr(const char *path,const char *name,
   VALUE args[5];
   VALUE res;
   int error = 0;
+
   args[0]=rb_str_new2(path);
   args[1]=rb_str_new2(name);
   args[2]=rb_str_new(value,size);
   args[3]=INT2NUM(size); //TODO:FIX would be faster
   args[4]=INT2NUM(flags);
+
   res=rb_protect((VALUE (*)())unsafe_setxattr,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------GETXATTR
-static VALUE unsafe_getxattr(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE name = values[1];
-  VALUE size = values[2];
+
+static VALUE unsafe_getxattr(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE name = args[1];
+  VALUE size = args[2];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("getxattr"),4,
         wrap_context(ctx),path,name,size);
 }
@@ -603,24 +825,32 @@ static int rf_getxattr(const char *path,const char *name,char *buf,
   args[1]=rb_str_new2(name);
   args[2]=INT2NUM(size);
   res=rb_protect((VALUE (*)())unsafe_getxattr,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     rbuf=rb_str2cstr(res,&length); //TODO protect this, too
-    if (buf != NULL) {
+    if (buf != NULL)
+    {
       memcpy(buf,rbuf,length); //First call is just to get the length
       //TODO optimize
     }
     return length;
   }
 }
-//----------------------
+
 //----------------------LISTXATTR
-static VALUE unsafe_listxattr(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE size = values[1];
+
+static VALUE unsafe_listxattr(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE size = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("listxattr"),3,
         wrap_context(ctx),path,size);
 }
@@ -636,33 +866,44 @@ static int rf_listxattr(const char *path,char *buf,
   args[0]=rb_str_new2(path);
   args[1]=INT2NUM(size);
   res=rb_protect((VALUE (*)())unsafe_listxattr,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     rbuf=rb_str2cstr(res,(long *)&length); //TODO protect this, too
-    if (buf != NULL){
-      if (length<=size) {
-  memcpy(buf,rbuf,length); //check for size
+    if (buf != NULL)
+    {
+      if (length<=size)
+      {
+        memcpy(buf,rbuf,length); //check for size
       } else {
-  return -ERANGE;
+        return -ERANGE;
       }
       printf("destination: %s,%d\n",buf,size);
       printf("source:      %s,%d\n",rbuf,length);
       return length;
       //TODO optimize,check lenght
-    } else {
+    }
+    else
+    {
       printf ("not copied: %s, %d\n",buf,length);
       return length;
     }
   }
 }
-//----------------------
+
 //----------------------REMOVEXATTR
-static VALUE unsafe_removexattr(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE name = values[1];
+
+static VALUE unsafe_removexattr(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE name = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("removexattr"),3,
         wrap_context(ctx),path,name);
 }
@@ -675,19 +916,26 @@ static int rf_removexattr(const char *path,const char *name)
   args[0]=rb_str_new2(path);
   args[1]=rb_str_new2(name);
   res=rb_protect((VALUE (*)())unsafe_removexattr,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------OPENDIR
-static VALUE unsafe_opendir(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE ffi =  values[1];
+
+static VALUE unsafe_opendir(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE ffi  = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("opendir"),3,wrap_context(ctx),path,ffi);
 }
 
@@ -699,19 +947,26 @@ static int rf_opendir(const char *path,struct fuse_file_info *ffi)
   args[0]=rb_str_new2(path);
   args[1]=wrap_file_info(ffi);
   res=rb_protect((VALUE (*)())unsafe_opendir,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------RELEASEDIR
-static VALUE unsafe_releasedir(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE ffi =  values[1];
+
+static VALUE unsafe_releasedir(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE ffi  = args[1];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("releasedir"),3,wrap_context(ctx),path,ffi);
 }
 
@@ -723,20 +978,27 @@ static int rf_releasedir(const char *path,struct fuse_file_info *ffi)
   args[0]=rb_str_new2(path);
   args[1]=wrap_file_info(ffi);
   res=rb_protect((VALUE (*)())unsafe_releasedir,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
     return 0;
-  };
+  }
 }
-//----------------------
+
 //----------------------FSYNCDIR
-static VALUE unsafe_fsyncdir(VALUE *args){
-  VALUE *values=(VALUE*)args;
-  VALUE path = values[0];
-  VALUE meta = values[1];
-  VALUE ffi =  values[2];
+
+static VALUE unsafe_fsyncdir(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE meta = args[1];
+  VALUE ffi  = args[2];
+
   struct fuse_context *ctx=fuse_get_context();
+
   return rb_funcall(fuse_object,rb_intern("fsyncdir"),3,wrap_context(ctx),path,
         meta,ffi);
 }
@@ -750,78 +1012,221 @@ static int rf_fsyncdir(const char *path,int meta,struct fuse_file_info *ffi)
   args[1]=INT2NUM(meta);
   args[2]=wrap_file_info(ffi);
   res=rb_protect((VALUE (*)())unsafe_fsyncdir,(VALUE) args,&error);
-  if (error) {
+
+  if (error)
+  {
     return -(return_error(ENOENT));
-  } else {
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+//----------------------INIT
+
+static void *rf_init(struct fuse_conn_info *conn)
+{
+  // TODO
+  return NULL;
+}
+
+//----------------------DESTROY
+
+static void rf_destroy(void *user_data)
+{
+  // TODO
+}
+
+//----------------------ACCESS
+
+static int rf_access(const char *path, int mask)
+{
+  // TODO
+  return 0;
+}
+
+//----------------------CREATE
+
+static int rf_create(const char *path, mode_t mode,
+  struct fuse_file_info *ffi)
+{
+  // TODO
+  return 0;
+}
+
+//----------------------FTRUNCATE
+
+static int rf_ftruncate(const char *path, off_t size,
+  struct fuse_file_info *ffi)
+{
+  // TODO
+  return 0;
+}
+
+//----------------------FGETATTR
+
+static int rf_fgetattr(const char *path, struct stat *stbuf,
+  struct fuse_file_info *ffi)
+{
+  // TODO
+  return 0;
+}
+
+//----------------------LOCK
+
+static int rf_lock(const char *path, struct fuse_file_info *ffi,
+  int cmd, struct flock *lock)
+{
+  // TODO
+  return 0;
+}
+
+//----------------------UTIMENS
+
+static VALUE unsafe_utimens(VALUE *args)
+{
+  VALUE path    = args[0];
+  VALUE actime  = args[1];
+  VALUE modtime = args[2];
+
+  struct fuse_context *ctx=fuse_get_context();
+
+  return rb_funcall(
+    fuse_object,
+    rb_intern("utimens"),
+    4,
+    wrap_context(ctx),
+    path,actime,modtime
+  );
+}
+
+static int rf_utimens(const char * path, const struct timespec tv[2])
+{
+  VALUE args[3];
+  VALUE res;
+  int   error = 0;
+
+  args[0] = rb_str_new2(path);
+
+  // tv_sec * 1000000 + tv_nsec
+  args[1] = rb_funcall(
+    rb_funcall(
+      INT2NUM(tv[0].tv_sec), rb_intern("*"), 1, INT2NUM(1000000)
+    ),
+    rb_intern("+"), 1, INT2NUM(tv[0].tv_nsec)
+  );
+
+  args[2] = rb_funcall(
+    rb_funcall(
+      INT2NUM(tv[1].tv_sec), rb_intern("*"), 1, INT2NUM(1000000)
+    ),
+    rb_intern("+"), 1, INT2NUM(tv[1].tv_nsec)
+  );
+  
+  res = rb_protect((VALUE (*)())unsafe_utimens,(VALUE) args, &error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
     return 0;
-  };
+  }
+}
+
+//----------------------BMAP
+
+static int rf_bmap(const char *path, size_t blocksize, uint64_t *idx)
+{
+  //TODO
+  return 0;
+}
+
+//----------------------IOCTL
+
+static int rf_ioctl(const char *path, int cmd, void *arg,
+  struct fuse_file_info *ffi, unsigned int flags, void *data)
+{
+  //TODO
+  return 0;
+}
+
+//----------------------POLL
+
+static int rf_poll(const char *path, struct fuse_file_info *ffi,
+  struct fuse_pollhandle *ph, unsigned *reventsp)
+{
+  //TODO
+  return 0;
 }
-//----------------------
 
-static VALUE rf_loop(VALUE self){
+//----------------------LOOP
+
+static VALUE rf_loop(VALUE self)
+{
   struct intern_fuse *inf;
   Data_Get_Struct(self,struct intern_fuse,inf);
   fuse_loop(inf->fuse);
   return Qnil;
 }
 
-/*static VALUE rf_loop_mt(VALUE self){
+//----------------------LOOP_MT
+
+static VALUE rf_loop_mt(VALUE self)
+{
   struct intern_fuse *inf;
   Data_Get_Struct(self,struct intern_fuse,inf);
   fuse_loop_mt(inf->fuse);
   return Qnil;
-}*/
+}
+
+//----------------------EXIT
 
-VALUE rf_exit(VALUE self){
+VALUE rf_exit(VALUE self)
+{
   struct intern_fuse *inf;
   Data_Get_Struct(self,struct intern_fuse,inf);
   fuse_exit(inf->fuse);
   return Qnil;
 }
 
-VALUE rf_unmount(VALUE self){
+//----------------------UNMOUNT
+
+VALUE rf_unmount(VALUE self)
+{
   struct intern_fuse *inf;
   Data_Get_Struct(self,struct intern_fuse,inf);
   fuse_unmount(inf->mountname, inf->fc);
   return Qnil;
 }
 
-VALUE rf_mountname(VALUE self){
+//----------------------MOUNTNAME
+
+VALUE rf_mountname(VALUE self)
+{
   struct intern_fuse *inf;
   Data_Get_Struct(self,struct intern_fuse,inf);
   return rb_str_new2(inf->mountname);
 }
-VALUE rf_invalidate(VALUE self,VALUE path){
+
+//----------------------INVALIDATE
+
+VALUE rf_invalidate(VALUE self,VALUE path)
+{
   struct intern_fuse *inf;
   Data_Get_Struct(self,struct intern_fuse,inf);
   return fuse_invalidate(inf->fuse,STR2CSTR(path)); //TODO: check if str?
 }
-//-------------RUBY
 
+#define RESPOND_TO(obj,methodname) \
+  rb_funcall( \
+    obj,rb_intern("respond_to?"), \
+    1, rb_str_new2(methodname) \
+  ) == Qtrue
 
-static struct fuse_args * rarray2fuseargs(VALUE rarray){
-
-  Check_Type(rarray, T_ARRAY);
-
-  struct fuse_args *args = malloc(sizeof(struct fuse_args));
-
-  args->argc      = RARRAY(rarray)->len;
-  args->argv      = malloc(args->argc * sizeof(char *) + 1);
-  /* Nope, this isn't really 'allocated'. The elements
-   * of this array shouldn't be freed */
-  args->allocated = 0;
-
-  int i;
-  VALUE v;
-  for(i = 0; i < args->argc; i++) {
-    v = RARRAY(rarray)->ptr[i];
-    Check_Type(v, T_STRING);
-    args->argv[i] = STR2CSTR(RSTRING(v));
-  }
-  args->argv[args->argc] = NULL;
-  
-  return args;
-}
+//-------------RUBY
 
 static VALUE rf_initialize(
   VALUE self,
@@ -830,61 +1235,106 @@ static VALUE rf_initialize(
   VALUE libopts)
 {
   Check_Type(mountpoint, T_STRING);
-  
+
+  // getdir is deprecated, use readdir instead
+
   struct intern_fuse *inf;
   Data_Get_Struct(self,struct intern_fuse,inf);
-  inf->fuse_op.getattr     = rf_getattr;
-  inf->fuse_op.readlink    = rf_readlink;
-  inf->fuse_op.mknod       = rf_mknod;
-  inf->fuse_op.mkdir       = rf_mkdir;
-  inf->fuse_op.unlink      = rf_unlink;
-  inf->fuse_op.rmdir       = rf_rmdir;
-  inf->fuse_op.symlink     = rf_symlink;
-  inf->fuse_op.rename      = rf_rename;
-  inf->fuse_op.link        = rf_link;
-  inf->fuse_op.chmod       = rf_chmod;
-  inf->fuse_op.chown       = rf_chown;
-  inf->fuse_op.truncate    = rf_truncate;
-  inf->fuse_op.utime       = rf_utime; // Deprecated, use utimens instead
-  inf->fuse_op.open        = rf_open;
-  inf->fuse_op.read        = rf_read;
-  inf->fuse_op.write       = rf_write;
-  //inf->fuse_op.statfs    = rf_statfs; // TODO
-  inf->fuse_op.flush       = rf_flush;
-  inf->fuse_op.release     = rf_release;
-  //inf->fuse_op.fsnyc     = rf_fsync; // TODO
-  inf->fuse_op.setxattr    = rf_setxattr;
-  inf->fuse_op.getxattr    = rf_getxattr;
-  inf->fuse_op.listxattr   = rf_listxattr;
-  inf->fuse_op.removexattr = rf_removexattr;
-  inf->fuse_op.opendir     = rf_opendir;
-  inf->fuse_op.readdir     = rf_readdir;
-  inf->fuse_op.releasedir  = rf_releasedir;
-  inf->fuse_op.fsyncdir    = rf_fsyncdir;
-  //inf->fuse_op.init      = rf_init;
-  //inf->fuse_op.destroy   = rf_destroy;
-  //inf->fuse_op.access    = rf_access;
-  //inf->fuse_op.create    = rf_create;
-  //inf->fuse_op.ftruncate = rf_ftruncate;
-  //inf->fuse_op.fgetattr  = rf_fgetattr;
-  //inf->fuse_op.lock      = rf_lock;
-  //inf->fuse_op.utimens   = rf_utimens;
-  //inf->fuse_op.bmap      = rf_bmap;
-  //inf->fuse_op.ioctl     = rf_ioctl;
-  //inf->fuse_op.poll      = rf_poll;
+  if (RESPOND_TO(self,"getattr"))
+    inf->fuse_op.getattr     = rf_getattr;
+  if (RESPOND_TO(self,"readlink"))
+    inf->fuse_op.readlink    = rf_readlink;
+  if (RESPOND_TO(self,"getdir"))
+    inf->fuse_op.getdir      = rf_getdir;  // Deprecated
+  if (RESPOND_TO(self,"mknod"))
+    inf->fuse_op.mknod       = rf_mknod;
+  if (RESPOND_TO(self,"mkdir"))
+    inf->fuse_op.mkdir       = rf_mkdir;
+  if (RESPOND_TO(self,"unlink"))
+    inf->fuse_op.unlink      = rf_unlink;
+  if (RESPOND_TO(self,"rmdir"))
+    inf->fuse_op.rmdir       = rf_rmdir;
+  if (RESPOND_TO(self,"symlink"))
+    inf->fuse_op.symlink     = rf_symlink;
+  if (RESPOND_TO(self,"rename"))
+    inf->fuse_op.rename      = rf_rename;
+  if (RESPOND_TO(self,"link"))
+    inf->fuse_op.link        = rf_link;
+  if (RESPOND_TO(self,"chmod"))
+    inf->fuse_op.chmod       = rf_chmod;
+  if (RESPOND_TO(self,"chown"))
+    inf->fuse_op.chown       = rf_chown;
+  if (RESPOND_TO(self,"truncate"))
+    inf->fuse_op.truncate    = rf_truncate;
+  if (RESPOND_TO(self,"utime"))
+    inf->fuse_op.utime       = rf_utime;    // Deprecated
+  if (RESPOND_TO(self,"open"))
+    inf->fuse_op.open        = rf_open;
+  if (RESPOND_TO(self,"read"))
+    inf->fuse_op.read        = rf_read;
+  if (RESPOND_TO(self,"write"))
+    inf->fuse_op.write       = rf_write;
+  if (RESPOND_TO(self,"statfs"))
+    inf->fuse_op.statfs      = rf_statfs;   //TODO
+  if (RESPOND_TO(self,"flush"))
+    inf->fuse_op.flush       = rf_flush;
+  if (RESPOND_TO(self,"release"))
+    inf->fuse_op.release     = rf_release;
+  if (RESPOND_TO(self,"fsync"))
+    inf->fuse_op.fsync       = rf_fsync;    // TODO
+  if (RESPOND_TO(self,"setxattr"))
+    inf->fuse_op.setxattr    = rf_setxattr;
+  if (RESPOND_TO(self,"getxattr"))
+    inf->fuse_op.getxattr    = rf_getxattr;
+  if (RESPOND_TO(self,"listxattr"))
+    inf->fuse_op.listxattr   = rf_listxattr;
+  if (RESPOND_TO(self,"removexattr"))
+    inf->fuse_op.removexattr = rf_removexattr;
+  if (RESPOND_TO(self,"opendir"))
+    inf->fuse_op.opendir     = rf_opendir;
+  if (RESPOND_TO(self,"readdir"))
+    inf->fuse_op.readdir     = rf_readdir;
+  if (RESPOND_TO(self,"releasedir"))
+    inf->fuse_op.releasedir  = rf_releasedir;
+  if (RESPOND_TO(self,"fsyncdir"))
+    inf->fuse_op.fsyncdir    = rf_fsyncdir;
+  if (RESPOND_TO(self,"init"))
+    inf->fuse_op.init        = rf_init;      // TODO
+  if (RESPOND_TO(self,"destroy"))
+    inf->fuse_op.destroy     = rf_destroy;   // TODO
+  if (RESPOND_TO(self,"access"))
+    inf->fuse_op.access      = rf_access;    // TODO
+  if (RESPOND_TO(self,"create"))
+    inf->fuse_op.create      = rf_create;    // TODO
+  if (RESPOND_TO(self,"ftruncate"))
+    inf->fuse_op.ftruncate   = rf_ftruncate; // TODO
+  if (RESPOND_TO(self,"fgetattr"))
+    inf->fuse_op.fgetattr    = rf_fgetattr;  // TODO
+  if (RESPOND_TO(self,"lock"))
+    inf->fuse_op.lock        = rf_lock;      // TODO
+  if (RESPOND_TO(self,"utimens"))
+    inf->fuse_op.utimens     = rf_utimens;
+  if (RESPOND_TO(self,"bmap"))
+    inf->fuse_op.bmap        = rf_bmap;      // TODO
+  if (RESPOND_TO(self,"ioctl"))
+    inf->fuse_op.ioctl       = rf_ioctl;     // TODO
+  if (RESPOND_TO(self,"poll"))
+    inf->fuse_op.poll        = rf_poll;      // TODO
 
   struct fuse_args
     *kargs = rarray2fuseargs(kernelopts),
     *largs = rarray2fuseargs(libopts);
 
   intern_fuse_init(inf, STR2CSTR(mountpoint), kargs, largs);
-  
-  fuse_object=self;  // this won't work with multithreading!!!
+
+  //TODO this won't work with multithreading!!!
+  fuse_object=self;
 
   return self;
 }
 
-static VALUE rf_new(VALUE class){
+static VALUE rf_new(VALUE class)
+{
   struct intern_fuse *inf;
   VALUE self;
   inf = intern_fuse_new();
@@ -892,16 +1342,19 @@ static VALUE rf_new(VALUE class){
   return self;
 }
 
-VALUE rfuse_init(VALUE module){
+VALUE rfuse_init(VALUE module)
+{
   VALUE cFuse=rb_define_class_under(module,"Fuse",rb_cObject);
+
   rb_define_alloc_func(cFuse,rf_new);
-  //initialize: string mountpoint,array kernel_opts,array lib_opts
+
   rb_define_method(cFuse,"initialize",rf_initialize,3);
   rb_define_method(cFuse,"loop",rf_loop,0);
-  //rb_define_method(cFuse,"loop_mt",rf_loop_mt,0); TODO: not until RIKE!
+  rb_define_method(cFuse,"loop_mt",rf_loop_mt,0); //TODO: not until RIKE!
   rb_define_method(cFuse,"exit",rf_exit,0);
   rb_define_method(cFuse,"invalidate",rf_invalidate,1);
   rb_define_method(cFuse,"unmount",rf_unmount,0);
   rb_define_method(cFuse,"mountname",rf_mountname,0);
+
   return cFuse;
 }