rfuse 1.0.0

data/ext/rfuse/file_info.c

@@ -0,0 +1,140 @@
+#include "file_info.h"
+#include <fuse.h>
+
+//creates a FileInfo object from an already allocated ffi
+VALUE wrap_file_info(struct fuse_context *ctx, struct fuse_file_info *ffi) {
+  VALUE rRFuse;
+  VALUE rFileInfo;
+  
+  VALUE rffi;
+ 
+  VALUE open_files;
+  VALUE key;
+
+  rRFuse=rb_const_get(rb_cObject,rb_intern("RFuse"));
+  rFileInfo=rb_const_get(rRFuse,rb_intern("FileInfo"));
+
+  rffi = Data_Wrap_Struct(rFileInfo,0,0,ffi);
+
+  //store the wrapped ffi back into the struct so we don't have to keep wrapping it
+  ffi->fh = rffi;
+ 
+  //also store it in an open_files hash on the fuse_object
+  //so it doesn't get GC'd
+  open_files = rb_iv_get(ctx->private_data,"@open_files");
+  key        = rb_funcall(rffi,rb_intern("object_id"),0);
+  rb_hash_aset(open_files,key,rffi);
+
+  return rffi;
+};
+
+//returns a previously wrapped ffi
+VALUE get_file_info(struct fuse_file_info *ffi) {
+    
+  if (TYPE(ffi->fh) == T_DATA )
+      return (VALUE) ffi->fh;
+  else
+      return Qnil;
+  
+};
+
+//Allow the FileInfo object to be GC'd 
+VALUE release_file_info(struct fuse_context *ctx, struct fuse_file_info *ffi)
+{
+
+  if (TYPE(ffi->fh) == T_DATA) {
+      VALUE rffi = ffi->fh;
+      VALUE fuse_object = ctx->private_data;
+      VALUE open_files = rb_iv_get(fuse_object,"@open_files");
+      VALUE key = rb_funcall(rffi,rb_intern("object_id"),0);
+      rb_hash_delete(open_files,key);
+  } else {
+      return Qnil;
+  }
+
+}
+
+VALUE file_info_initialize(VALUE self){
+  return self;
+}
+
+//TODO FT: test: this _should_not_ be called, an exception would do the trick :)
+VALUE file_info_new(VALUE class){
+  rb_raise(rb_eNotImpError, "new() not implemented (it has no use), and should not be called");
+  return Qnil;
+}
+
+VALUE file_info_writepage(VALUE self) {
+  struct fuse_file_info *f;
+  Data_Get_Struct(self,struct fuse_file_info,f);
+  return INT2FIX(f->writepage);
+}
+
+VALUE file_info_flags(VALUE self) {
+  struct fuse_file_info *f;
+  Data_Get_Struct(self,struct fuse_file_info,f);
+  return INT2FIX(f->flags);
+}
+
+VALUE file_info_direct(VALUE self) {
+   struct fuse_file_info *f;
+   Data_Get_Struct(self,struct fuse_file_info,f);
+  if (TYPE(f->direct_io) != T_NONE) {
+    return (VALUE) f->direct_io;
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE file_info_direct_assign(VALUE self,VALUE value) {
+   struct fuse_file_info *f;
+   Data_Get_Struct(self,struct fuse_file_info,f);
+   f->direct_io = value;
+   return value;
+}
+
+VALUE file_info_nonseekable(VALUE self) {
+   struct fuse_file_info *f;
+   Data_Get_Struct(self,struct fuse_file_info,f);
+  if (TYPE(f->nonseekable) != T_NONE) {
+    return (VALUE) f->nonseekable;
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE file_info_nonseekable_assign(VALUE self,VALUE value) {
+   struct fuse_file_info *f;
+   Data_Get_Struct(self,struct fuse_file_info,f);
+   f->nonseekable = value;
+   return value;
+}
+
+/*
+   Document-class: RFuse::FileInfo
+
+   Represents an open file (or directory) that is reused
+   across multiple fuse operations
+
+*/
+void file_info_init(VALUE module) {
+#if 0
+    //Trick Yardoc
+    module = rb_define_module("RFuse");
+#endif
+  VALUE cFileInfo=rb_define_class_under(module,"FileInfo",rb_cObject);
+  rb_define_alloc_func(cFileInfo,file_info_new);
+  rb_define_method(cFileInfo,"initialize",file_info_initialize,0);
+  rb_define_method(cFileInfo,"flags",file_info_flags,0);
+  rb_define_method(cFileInfo,"writepage",file_info_writepage,0);
+  rb_define_method(cFileInfo,"direct",file_info_direct,0);
+  rb_define_method(cFileInfo,"direct=",file_info_direct_assign,1);
+  rb_define_method(cFileInfo,"nonseekable",file_info_nonseekable,0);
+  rb_define_method(cFileInfo,"nonseekable=",file_info_nonseekable_assign,1);
+  
+  /*
+     Filehandle - can be any ruby object
+  */
+  rb_define_attr(cFileInfo,"fh",1,1);
+  return cFileInfo;
+}

data/ext/rfuse/file_info.h

@@ -0,0 +1,13 @@
+#include <fuse.h>
+#include <ruby.h>
+
+VALUE wrap_file_info(struct fuse_context *ctx, struct fuse_file_info *ffi);
+VALUE get_file_info(struct fuse_file_info *ffi);
+VALUE release_file_info(struct fuse_context *ctx, struct fuse_file_info *ffi);
+
+VALUE file_info_initialize(VALUE self);
+VALUE file_info_new(VALUE class);
+VALUE file_info_flags(VALUE self);
+VALUE file_info_writepage(VALUE self);
+
+void file_info_init(VALUE module);

data/ext/rfuse/filler.c

@@ -0,0 +1,60 @@
+#include "filler.h"
+#include <fuse.h>
+#include "helper.h"
+
+VALUE rfiller_initialize(VALUE self){
+  return self;
+}
+
+/*
+* @api private Never called
+*/
+VALUE rfiller_new(VALUE class){
+  VALUE self;
+  struct filler_t *f;
+  self = Data_Make_Struct(class, struct filler_t, 0,free,f);
+  return self;
+}
+
+/*
+ * Add a value into the filler 
+ * @param [String] name a file name
+ * @param [Stat] stat Stat info representing the file, may be nil
+ * @param [Integer] offset index of next entry, or zero
+ * 
+ * @return self or nil if the buffer is full
+ * 
+ */
+VALUE rfiller_push(VALUE self, VALUE name, VALUE stat, VALUE offset) {
+  struct filler_t *f;
+  Data_Get_Struct(self,struct filler_t,f);
+  //Allow nil return instead of a stat
+
+  int result;
+
+  if (NIL_P(stat)) {
+    result = f->filler(f->buffer,STR2CSTR(name),NULL,NUM2LONG(offset));
+  } else {
+    struct stat st;
+    memset(&st, 0, sizeof(st));
+    rstat2stat(stat,&st);
+    result = f->filler(f->buffer,STR2CSTR(name),&st,NUM2LONG(offset));
+  }
+
+  return result ? Qnil : self;
+}
+
+/*
+* Document-class: RFuse::Filler
+* Used by {Fuse#readdir} to collect directory entries
+*/
+void rfiller_init(VALUE module) {
+
+#if 0
+  module = rb_define_module("RFuse");
+#endif
+  VALUE cFiller=rb_define_class_under(module,"Filler",rb_cObject);
+  rb_define_alloc_func(cFiller,rfiller_new);
+  rb_define_method(cFiller,"initialize",rfiller_initialize,0);
+  rb_define_method(cFiller,"push",rfiller_push,3);
+}

data/ext/rfuse/filler.h

@@ -0,0 +1,15 @@
+#include <fuse.h>
+#include <ruby.h>
+
+struct filler_t {
+  fuse_fill_dir_t filler;
+  void            *buffer;
+  fuse_dirh_t     dh;
+  fuse_dirfil_t   df;
+};
+
+VALUE rfiller_initialize(VALUE self);
+VALUE rfiller_new(VALUE class);
+VALUE rfiller_push(VALUE self, VALUE name, VALUE stat, VALUE offset);
+
+void rfiller_init(VALUE module);

data/ext/rfuse/helper.c

@@ -0,0 +1,93 @@
+#include "helper.h"
+
+char*
+rb_compat_str2cstr(VALUE x)
+{
+  return StringValuePtr(x);
+}
+
+void rstat2stat(VALUE rstat, struct stat *statbuf)
+{
+  statbuf->st_dev     = FIX2ULONG(rb_funcall(rstat,rb_intern("dev"),0));
+  statbuf->st_ino     = FIX2ULONG(rb_funcall(rstat,rb_intern("ino"),0));
+  statbuf->st_mode    = FIX2UINT(rb_funcall(rstat,rb_intern("mode"),0));
+  statbuf->st_nlink   = FIX2UINT(rb_funcall(rstat,rb_intern("nlink"),0));
+  statbuf->st_uid     = FIX2UINT(rb_funcall(rstat,rb_intern("uid"),0));
+  statbuf->st_gid     = FIX2UINT(rb_funcall(rstat,rb_intern("gid"),0));
+  statbuf->st_rdev    = FIX2ULONG(rb_funcall(rstat,rb_intern("rdev"),0));
+  statbuf->st_size    = FIX2ULONG(rb_funcall(rstat,rb_intern("size"),0));
+  statbuf->st_blksize = NUM2ULONG(rb_funcall(rstat,rb_intern("blksize"),0));
+  statbuf->st_blocks  = NUM2ULONG(rb_funcall(rstat,rb_intern("blocks"),0));
+
+  VALUE r_atime = rb_funcall(rstat,rb_intern("atime"),0);
+  VALUE r_mtime = rb_funcall(rstat,rb_intern("mtime"),0);
+  VALUE r_ctime = rb_funcall(rstat,rb_intern("ctime"),0);
+
+  ID to_i = rb_intern("to_i");
+
+  statbuf->st_atime = NUM2ULONG(rb_funcall(r_atime,to_i,0));
+  statbuf->st_mtime = NUM2ULONG(rb_funcall(r_mtime,to_i,0));
+  statbuf->st_ctime = NUM2ULONG(rb_funcall(r_ctime,to_i,0));
+
+//TODO: Find out the correct way to test for nano second resolution availability
+#ifdef _STATBUF_ST_NSEC
+  ID nsec = rb_intern("nsec");
+
+  if (rb_respond_to(r_atime,nsec))
+    statbuf->st_atim.tv_nsec = NUM2ULONG(rb_funcall(r_atime,nsec,0));
+
+  if (rb_respond_to(r_mtime,nsec))
+    statbuf->st_mtim.tv_nsec = NUM2ULONG(rb_funcall(r_mtime,nsec,0));
+
+  if (rb_respond_to(r_ctime,nsec))
+    statbuf->st_ctim.tv_nsec = NUM2ULONG(rb_funcall(r_ctime,nsec,0));
+#endif
+
+}
+
+void rstatvfs2statvfs(VALUE rstatvfs,struct statvfs *statvfsbuf) {
+  statvfsbuf->f_bsize   = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_bsize"),0));
+  statvfsbuf->f_frsize  = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_frsize"),0));
+  statvfsbuf->f_blocks  = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_blocks"),0));
+  statvfsbuf->f_bfree   = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_bfree"),0));
+  statvfsbuf->f_bavail  = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_bavail"),0));
+  statvfsbuf->f_files   = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_files"),0));
+  statvfsbuf->f_ffree   = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_ffree"),0));
+  statvfsbuf->f_favail  = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_favail"),0));
+  statvfsbuf->f_fsid    = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_fsid"),0));
+  statvfsbuf->f_flag    = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_flag"),0));
+  statvfsbuf->f_namemax = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_namemax"),0));
+}
+
+void rfuseconninfo2fuseconninfo(VALUE rfuseconninfo,struct fuse_conn_info *fuseconninfo) {
+  fuseconninfo->proto_major   = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("proto_major"),0));
+  fuseconninfo->proto_minor   = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("proto_minor"),0));
+  fuseconninfo->async_read    = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("async_read"),0));
+  fuseconninfo->max_write     = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("max_write"),0));
+  fuseconninfo->max_readahead = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("max_readahead"),0));
+  fuseconninfo->capable       = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("capable"),0));
+  fuseconninfo->want          = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("want"),0));
+}
+
+struct fuse_args * rarray2fuseargs(VALUE rarray){
+
+  Check_Type(rarray, T_ARRAY);
+  struct fuse_args *args = malloc(sizeof(struct fuse_args));
+  args->argc      = RARRAY_LEN(rarray) + 1;
+  args->argv      = malloc((args->argc + 1) * sizeof(char *));
+  args->allocated = 1;
+
+  int i;
+  VALUE v;
+
+  args->argv[0] = strdup("");
+
+  for(i = 0; i < args->argc - 1; i++) {
+      v = RARRAY_PTR(rarray)[i];
+      Check_Type(v, T_STRING);
+      args->argv[i+1] = strdup(rb_string_value_ptr(&v)); //STR2CSTR(RSTRING(v));
+                                      }
+  args->argv[args->argc] = NULL;
+                        
+  return args;
+}

data/ext/rfuse/helper.h

@@ -0,0 +1,22 @@
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <ruby.h>
+#include <fuse.h>
+
+#ifndef _RHUSE_HELPER_H
+#define _RHUSE_HELPER_H
+
+#define STR2CSTR(x) rb_compat_str2cstr(x)
+char *rb_compat_str2cstr(VALUE);
+
+void rstat2stat(VALUE rstat,struct stat *statbuf);
+void rstatvfs2statvfs(VALUE rstatvfs,struct statvfs *statvfsbuf);
+void rfuseconninfo2fuseconninfo(VALUE rfuseconninfo,struct fuse_conn_info *fuseconninfo);
+struct fuse_args * rarray2fuseargs(VALUE rarray);
+
+#if defined(RUBY_VERSION) && RUBY_VERSION >= 19
+  #define STR2CSTR(X) StringValuePtr(X)
+#endif
+
+
+#endif

data/ext/rfuse/intern_rfuse.c

@@ -0,0 +1,84 @@
+#include "intern_rfuse.h"
+#include <fuse/fuse_lowlevel.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct intern_fuse *intern_fuse_new() {
+  struct intern_fuse *inf;
+  inf = (struct intern_fuse *) malloc(sizeof(struct intern_fuse));
+  memset(inf, 0, sizeof(*inf));
+  memset(&inf->fuse_op, 0, sizeof(struct fuse_operations));
+  return inf;
+}
+
+
+int intern_fuse_destroy(struct intern_fuse *inf){
+  //you have to take care, that fuse is unmounted yourself!
+  if(inf->fuse)
+    fuse_destroy(inf->fuse);
+  if(inf->mountpoint)
+     free(inf->mountpoint);
+  free(inf);
+  return 0;
+}
+
+int intern_fuse_init(
+  struct intern_fuse *inf,
+  struct fuse_args *args,
+  void* user_data
+  )
+{
+  struct fuse_chan* fc;
+  int res;                                       
+
+  char* mountpoint;
+  mountpoint = inf->mountpoint;
+  fc = fuse_mount(mountpoint,args);
+
+  if (fc == NULL) {
+    return -1;
+  }
+
+  inf->fuse=fuse_new(fc, args, &(inf->fuse_op), sizeof(struct fuse_operations), user_data);
+  if (inf->fuse == NULL) {
+      fuse_unmount(inf->mountpoint, fc);
+      return -1;
+  }
+
+  inf->fc = fc;
+
+  return 0;
+}
+
+// Return the /dev/fuse file descriptor for use with IO.select
+int intern_fuse_fd(struct intern_fuse *inf)
+{
+   if (inf->fc == NULL) {
+     return -1;
+   }
+
+  struct fuse_chan *fc = inf->fc;
+  return fuse_chan_fd(fc);
+}
+
+//Process one fuse command (ie after IO.select)
+int intern_fuse_process(struct intern_fuse *inf)
+{
+  if (inf->fuse == NULL) {
+    return -1;
+  }
+
+  if (fuse_exited(inf->fuse)) {
+    return -1;
+  }
+
+  struct fuse_cmd *cmd;
+  cmd = fuse_read_cmd(inf->fuse);
+
+  if (cmd != NULL) {
+    fuse_process_cmd(inf->fuse, cmd);
+  }
+
+  return 0;
+}

data/ext/rfuse/intern_rfuse.h

@@ -0,0 +1,22 @@
+#include <fuse.h>
+
+#define MOUNTNAME_MAX 1024
+
+struct intern_fuse {
+  struct fuse_chan *fc;
+  struct fuse *fuse;
+  struct fuse_operations fuse_op;
+  char *mountpoint;
+};
+
+struct intern_fuse *intern_fuse_new();
+
+int intern_fuse_init(
+  struct intern_fuse *inf,
+  struct fuse_args *args,
+  void *user_data
+);
+
+int intern_fuse_fd(struct intern_fuse *inf);
+int intern_fuse_process(struct intern_fuse *inf);
+int intern_fuse_destroy(struct intern_fuse *inf);

data/ext/rfuse/pollhandle.c

@@ -0,0 +1,54 @@
+#include <ruby.h>
+#include <fuse.h>
+
+#include "pollhandle.h"
+
+static int pollhandle_destroy(struct fuse_pollhandle *ph)
+{
+  fuse_pollhandle_destroy(ph);
+  return 0;
+}
+
+VALUE pollhandle_new(VALUE class)
+{
+  rb_raise(rb_eNotImpError, "new() not implemented (it has no use), and should not be called");
+  return Qnil;
+}
+
+VALUE pollhandle_initialize(VALUE self)
+{
+  return self;
+}
+
+VALUE pollhandle_notify_poll(VALUE self)
+{
+  struct fuse_pollhandle *ph;
+  Data_Get_Struct(self, struct fuse_pollhandle, ph);
+  return INT2FIX(fuse_notify_poll(ph));
+}
+
+VALUE wrap_pollhandle(struct fuse_pollhandle *ph)
+{
+  VALUE rRFuse;
+  VALUE rPollHandle;
+
+  rRFuse      = rb_const_get(rb_cObject,rb_intern("RFuse"));
+  rPollHandle = rb_const_get(rRFuse,rb_intern("PollHandle"));
+
+  // We need a mark function here to ensure the ph is not GC'd
+  // between poll and notify_poll
+  return Data_Wrap_Struct(rPollHandle, NULL, pollhandle_destroy, ph);
+
+}
+
+VALUE pollhandle_init(VALUE module)
+{
+  VALUE cPollHandle = rb_define_class_under(module,"PollHandle",rb_cObject);
+
+  rb_define_alloc_func(cPollHandle,pollhandle_new);
+
+  rb_define_method(cPollHandle,"initialize",pollhandle_initialize,0);
+  rb_define_method(cPollHandle,"notifyPoll",pollhandle_notify_poll,0);
+
+  return cPollHandle;
+}

data/ext/rfuse/pollhandle.h

@@ -0,0 +1,10 @@
+#include <fuse.h>
+#include <ruby.h>
+
+VALUE wrap_pollhandle(struct fuse_pollhandle *ph);
+
+VALUE pollhandle_new(VALUE class);
+VALUE pollhandle_initialize(VALUE self);
+VALUE pollhandle_notify_poll(VALUE self);
+
+VALUE pollhandle_init(VALUE module);