net-smb 0.0.1 → 0.0.2

data/ext/net/smb/smbdir.c

@@ -0,0 +1,236 @@
+/*
+ * Ruby/Net::SMB - SMB/CIFS client (Samba libsmbclient binding) for Ruby
+ * Net::SMB::Dir class
+ * Copyright (C) 2012 SATOH Fumiyas @ OSS Technology Corp., Japan
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "rb_smb.h"
+#include "dlinklist.h"
+
+#include <ruby/util.h>
+#include <errno.h>
+
+VALUE rb_cSMBDir;
+
+/* ====================================================================== */
+
+static void rb_smbdir_data_gc_mark(RB_SMBFILE_DATA *data)
+{
+  rb_gc_mark(data->smb_obj);
+}
+
+static void rb_smbdir_close_by_data(RB_SMBFILE_DATA *data)
+{
+  if (data->smbcfile == NULL) {
+    rb_raise(rb_eIOError, "Closed directory object");
+  }
+
+  smbc_closedir_fn fn = smbc_getFunctionClosedir(data->smbcctx);
+
+  if ((*fn)(data->smbcctx, data->smbcfile) != 0) {
+    rb_sys_fail("SMBC_closedir_ctx() failed");
+  }
+}
+
+static void rb_smbdir_close_and_deref_by_data(RB_SMBFILE_DATA *data)
+{
+  RB_SMB_DEBUG("data=%p smbcctx=%p smbcfile=%p\n", data, data->smbcctx, data->smbcfile);
+
+  rb_smbdir_close_by_data(data);
+
+  data->smbcctx = NULL;
+  data->smbcfile = NULL;
+
+  DLIST_REMOVE(data->smb_data->smbfile_data_list, data);
+
+  RB_SMB_DEBUG("smbfile_data_list=%p smbfile_data=%p\n", data->smb_data->smbfile_data_list, data);
+}
+
+static void rb_smbdir_data_free(RB_SMBFILE_DATA *data)
+{
+  RB_SMB_DEBUG("data=%p smbcctx=%p smbcfile=%p\n", data, data->smbcctx, data->smbcfile);
+
+  if (data->smbcfile != NULL) {
+    rb_smbdir_close_and_deref_by_data(data);
+  }
+
+  ruby_xfree(data->url);
+  ruby_xfree(data);
+}
+
+static VALUE rb_smbdir_data_alloc(VALUE klass)
+{
+  RB_SMBFILE_DATA *data = ALLOC(RB_SMBFILE_DATA);
+
+  memset(data, 0, sizeof(*data));
+
+  data->smb_obj = Qnil;
+
+  return Data_Wrap_Struct(klass, rb_smbdir_data_gc_mark, rb_smbdir_data_free, data);
+}
+
+static VALUE rb_smbdir_close(VALUE self);
+
+static VALUE rb_smbdir_initialize(VALUE self, VALUE smb_obj, VALUE url_obj)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+  RB_SMB_DATA_FROM_OBJ(smb_obj, smb_data);
+  smbc_opendir_fn fn;
+  const char *url = StringValueCStr(url_obj);
+
+  fn = smbc_getFunctionOpendir(smb_data->smbcctx);
+  data->smbcfile = (*fn)(smb_data->smbcctx, url);
+  if (data->smbcfile == NULL) {
+    rb_sys_fail("SMBC_opendir_ctx() failed");
+  }
+
+  /* FIXME: Take encoding from argument */
+  /* FIXME: Read unix charset (?) from smb.conf for default encoding */
+  data->enc = rb_enc_find("UTF-8");
+
+  data->smb_obj = smb_obj;
+  data->smb_data = smb_data;
+  data->smbcctx = smb_data->smbcctx;
+  data->url = ruby_strdup(url);
+
+  RB_SMB_DEBUG("smbcctx=%p smbcfile=%p\n", data->smbcctx, data->smbcfile);
+
+  if (rb_block_given_p()) {
+    rb_ensure(rb_yield, self, rb_smbdir_close, self);
+    return Qnil;
+  }
+
+  return self;
+}
+
+static VALUE rb_smbdir_smb(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+
+  return data->smb_obj;
+}
+
+static VALUE rb_smbdir_url(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+
+  return rb_str_new2(data->url);
+}
+
+static VALUE rb_smbdir_close(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+
+  RB_SMB_DEBUG("data=%p smbcctx=%p smbcfile=%p\n", data, data->smbcctx, data->smbcfile);
+
+  rb_smbdir_close_and_deref_by_data(data);
+
+  return self;
+}
+
+static VALUE rb_smbdir_tell(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+  smbc_telldir_fn fn;
+  off_t offset;
+
+  fn = smbc_getFunctionTelldir(data->smbcctx);
+
+  errno = 0;
+  offset = (*fn)(data->smbcctx, data->smbcfile);
+  if (offset == (off_t)-1) {
+    if (errno != 0) {
+      rb_sys_fail("SMBC_telldir_ctx() failed");
+    }
+  }
+
+  return LONG2NUM(offset);
+}
+
+static VALUE rb_smbdir_seek(VALUE self, VALUE offset_num)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+  smbc_lseekdir_fn fn;
+  off_t offset = (off_t)NUM2LONG(offset_num);
+
+  fn = smbc_getFunctionLseekdir(data->smbcctx);
+
+  errno = 0;
+  if ((*fn)(data->smbcctx, data->smbcfile, offset) == -1) {
+    rb_sys_fail("SMBC_lseekdir_ctx() failed");
+  }
+
+  return self;
+}
+
+static VALUE rb_smbdir_rewind(VALUE self)
+{
+  return rb_smbdir_seek(self, LONG2NUM(0));
+}
+
+static VALUE rb_smbdir_read(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+  smbc_readdir_fn fn;
+  struct smbc_dirent *smbcdent;
+
+  fn = smbc_getFunctionReaddir(data->smbcctx);
+
+  errno = 0;
+  smbcdent = (*fn)(data->smbcctx, data->smbcfile);
+
+  if (smbcdent == NULL) {
+    if (errno) {
+      rb_sys_fail("SMBC_readdir_ctx() failed");
+    }
+
+    return Qnil;
+  }
+
+  return rb_external_str_new_with_enc(smbcdent->name, strlen(smbcdent->name), data->enc);
+}
+
+static VALUE rb_smbdir_each(VALUE self)
+{
+  VALUE name;
+
+  RETURN_ENUMERATOR(self, 0, 0);
+
+  while (!NIL_P(name = rb_smbdir_read(self))) {
+    rb_yield(name);
+  }
+
+  return self;
+}
+
+/* ====================================================================== */
+
+void Init_smbdir(void)
+{
+  rb_cSMBDir = rb_define_class_under(rb_cSMB, "Dir", rb_cObject);
+  rb_define_alloc_func(rb_cSMBDir, rb_smbdir_data_alloc);
+  rb_define_method(rb_cSMBDir, "initialize", rb_smbdir_initialize, 2);
+  rb_define_method(rb_cSMBDir, "smb", rb_smbdir_smb, 0);
+  rb_define_method(rb_cSMBDir, "url", rb_smbdir_url, 0);
+  rb_define_method(rb_cSMBDir, "close", rb_smbdir_close, 0);
+  rb_define_method(rb_cSMBDir, "tell", rb_smbdir_tell, 0);
+  rb_define_alias(rb_cSMBDir, "pos", "tell");
+  rb_define_method(rb_cSMBDir, "seek", rb_smbdir_seek, 1);
+  rb_define_method(rb_cSMBDir, "rewind", rb_smbdir_rewind, 0);
+  rb_define_method(rb_cSMBDir, "read", rb_smbdir_read, 0);
+  rb_define_method(rb_cSMBDir, "each", rb_smbdir_each, 0);
+}
+

data/ext/net/smb/smbfile.c

@@ -0,0 +1,354 @@
+/*
+ * Ruby/Net::SMB - SMB/CIFS client (Samba libsmbclient binding) for Ruby
+ * Net::SMB::File class
+ * Copyright (C) 2012 SATOH Fumiyas @ OSS Technology Corp., Japan
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "rb_smb.h"
+#include "dlinklist.h"
+
+#include <ruby/util.h>
+#include <ruby/io.h>
+#include <errno.h>
+
+VALUE rb_cSMBFile;
+
+/* ====================================================================== */
+
+static void rb_smbfile_data_gc_mark(RB_SMBFILE_DATA *data)
+{
+  rb_gc_mark(data->smb_obj);
+}
+
+static void rb_smbfile_close_by_data(RB_SMBFILE_DATA *data)
+{
+  if (data->smbcfile == NULL) {
+    rb_raise(rb_eIOError, "Closed file object");
+  }
+
+  smbc_close_fn fn = smbc_getFunctionClose(data->smbcctx);
+
+  if ((*fn)(data->smbcctx, data->smbcfile) != 0) {
+    rb_sys_fail("SMBC_close_ctx() failed");
+  }
+}
+
+static void rb_smbfile_close_and_deref_by_data(RB_SMBFILE_DATA *data)
+{
+  rb_smbfile_close_by_data(data);
+
+  data->smbcctx = NULL;
+  data->smbcfile = NULL;
+
+  DLIST_REMOVE(data->smb_data->smbfile_data_list, data);
+}
+
+static void rb_smbfile_data_free(RB_SMBFILE_DATA *data)
+{
+  RB_SMB_DEBUG("smbcctx=%p smbcfile=%p\n", data->smbcctx, data->smbcfile);
+
+  if (data->smbcfile != NULL) {
+    rb_smbfile_close_and_deref_by_data(data);
+  }
+
+  ruby_xfree(data->url);
+  ruby_xfree(data->buffer);
+  ruby_xfree(data);
+}
+
+static VALUE rb_smbfile_data_alloc(VALUE klass)
+{
+  RB_SMBFILE_DATA *data = ALLOC(RB_SMBFILE_DATA);
+
+  memset(data, 0, sizeof(*data));
+
+  data->smb_obj = Qnil;
+
+  return Data_Wrap_Struct(klass, rb_smbfile_data_gc_mark, rb_smbfile_data_free, data);
+}
+
+static void rb_smbfile_open_by_data(RB_SMBFILE_DATA *data)
+{
+  smbc_open_fn fn = smbc_getFunctionOpen(data->smbcctx);
+
+  data->smbcfile = (*fn)(data->smbcctx, data->url, data->oflags, 0);
+  if (data->smbcfile == NULL) {
+    rb_sys_fail("SMBC_open_ctx() failed");
+  }
+
+  RB_SMB_DEBUG("smbcctx=%p smbcfile=%p\n", data->smbcctx, data->smbcfile);
+}
+
+static void rb_smbfile_seek_by_data(RB_SMBFILE_DATA *data)
+{
+  smbc_lseek_fn fn = smbc_getFunctionLseek(data->smbcctx);
+
+  if ((*fn)(data->smbcctx, data->smbcfile, data->pos, SEEK_SET) == -1) {
+    rb_sys_fail("SMBC_lseek_ctx() failed");
+  }
+
+  data->buffer_used_size = 0;
+  data->buffer_pos = 0;
+  data->eof = 0;
+}
+
+static void rb_smbfile_reopen_by_data(RB_SMBFILE_DATA *data)
+{
+  rb_smbfile_close_by_data(data);
+  rb_smbfile_open_by_data(data);
+  rb_smbfile_seek_by_data(data);
+}
+
+static void rb_smbfile_read_by_data(RB_SMBFILE_DATA *data)
+{
+  smbc_read_fn fn;
+  ssize_t read_size;
+  char *buffer = data->buffer + data->buffer_used_size;
+  size_t buffer_size = data->buffer_size - data->buffer_used_size;
+
+  if (buffer_size == 0) {
+    /* Buffer is full */
+    if (data->buffer_pos < data->buffer_used_size) {
+      /* But remained data exists */
+      return;
+    }
+
+    /* Rewind */
+    data->buffer_used_size = 0;
+    data->buffer_pos = 0;
+    buffer = data->buffer;
+    buffer_size = data->buffer_size;
+  }
+
+  fn = smbc_getFunctionRead(data->smbcctx);
+
+try:
+  read_size = (*fn)(data->smbcctx, data->smbcfile, buffer, buffer_size);
+  if (read_size < 0) {
+    if (errno != EBADF) {
+      rb_sys_fail("Bad SMBCFILE");
+    }
+    else {
+      rb_smbfile_reopen_by_data(data);
+      goto try;
+    }
+  }
+
+  data->buffer_used_size += read_size;
+  data->eof = (read_size == 0);
+}
+
+static VALUE rb_smbfile_initialize(int argc, VALUE *argv, VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+  VALUE smb_obj, url_obj, mode_obj;
+
+  rb_scan_args(argc, argv, "21", &smb_obj, &url_obj, &mode_obj);
+  RB_SMB_DATA_FROM_OBJ(smb_obj, smb_data);
+
+  if (NIL_P(mode_obj)) {
+    data->fmode = FMODE_READABLE;
+    // FIXME data->fmode = FMODE_READABLE | DEFAULT_TEXTMODE;
+    data->oflags = O_RDONLY;
+  }
+  else if (FIXNUM_P(mode_obj)) {
+    rb_raise(rb_eArgError, "FIXME");
+    data->fmode = 0;
+    data->oflags = NUM2INT(mode_obj);
+  }
+  else {
+    const char *mode_str = StringValueCStr(mode_obj);
+    data->fmode = rb_io_modestr_fmode(mode_str);
+    data->oflags = rb_io_modestr_oflags(mode_str);
+  }
+
+  data->smb_obj = smb_obj;
+  data->smb_data = smb_data;
+  data->smbcctx = smb_data->smbcctx;
+  data->url = ruby_strdup(RSTRING_PTR(url_obj));
+
+  data->buffer = ruby_xmalloc(RB_SMBFILE_BUFFER_SIZE);
+  data->buffer_size = RB_SMBFILE_BUFFER_SIZE;
+
+  rb_smbfile_open_by_data(data);
+
+  return self;
+}
+
+static VALUE rb_smbfile_smb(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+
+  return data->smb_obj;
+}
+
+static VALUE rb_smbfile_url(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+
+  return rb_str_new2(data->url);
+}
+
+static VALUE rb_smbfile_close(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+
+  RB_SMB_DEBUG("data=%p smbcctx=%p smbcfile=%p\n", data, data->smbcctx, data->smbcfile);
+
+  rb_smbfile_close_and_deref_by_data(data);
+
+  return self;
+}
+
+static VALUE rb_smbfile_tell(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+
+  return SIZET2NUM(data->pos);
+}
+
+static VALUE rb_smbfile_seek(VALUE self, VALUE offset_num, VALUE whence_num)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+  off_t offset = NUM2OFFT(offset_num);
+  int whence = NUM2INT(whence_num);
+
+  switch (whence) {
+  case SEEK_SET:
+    data->pos = offset;
+    break;
+  case SEEK_CUR:
+    if (offset < 0 && offset < -data->pos) {
+      errno = EINVAL;
+      rb_sys_fail("SMBC_lseek_ctx() failed");
+    }
+    data->pos += offset;
+    break;
+  case SEEK_END:
+    rb_sys_fail("FIXME");
+    break;
+  default:
+    rb_sys_fail("FIXME");
+    break;
+  }
+
+  rb_smbfile_seek_by_data(data);
+
+  return self;
+}
+
+static VALUE rb_smbfile_rewind(VALUE self)
+{
+  return rb_smbfile_seek(self, OFFT2NUM(0), INT2NUM(SEEK_SET));
+}
+
+static VALUE rb_smbfile_eof_p(VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+
+  if (data->buffer_used_size - data->buffer_pos > 0) {
+    /* Remained data exist in buffer */
+    return Qfalse;
+  }
+
+  /* Try to read from file to buffer */
+  rb_smbfile_read_by_data(data);
+
+  if (data->buffer_used_size - data->buffer_pos > 0) {
+    /* Remained data exist in buffer */
+    return Qfalse;
+  }
+
+  return Qtrue;
+}
+
+static void rb_smbfile_readable_p_by_data(RB_SMBFILE_DATA *data)
+{
+  if (data->oflags & O_WRONLY) {
+    rb_raise(rb_eIOError, "Not opened for reading");
+  }
+}
+
+static VALUE rb_smbfile_read(int argc, VALUE *argv, VALUE self)
+{
+  RB_SMBFILE_DATA_FROM_OBJ(self, data);
+  ssize_t req_read_size;
+  VALUE str = rb_str_new2("");
+
+  rb_smbfile_readable_p_by_data(data);
+
+  if (argc == 0) {
+    req_read_size = -1;
+  }
+  else {
+    req_read_size = NUM2SSIZET(argv[0]);
+    if (req_read_size == 0) {
+      return str; /* Return empty string */
+    }
+    if (req_read_size < 0) {
+      rb_raise(rb_eArgError, "Negative length given: %zd", req_read_size);
+    }
+  }
+
+  while (req_read_size) {
+    ssize_t buffer_read_size = data->buffer_used_size - data->buffer_pos;
+
+    if (buffer_read_size == 0) {
+      /* No remained data in buffer */
+      rb_smbfile_read_by_data(data);
+
+      if (data->eof) {
+	/* No remained data in file */
+	return (req_read_size > 0 && RSTRING_LEN(str) == 0) ? Qnil : str;
+      }
+
+      buffer_read_size = data->buffer_used_size - data->buffer_pos;
+    }
+
+    if (req_read_size > 0 && buffer_read_size > req_read_size) {
+      buffer_read_size = req_read_size;
+    }
+
+    rb_str_cat(str, data->buffer + data->buffer_pos, buffer_read_size);
+
+    data->pos += buffer_read_size;
+    data->buffer_pos += buffer_read_size;
+    if (req_read_size > 0) {
+      req_read_size -= buffer_read_size;
+    }
+  }
+
+  return str;
+}
+
+/* ====================================================================== */
+
+void Init_smbfile(void)
+{
+  rb_cSMBFile = rb_define_class_under(rb_cSMB, "File", rb_cObject);
+  rb_define_alloc_func(rb_cSMBFile, rb_smbfile_data_alloc);
+  rb_define_method(rb_cSMBFile, "initialize", rb_smbfile_initialize, -1);
+  rb_define_method(rb_cSMBFile, "smb", rb_smbfile_smb, 0);
+  rb_define_method(rb_cSMBFile, "url", rb_smbfile_url, 0);
+  rb_define_method(rb_cSMBFile, "close", rb_smbfile_close, 0);
+  rb_define_method(rb_cSMBFile, "tell", rb_smbfile_tell, 0);
+  rb_define_alias(rb_cSMBFile, "pos", "tell");
+  rb_define_method(rb_cSMBFile, "seek", rb_smbfile_seek, 2);
+  rb_define_method(rb_cSMBFile, "rewind", rb_smbfile_rewind, 0);
+  rb_define_method(rb_cSMBFile, "eof?", rb_smbfile_eof_p, 0);
+  rb_define_method(rb_cSMBFile, "read", rb_smbfile_read, -1);
+}
+

data/lib/net/smb/version.rb

@@ -1,5 +1,5 @@
 module Net #:nodoc:
   module SMB #:nodoc:
-    VERSION = "0.0.1" #:nodoc:
+    VERSION = "0.0.2" #:nodoc:
   end
 end

data/net-smb.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["SATOH Fumiyasu"]
   s.email       = ["fumiyas@osstech.co.jp"]
   s.homepage    = "https://github.com/fumiyas/ruby-net-smb"
-  s.summary     = %q{SMB/CIFS client}
-  s.description = %q{SMB/CIFS client}
+  s.summary     = %q{SMB/CIFS client (Samba libsmbclient binding)}
+  s.description = %q{SMB/CIFS client (Samba libsmbclient binding)}
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/test/bin/smbd.wrapper

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+ENV['LC_ALL'] = 'C'
+
+command = [
+  ENV['TEST_SMBD'],
+  "--configfile=#{ENV['TEST_SMB_CONF']}",
+  "--debuglevel=#{ENV['TEST_SAMBA_DEBUGLEVEL']}",
+  "--log-basename=#{ENV['TEST_SAMBA_LOG_DIR']}",
+]
+
+if ENV['TEST_SMBD_STRACE']
+  strace = [ENV['TEST_SMBD_STRACE']]
+  strace << ENV['TEST_SMBD_STRACE_OPTIONS'] if ENV['TEST_SMBD_STRACE_OPTIONS']
+  strace << "-o#{ENV['TEST_SAMBA_LOG_DIR']}/smbd.strace.log"
+  command.unshift(*strace)
+end
+
+begin
+  Process.setsid
+rescue Errno::EPERM
+  ## This process is a process group leader already.
+end
+
+exec(*command)
+

data/test/etc/smb.conf

@@ -0,0 +1,32 @@
+[global]
+private dir = %$(TEST_SAMBA_VAR_DIR)
+lock directory = %$(TEST_SAMBA_VAR_DIR)
+state directory = %$(TEST_SAMBA_VAR_DIR)
+cache directory = %$(TEST_SAMBA_VAR_DIR)
+pid directory = %$(TEST_SAMBA_VAR_DIR)
+ncalrpc dir = %$(TEST_SAMBA_VAR_DIR)
+
+map to guest = BAD USER
+
+[template]
+path = %$(TEST_SHARE_DIR)
+writeable = yes
+guest ok = no
+
+[private]
+copy = template
+
+[public]
+copy = template
+guest ok = yes
+
+[readonly]
+copy = template
+writeable = no
+
+[共有]
+copy = template
+
+[共有フォルダー]
+copy = template
+