net-smb 0.0.1 → 0.0.2

data/Makefile

@@ -0,0 +1,18 @@
+default: build
+
+build: gem
+
+gem:
+	rm pkg/*.gem
+	rake build
+
+upload:
+	$(MAKE) gem
+	gem push pkg/*.gem
+
+clean:
+	rake clean
+
+distclean:
+	rake clobber
+

data/Rakefile

@@ -1,8 +1,13 @@
+begin
+  load 'Rakefile.local'
+rescue LoadError => e
+end
+
 begin
   require 'bundler/gem_tasks'
 rescue LoadError => e
-  p e
 end
+
 require 'rake/clean'
 require 'rake/testtask'
 
@@ -10,7 +15,10 @@ Rake::TestTask.new
 
 CLEAN.include('ext/**/*.{log,o,so}')
 CLEAN.include('ext/**/Makefile')
-CLOBBER.include('lib/**/*.so')
+CLEAN.include('lib/**/*.so')
+CLOBBER.include('pkg/*')
+CLOBBER.include('test/log')
+CLOBBER.include('test/log.[0-9]')
 
 EXT_PATH = 'net/smb'
 

data/Rakefile.local.example

@@ -0,0 +1,7 @@
+ENV['CFLAGS'] = '-I/usr/local/samba/include'
+ENV['LDFLAGS'] = '-L/usr/local/samba/lib -Wl,-rpath,/usr/local/samba/lib'
+
+ENV['TEST_SMBD'] = '/usr/local/samba/sbin/smbd'
+ENV['TEST_PDBEDIT'] = '/usr/local/samba/bin/pdbedit'
+#ENV['TEST_SMBD_STRACE'] = 'strace'
+#ENV['TEST_SMBD_STRACE_OPTIONS'] = '-ffttTxs9999'

data/ext/net/smb/dlinklist.h

@@ -0,0 +1,181 @@
+/* 
+   Unix SMB/CIFS implementation.
+   some simple double linked list macros
+
+   Copyright (C) Andrew Tridgell 1998-2010
+   
+   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/>.
+*/
+
+/* To use these macros you must have a structure containing a next and
+   prev pointer */
+
+#ifndef _DLINKLIST_H
+#define _DLINKLIST_H
+
+/*
+  February 2010 - changed list format to have a prev pointer from the
+  list head. This makes DLIST_ADD_END() O(1) even though we only have
+  one list pointer.
+
+  The scheme is as follows:
+
+     1) with no entries in the list:
+          list_head == NULL
+
+     2) with 1 entry in the list:
+          list_head->next == NULL
+          list_head->prev == list_head
+
+     3) with 2 entries in the list:
+          list_head->next == element2
+          list_head->prev == element2
+	  element2->prev == list_head
+	  element2->next == NULL
+
+     4) with N entries in the list:
+          list_head->next == element2
+          list_head->prev == elementN
+	  elementN->prev == element{N-1}
+	  elementN->next == NULL
+
+  This allows us to find the tail of the list by using
+  list_head->prev, which means we can add to the end of the list in
+  O(1) time
+
+
+  Note that the 'type' arguments below are no longer needed, but
+  are kept for now to prevent an incompatible argument change
+ */
+
+
+/*
+   add an element at the front of a list
+*/
+#define DLIST_ADD(list, p) \
+do { \
+        if (!(list)) { \
+		(p)->prev = (list) = (p);  \
+		(p)->next = NULL; \
+	} else { \
+		(p)->prev = (list)->prev; \
+		(list)->prev = (p); \
+		(p)->next = (list); \
+		(list) = (p); \
+	} \
+} while (0)
+
+/*
+   remove an element from a list
+   Note that the element doesn't have to be in the list. If it
+   isn't then this is a no-op
+*/
+#define DLIST_REMOVE(list, p) \
+do { \
+	if ((p) == (list)) { \
+		if ((p)->next) (p)->next->prev = (p)->prev; \
+		(list) = (p)->next; \
+	} else if ((list) && (p) == (list)->prev) {	\
+		(p)->prev->next = NULL; \
+		(list)->prev = (p)->prev; \
+	} else { \
+		if ((p)->prev) (p)->prev->next = (p)->next; \
+		if ((p)->next) (p)->next->prev = (p)->prev; \
+	} \
+	if ((p) != (list)) (p)->next = (p)->prev = NULL;	\
+} while (0)
+
+/*
+   find the head of the list given any element in it.
+   Note that this costs O(N), so you should avoid this macro
+   if at all possible!
+*/
+#define DLIST_HEAD(p, result_head) \
+do { \
+       (result_head) = (p); \
+       while (DLIST_PREV(result_head)) (result_head) = (result_head)->prev; \
+} while(0)
+
+/* return the last element in the list */
+#define DLIST_TAIL(list) ((list)?(list)->prev:NULL)
+
+/* return the previous element in the list. */
+#define DLIST_PREV(p) (((p)->prev && (p)->prev->next != NULL)?(p)->prev:NULL)
+
+/* insert 'p' after the given element 'el' in a list. If el is NULL then
+   this is the same as a DLIST_ADD() */
+#define DLIST_ADD_AFTER(list, p, el) \
+do { \
+        if (!(list) || !(el)) { \
+		DLIST_ADD(list, p); \
+	} else { \
+		(p)->prev = (el);   \
+		(p)->next = (el)->next;		\
+		(el)->next = (p);		\
+		if ((p)->next) (p)->next->prev = (p);	\
+		if ((list)->prev == (el)) (list)->prev = (p); \
+	}\
+} while (0)
+
+
+/*
+   add to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_ADD_END(list, p, type)			\
+do { \
+	if (!(list)) { \
+		DLIST_ADD(list, p); \
+	} else { \
+		DLIST_ADD_AFTER(list, p, (list)->prev); \
+	} \
+} while (0)
+
+/* promote an element to the from of a list */
+#define DLIST_PROMOTE(list, p) \
+do { \
+          DLIST_REMOVE(list, p); \
+          DLIST_ADD(list, p); \
+} while (0)
+
+/*
+   demote an element to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_DEMOTE(list, p, type)			\
+do { \
+	DLIST_REMOVE(list, p); \
+	DLIST_ADD_END(list, p, NULL);		\
+} while (0)
+
+/*
+   concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list.
+   Note that 'type' is ignored
+*/
+#define DLIST_CONCATENATE(list1, list2, type)	\
+do { \
+	if (!(list1)) { \
+		(list1) = (list2); \
+	} else { \
+		(list1)->prev->next = (list2); \
+		if (list2) { \
+			void *_tmplist = (void *)(list1)->prev; \
+			(list1)->prev = (list2)->prev; \
+			(list2)->prev = _tmplist; \
+		} \
+	} \
+} while (0)
+
+#endif /* _DLINKLIST_H */

data/ext/net/smb/rb_smb.h

@@ -0,0 +1,100 @@
+/*
+ * Ruby/Net::SMB - SMB/CIFS client (Samba libsmbclient binding) for Ruby
+ * Common header for Net::SMB
+ * 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/>.
+ */
+
+#ifndef _RB_SMB_H_
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <libsmbclient.h>
+
+#ifdef RB_SMB_DEBUG
+#  undef RB_SMB_DEBUG
+#  define RB_SMB_DEBUG(fmt, ...) \
+    do { \
+      fprintf(stdout, "%s:%s:%d ", __FILE__, __func__, __LINE__); \
+      fprintf(stdout, fmt, __VA_ARGS__); \
+      fflush(stdout); \
+    } while (0)
+#else
+#  define RB_SMB_DEBUG(fmt, ...)
+#endif
+
+#define SMBC_TRUE	((smbc_bool)1)
+#define SMBC_FALSE	((smbc_bool)0)
+
+#define TRUE_P(value)   ((value) == Qtrue)
+#define FALSE_P(value)  (NIL_P(value) || (value) == Qfalse)
+
+#define SMBC2RB_BOOL(b)   ((b) ? Qtrue : Qfalse)
+#define RB2SMBC_BOOL(v)   (TRUE_P(v) ? SMBC_TRUE : SMBC_FALSE)
+
+#define RB_SMB_NAME	"Net::SMB"
+#define RB_SMBDIR_NAME	"Net::SMB::Dir"
+#define RB_SMBFILE_NAME	"Net::SMB::File"
+
+#define RB_SMBFILE_BUFFER_SIZE 8192
+
+typedef struct rb_smb_data	RB_SMB_DATA;
+typedef struct rb_smbfile_data	RB_SMBFILE_DATA;
+
+struct rb_smbfile_data {
+  rb_encoding	*enc;
+  VALUE         smb_obj;	/* Net::SMB object */
+  RB_SMB_DATA	*smb_data;
+  SMBCCTX	*smbcctx;
+  SMBCFILE	*smbcfile;
+  char		*url;
+  int		fmode;
+  int		oflags;
+  int		eof;
+  off_t		pos;
+  char		*buffer;
+  size_t	buffer_size;
+  size_t	buffer_used_size;
+  size_t	buffer_pos;
+  RB_SMBFILE_DATA *next, *prev;
+};
+
+struct rb_smb_data {
+  rb_encoding	*enc;
+  SMBCCTX	*smbcctx;
+  VALUE		auth_callback;
+  RB_SMBFILE_DATA *smbfile_data_list;
+};
+
+#define RB_SMB_DATA_FROM_OBJ(obj, data) \
+  RB_SMB_DATA *data; \
+  Data_Get_Struct(obj, RB_SMB_DATA, data);
+
+#define RB_SMBFILE_DATA_FROM_OBJ(obj, data) \
+  RB_SMBFILE_DATA *data; \
+  Data_Get_Struct(obj, RB_SMBFILE_DATA, data);
+
+extern VALUE rb_cSMB;
+extern VALUE rb_eSMBError;
+extern VALUE rb_cSMBDir;
+extern VALUE rb_cSMBFile;
+
+void Init_smbdir(void);
+void Init_smbfile(void);
+
+#define _RB_SMB_H_
+
+#endif /* _RB_SMB_H_ */
+

data/ext/net/smb/smb.c

@@ -1,107 +1,310 @@
-#include <ruby.h>
-#include <libsmbclient.h>
+/*
+ * Ruby/Net::SMB - SMB/CIFS client (Samba libsmbclient binding) for Ruby
+ * Net::SMB 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/>.
+ */
 
-struct smbcctx {
-  SMBCCTX       *ctx;
-  VALUE         auth_callback;
-};
+#include "rb_smb.h"
+#include "dlinklist.h"
 
-#define FALSE_P(value)  (NIL_P(value) || (value) == Qfalse)
-#define TRUE_P(value)   !FALSE_P(value)
+VALUE rb_cSMB;
+VALUE rb_eSMBError;
 
-#define bool2value(b)   ((b) ? Qtrue : Qfalse)
-#define value2bool(v)   ((b) ? Qtrue : Qfalse)
+/* ====================================================================== */
 
-#define get_smbcctx(self) \
-  struct smbcctx *smbcctx; \
-  Data_Get_Struct((self), struct smbcctx, smbcctx);
+static void smbcctx_auth_fn(SMBCCTX *smbcctx,
+	const char *server, const char *share,
+	char *workgroup, int wgmaxlen,
+	char *username, int unmaxlen,
+	char *password, int pwmaxlen)
+{
+  VALUE self = (VALUE)smbc_getOptionUserData(smbcctx);
+  VALUE cred_obj;
+  VALUE workgroup_obj;
+  VALUE username_obj;
+  VALUE password_obj;
+  RB_SMB_DATA_FROM_OBJ(self, data);
 
-static VALUE eRuntimeError;
+  if (NIL_P(data->auth_callback)) {
+    return;
+  }
 
-/* ====================================================================== */
+  cred_obj = rb_funcall(data->auth_callback,
+    rb_intern("call"), 2,
+    rb_str_new2(server),
+    rb_str_new2(share));
+
+  if (TYPE(cred_obj) != T_ARRAY) {
+    rb_raise(rb_eTypeError,
+	RB_SMB_NAME
+	"#on_auth proc must return an array of username, passsword, and optional workgroup name");
+  }
+  if (RARRAY_LEN(cred_obj) < 2 || RARRAY_LEN(cred_obj) > 3) {
+    rb_raise(rb_eArgError,
+	RB_SMB_NAME
+	"#on_auth proc must return an array of username, passsword, and optional workgroup name");
+  }
 
-static void smbcctx_gc_mark(struct smbcctx *smbcctx)
+  username_obj = RARRAY_PTR(cred_obj)[0];
+  password_obj = RARRAY_PTR(cred_obj)[1];
+  workgroup_obj = (RARRAY_LEN(cred_obj) >= 3) ? RARRAY_PTR(cred_obj)[2] : Qnil;
+
+  if (!NIL_P(workgroup_obj)) {
+    SafeStringValue(workgroup_obj);
+    if (RSTRING_LEN(workgroup_obj) > wgmaxlen - 1) {
+      rb_raise(rb_eArgError, "Workgroup name too long");
+    }
+    strcpy(workgroup, RSTRING_PTR(workgroup_obj));
+  }
+  else {
+    workgroup[0] = '\0';
+  }
+  if (!NIL_P(username_obj)) {
+    SafeStringValue(username_obj);
+    if (RSTRING_LEN(username_obj) > unmaxlen - 1) {
+      rb_raise(rb_eArgError, "Username too long");
+    }
+    strcpy(username, RSTRING_PTR(username_obj));
+  }
+  else {
+    username[0] = '\0';
+  }
+  if (!NIL_P(password_obj)) {
+    SafeStringValue(password_obj);
+    if (RSTRING_LEN(password_obj) > pwmaxlen - 1) {
+      rb_raise(rb_eArgError, "Password too long");
+    }
+    strcpy(password, RSTRING_PTR(password_obj));
+  }
+  else {
+    password[0] = '\0';
+  }
+
+  RB_SMB_DEBUG("\\%s\%s %s\%s|%s\n", server, share, workgroup, username, password);
+}
+
+static void rb_smb_data_gc_mark(RB_SMB_DATA *data)
 {
-  rb_gc_mark(smbcctx->auth_callback);
+  rb_gc_mark(data->auth_callback);
 }
 
-static void smbcctx_free(struct smbcctx *smbcctx)
+static void rb_smb_data_free(RB_SMB_DATA *data)
 {
-  smbc_free_context(smbcctx->ctx, 1);
+  RB_SMBFILE_DATA *smbfile_data;
+
+  for (smbfile_data = data->smbfile_data_list; smbfile_data != NULL;
+      smbfile_data = smbfile_data->next) {
+    smbfile_data->smb_obj = Qnil;
+    smbfile_data->smb_data = NULL;
+    smbfile_data->smbcctx = NULL;
+    smbfile_data->smbcfile = NULL;
+  }
+  smbc_free_context(data->smbcctx, 1);
+
+  ruby_xfree(data);
 }
 
-static VALUE rb_smbcctx_alloc(VALUE klass)
+static VALUE rb_smb_data_alloc(VALUE klass)
 {
-  struct smbcctx *smbcctx = ALLOC(struct smbcctx);
+  VALUE data_obj;
+  RB_SMB_DATA *data = ALLOC(RB_SMB_DATA);
+  const char *home_backup = getenv("HOME");
+
+  memset(data, 0, sizeof(*data));
 
-  memset(smbcctx, 0, sizeof(struct smbcctx));
+  data_obj = Data_Wrap_Struct(klass, rb_smb_data_gc_mark, rb_smb_data_free, data);
 
-  /* FIXME: Unset $HOME to ignore $HOME/.smb/smb.conf */
-  smbcctx->ctx = smbc_new_context();
-  if (smbcctx->ctx == NULL) {
-    rb_sys_fail("Cannot create SMBCCTX");
+  /* Unset $HOME to ignore $HOME/.smb/smb.conf */
+  if (home_backup) {
+    unsetenv("HOME");
+  }
+  data->smbcctx = smbc_new_context();
+  if (home_backup) {
+    setenv("HOME", home_backup, 1);
+  }
+  if (data->smbcctx == NULL) {
+    rb_sys_fail("smbc_new_context() failed");
   }
 
-  smbcctx->auth_callback = Qnil;
+  data->auth_callback = Qnil;
 
-  return Data_Wrap_Struct(klass, smbcctx_gc_mark, smbcctx_free, smbcctx);
+  return data_obj;
 }
 
-static VALUE rb_smbcctx_initialize(VALUE self)
+static VALUE rb_smb_initialize(VALUE self)
 {
-  get_smbcctx(self);
+  RB_SMB_DATA_FROM_OBJ(self, data);
+
+  /* FIXME: Take encoding from argument */
+  /* FIXME: Read unix charset (?) from smb.conf for default encoding */
+  data->enc = rb_enc_find("UTF-8");
 
-  smbc_setDebug(smbcctx->ctx, 0);
-  smbc_setOptionDebugToStderr(smbcctx->ctx, (smbc_bool)1);
+  smbc_setDebug(data->smbcctx, 0);
+  smbc_setOptionUserData(data->smbcctx, (void *)self);
+  smbc_setOptionDebugToStderr(data->smbcctx, SMBC_TRUE);
+  smbc_setOptionNoAutoAnonymousLogin(data->smbcctx,  SMBC_TRUE);
+  smbc_setFunctionAuthDataWithContext(data->smbcctx, smbcctx_auth_fn);
+
+  if (smbc_init_context(data->smbcctx) == NULL) {
+    rb_sys_fail("smbc_init_context() failed");
+  }
 
   return self;
 }
 
-static VALUE rb_smbcctx_debug_get(VALUE self)
+static VALUE rb_smb_debug_get(VALUE self)
 {
-  get_smbcctx(self);
+  RB_SMB_DATA_FROM_OBJ(self, data);
 
-  return INT2NUM(smbc_getDebug(smbcctx->ctx));
+  return INT2NUM(smbc_getDebug(data->smbcctx));
 }
 
-static VALUE rb_smbcctx_debug_set(VALUE self, VALUE debug)
+static VALUE rb_smb_debug_set(VALUE self, VALUE debug)
 {
-  get_smbcctx(self);
+  RB_SMB_DATA_FROM_OBJ(self, data);
 
-  smbc_setDebug(smbcctx->ctx, NUM2INT(debug));
+  smbc_setDebug(data->smbcctx, NUM2INT(debug));
 
   return debug;
 }
 
-static VALUE rb_smbcctx_use_kerberos_get(VALUE self)
+static VALUE rb_smb_use_kerberos_get(VALUE self)
 {
-  get_smbcctx(self);
+  RB_SMB_DATA_FROM_OBJ(self, data);
 
-  return smbc_getOptionUseKerberos(smbcctx->ctx) ? Qtrue : Qfalse;
+  return SMBC2RB_BOOL(smbc_getOptionUseKerberos(data->smbcctx));
 }
 
-static VALUE rb_smbcctx_use_kerberos_set(VALUE self, VALUE flag)
+static VALUE rb_smb_use_kerberos_set(VALUE self, VALUE flag)
 {
-  get_smbcctx(self);
+  RB_SMB_DATA_FROM_OBJ(self, data);
 
-  smbc_setOptionUseKerberos(smbcctx->ctx, (smbc_bool)(TRUE_P(flag) ? 1 : 0));
+  smbc_setOptionUseKerberos(data->smbcctx, RB2SMBC_BOOL(flag));
 
   return flag;
 }
 
+static VALUE rb_smb_on_auth(int argc, VALUE* argv, VALUE self)
+{
+  RB_SMB_DATA_FROM_OBJ(self, data);
+
+  VALUE proc;
+  VALUE block;
+
+  if (argc == 0 && !rb_block_given_p()) {
+    rb_raise(rb_eArgError, "No block or proc given");
+  }
+  else if (argc > 0 && rb_block_given_p()) {
+    rb_raise(rb_eArgError, "Cannot use both block and proc");
+  }
+
+  rb_scan_args(argc, argv, "01&", &proc, &block);
+  if (argc == 1) {
+    data->auth_callback = proc;
+  }
+  else {
+    data->auth_callback = block;
+  }
+
+  return Qnil;
+}
+
+static VALUE rb_smb_opendir(VALUE self, VALUE url_obj)
+{
+  RB_SMB_DATA_FROM_OBJ(self, data);
+  VALUE args[2];
+  VALUE smbdir;
+
+  args[0] = self;
+  args[1] = url_obj;
+  smbdir = rb_class_new_instance(2, args, rb_cSMBDir);
+
+  RB_SMBFILE_DATA_FROM_OBJ(smbdir, smbfile_data);
+  DLIST_ADD(data->smbfile_data_list, smbfile_data);
+
+  return smbdir;
+}
+
+static VALUE rb_smb_open(int argc, VALUE *argv, VALUE self)
+{
+  RB_SMB_DATA_FROM_OBJ(self, data);
+  VALUE argv_new[argc+1];
+  VALUE smbfile;
+
+  argv_new[0] = self;
+  memcpy(argv_new + 1, argv, sizeof(*argv) * argc);
+  smbfile = rb_class_new_instance(argc+1, argv_new, rb_cSMBFile);
+
+  RB_SMBFILE_DATA_FROM_OBJ(smbfile, smbfile_data);
+  DLIST_ADD(data->smbfile_data_list, smbfile_data);
+
+  return smbfile;
+}
+
+
 /* ====================================================================== */
 
 void Init_smb(void)
 {
   VALUE rb_mNet = rb_define_module("Net");
-  VALUE rb_mSMB = rb_define_module_under(rb_mNet, "SMB");
-  VALUE rb_cSMBCCTX = rb_define_class_under(rb_mNet, "SMBCCTX", rb_cObject);
 
-  rb_define_alloc_func(rb_cSMBCCTX, rb_smbcctx_alloc);
-  rb_define_method(rb_cSMBCCTX, "initialize", rb_smbcctx_initialize, 0);
-  rb_define_method(rb_cSMBCCTX, "debug", rb_smbcctx_debug_get, 0);
-  rb_define_method(rb_cSMBCCTX, "debug=", rb_smbcctx_debug_set, 1);
+  /* Net::SMB */
+  rb_cSMB = rb_define_class_under(rb_mNet, "SMB", rb_cObject);
+  rb_define_alloc_func(rb_cSMB, rb_smb_data_alloc);
+  rb_define_method(rb_cSMB, "initialize", rb_smb_initialize, 0);
+  rb_define_method(rb_cSMB, "debug", rb_smb_debug_get, 0);
+  rb_define_method(rb_cSMB, "debug=", rb_smb_debug_set, 1);
+  rb_define_method(rb_cSMB, "use_kerberos", rb_smb_use_kerberos_get, 0);
+  rb_define_method(rb_cSMB, "use_kerberos=", rb_smb_use_kerberos_set, 1);
+  rb_define_method(rb_cSMB, "on_auth", rb_smb_on_auth, -1);
+  rb_define_alias(rb_cSMB, "on_authentication", "on_auth");
+  rb_define_method(rb_cSMB, "opendir", rb_smb_opendir, 1);
+  rb_define_method(rb_cSMB, "open", rb_smb_open, -1);
+
+  /* Net::SMB::Error */
+  rb_eSMBError = rb_define_class_under(rb_cSMB, "Error", rb_eStandardError);
+
+  const char *smbc_ver = smbc_version();
+  int smbc_ver_major = atoi(smbc_ver);
+  int smbc_ver_minor = (smbc_ver = strchr(smbc_ver, '.')) ? atoi(++smbc_ver) : 0;
+  int smbc_ver_release = (smbc_ver = strchr(smbc_ver, '.')) ? atoi(++smbc_ver) : 0;
+  long smbc_ver_number =
+      (smbc_ver_major << 16) +
+      (smbc_ver_minor << 8) +
+      smbc_ver_release;
+
+  if (smbc_ver_number <= 0x030606L) {
+    /*
+     * Hack to avoid Samba Bug 9038 - libsmbclient: SMBC_module_init()
+     * does not init global parameters if $HOME is not set
+     * https://bugzilla.samba.org/show_bug.cgi?id=9038
+     */
+    const char *home_backup = getenv("HOME");
+    /* Unset $HOME to ignore $HOME/.smb/smb.conf */
+    if (home_backup) {
+      unsetenv("HOME");
+    }
+    SMBCCTX *smbcctx = smbc_new_context();
+    if (home_backup) {
+      setenv("HOME", home_backup, 1);
+    }
+    smbc_init_context(smbcctx);
+  }
 
-  //eRuntimeError = rb_define_class_under(mSMB, "Net::SMB::RuntimeError", rb_eRuntimeError);
+  Init_smbdir();
+  Init_smbfile();
 }