rfuse-ng 0.1

data/ext/file_info.c

@@ -0,0 +1,45 @@
+#include "file_info.h"
+#include <fuse.h>
+
+
+VALUE wrap_file_info(struct fuse_file_info *ffi) {
+  VALUE rRFuse;
+  VALUE rFileInfo;
+  rRFuse=rb_const_get(rb_cObject,rb_intern("RFuse"));
+  rFileInfo=rb_const_get(rRFuse,rb_intern("FileInfo"));
+  return Data_Wrap_Struct(rFileInfo,0,0,ffi); //shouldn't be freed!
+
+};
+
+
+VALUE file_info_initialize(VALUE self){
+  return self;
+}
+
+VALUE file_info_new(VALUE class){
+  VALUE self;
+  struct fuse_file_info *f;
+  self = Data_Make_Struct(class, struct fuse_file_info, 0,NULL,f);
+  return self;
+}
+
+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_init(VALUE module) {
+  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);
+  return cFileInfo;
+}

data/ext/file_info.h

@@ -0,0 +1,11 @@
+#include <fuse.h>
+#include <ruby.h>
+
+VALUE wrap_file_info(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);
+
+VALUE file_info_init(VALUE module);

data/ext/filler.c

@@ -0,0 +1,33 @@
+#include "filler.h"
+#include <fuse.h>
+#include "helper.h"
+
+VALUE rfiller_initialize(VALUE self){
+  return self;
+}
+
+
+VALUE rfiller_new(VALUE class){
+  VALUE self;
+  struct filler_t *f;
+  self = Data_Make_Struct(class, struct filler_t, 0,free,f);
+  return self;
+}
+
+VALUE rfiller_push(VALUE self,VALUE name, VALUE stat,VALUE offset) {
+  struct filler_t *f;
+  Data_Get_Struct(self,struct filler_t,f);
+  struct stat st;
+  memset(&st, 0, sizeof(st));
+  rstat2stat(stat,&st);
+  f->filler(f->buffer,STR2CSTR(name),&st,NUM2LONG(offset));
+  return self;
+}
+
+VALUE rfiller_init(VALUE module) {
+  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);
+  return cFiller;
+}

data/ext/filler.h

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

data/ext/helper.c

@@ -0,0 +1,20 @@
+#include "helper.h"
+
+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));
+    statbuf->st_atime=NUM2ULONG(rb_funcall(rb_funcall(rstat,
+			rb_intern("atime"),0),rb_intern("to_i"),0));
+    statbuf->st_mtime=NUM2ULONG(rb_funcall(rb_funcall(rstat,
+                        rb_intern("mtime"),0),rb_intern("to_i"),0));
+    statbuf->st_ctime=NUM2ULONG(rb_funcall(rb_funcall(rstat,
+                        rb_intern("ctime"),0),rb_intern("to_i"),0));
+};

data/ext/helper.h

@@ -0,0 +1,7 @@
+#include <sys/stat.h>
+#include <ruby.h>
+
+#ifndef _RHUSE_HELPER_H
+#define _RHUSE_HELPER_H
+void rstat2stat(VALUE rstat,struct stat *statbuf);
+#endif

data/ext/intern_rfuse.c

@@ -0,0 +1,32 @@
+#include <stdlib.h>
+#include <string.h>
+#include <fuse.h>
+#include "intern_rfuse.h"
+
+struct intern_fuse *intern_fuse_new() {
+  struct intern_fuse *inf;
+  inf = (struct intern_fuse *) malloc(sizeof(struct intern_fuse));
+  return inf;
+};
+
+int intern_fuse_destroy(struct intern_fuse *inf){
+  //you have to take care, that fuse is unmounted yourself!
+  fuse_destroy(inf->fuse);
+  free(inf);
+  return 0;
+};
+
+int intern_fuse_init(struct intern_fuse *inf,
+		     const char *mountpoint, 
+		     const char *kernelopts,
+		     const char *libopts) {
+  int fd;
+  fd=fuse_mount(mountpoint,kernelopts);
+  if (fd==-1) 
+    return -1;
+  inf->fuse=fuse_new(fd,libopts,&(inf->fuse_op),sizeof(struct fuse_operations));
+  inf->fd=fd;
+  //TODO: check length
+  strncpy(inf->mountname,mountpoint,MOUNTNAME_MAX);
+  return 0;
+};

data/ext/intern_rfuse.h

@@ -0,0 +1,21 @@
+
+#include <fuse.h>
+
+#define MOUNTNAME_MAX 1024
+struct intern_fuse {
+  int fd;
+  struct fuse *fuse;
+  struct fuse_operations fuse_op;
+  struct fuse_context *fuse_ctx;
+  char   mountname[MOUNTNAME_MAX];
+  int state; //created,mounted,running
+};
+
+struct intern_fuse *intern_fuse_new();
+
+int intern_fuse_init(struct intern_fuse *inf,
+		     const char *mountpoint, 
+		     const char *kernelopts,
+		     const char *libopts);
+
+int intern_fuse_destroy(struct intern_fuse *inf);