posix 0.0.0 → 0.0.1

data/ext/posix/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+dir_config('posix/posix')
+create_makefile('posix/posix')

data/ext/posix/posix.c

@@ -0,0 +1,146 @@
+#include <ruby.h>
+#include <ruby/st.h>
+#include <errno.h>
+#include <signal.h>
+#include <unistd.h>
+
+void Init_posix(void);
+static VALUE rb_hash_keys(VALUE hash);
+
+#define RB_POSIX_SIG_BLOCK SIG_BLOCK
+#define RB_POSIX_SIG_UNBLOCK SIG_UNBLOCK
+#define RB_POSIX_SIG_SETMASK SIG_SETMASK
+
+int rb_Sigset2sigset_t(VALUE rb_Sigset, sigset_t *sigset) {
+    int i;
+    VALUE signals;
+
+
+    sigemptyset(sigset);
+    signals = rb_iv_get(rb_Sigset, "@signals");
+
+    for (i = 0; i < RARRAY_LEN(signals); i++) {
+        sigaddset(sigset, FIX2INT(RARRAY_PTR(signals)[i]));
+    }
+    return 0;
+}
+
+/* @see man 2 sigprocmask
+ *
+ * Doesn't accept a third argument, instead returns the new set
+ */
+
+VALUE posix_sigprocmask(VALUE self, VALUE _how, VALUE _set) {
+    int how;
+    sigset_t *set;
+    sigset_t *oset = NULL; // TODO, storage for returnvalue
+
+    how = FIX2INT(_how);
+
+    if (_set == Qnil) {
+        set = NULL;
+    } else {
+        set = malloc(sizeof(sigset_t));
+        rb_Sigset2sigset_t(_set, set);
+    }
+
+    sigemptyset(set);
+    sigaddset(set, SIGINT);
+
+    if (sigprocmask(how, set, oset) == 0) {
+        // TODO Construct a Sigset and return it so that we can interrogate it
+
+        if(set)
+            free(set);
+        return Qtrue;
+    } else {
+        if(set)
+            free(set);
+        rb_raise(rb_eException, "%s", strerror(errno));
+    }
+}
+
+/* Export an argv that does sane, reasonable things instead of doing weird
+ * shit.
+ *
+ * Return value is largely irrelevant
+ */
+VALUE posix_execve(VALUE self, VALUE _binary, VALUE _argv, VALUE _envp) {
+    /* Iterators */
+    int i;
+    VALUE akey, keys, envk;
+
+    /* Binary to load in the new process */
+    char* binary = StringValueCStr(_binary);
+
+    /* Construct our new process' argv. Onus is on
+     * the programmer to set ARGV[0] to something
+     * reasonable. */
+    char** argv = malloc(sizeof(char*)*RARRAY_LEN(_argv) + 1);
+
+    for (i = 0; i < RARRAY_LEN(_argv); i++) {
+        argv[i] = StringValuePtr(RARRAY_PTR(_argv)[i]);
+        argv[i+1] = NULL; /* Ensure that we're null terminated */
+    }
+
+    /* Construct our environment. Note that this totally ignores the precedent
+     * set by Process#spawn, Kernel#exec and fiends */
+
+    fprintf(stderr, "Allocatin' some memory\n");
+    char **envp = malloc(sizeof(char**)*RHASH(_envp)->ntbl->num_entries + 1);
+    fprintf(stderr, "Allocated some memory\n");
+    i = 0;
+
+    keys = rb_hash_keys(_envp);
+    for (i = 0; i < RARRAY_LEN(keys); i++) {
+        akey = RARRAY_PTR(keys)[i];
+        envk = rb_hash_aref(_envp, akey);
+        fprintf(stderr, "printin' some stringz");
+        asprintf(&envp[i], "%s=%s", StringValuePtr(akey), StringValuePtr(envk));
+        fprintf(stderr, "printed some stringz");
+        envp[i+1] = NULL; /* Ensure that we're null terminated */
+    }
+    fprintf(stderr,"%s", envp[0]);
+
+    binary = "/bin/bash";
+    char *__envp[] = { NULL };
+    char *__argv[] = { "/bin/bash", NULL };
+    execve(binary, argv, envp);
+    fprintf(stderr, "Error: %s", strerror(errno));
+}
+
+void Init_posix(void) {
+    /* Create ::Posix */
+    VALUE klass = rb_define_class("Posix", rb_cObject);
+
+    /* Define constants */
+    rb_define_const(klass, "SIG_BLOCK", INT2FIX(RB_POSIX_SIG_BLOCK));
+    rb_define_const(klass, "SIG_UNBLOCK", INT2FIX(RB_POSIX_SIG_UNBLOCK));
+    rb_define_const(klass, "SIG_SETMASK", INT2FIX(RB_POSIX_SIG_SETMASK));
+
+    /* Method binding */
+    rb_define_singleton_method(klass, "sigprocmask", posix_sigprocmask, 2);
+    rb_define_singleton_method(klass, "execve", posix_execve, 3);
+}
+
+
+// Shamelessly stolen from hash.c
+static int
+keys_i(VALUE key, VALUE value, VALUE ary)
+{
+        rb_ary_push(ary, key);
+        return ST_CONTINUE;
+}
+
+static VALUE
+rb_hash_keys(VALUE hash)
+{
+    VALUE ary;
+
+    ary = rb_ary_new();
+    rb_hash_foreach(hash, keys_i, ary);
+
+    return ary;
+}
+
+

data/lib/posix/sigset.rb

@@ -0,0 +1,22 @@
+class Posix
+  class Sigset
+
+    def initialize
+      @signals = []
+    end
+
+    def <<(signal)
+      case signal
+      when String
+        signal = Signal.list[signal]
+      end
+
+      @signals << signal unless include? signal
+    end
+
+    def include?(signal)
+      @signals.include? signal
+    end
+
+  end
+end

data/lib/posix.rb

@@ -0,0 +1,5 @@
+require 'posix/posix'
+
+Dir["#{File.expand_path("../posix/", __FILE__)}/*"].each do |file|
+  require file
+end

data/posix.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = "posix"
-  s.version     = "0.0.0"
+  s.version     = "0.0.1"
   s.authors     = ["Richo Healey"]
   s.email       = ["richo@psych0tik.net"]
   s.homepage    = "http://github.com/richo/ruby-posix"
@@ -16,8 +16,8 @@ Gem::Specification.new do |s|
   #s.add_development_dependency "rspec"
 
   s.files         = `git ls-files`.split("\n")
+  s.extensions    = ['ext/posix/extconf.rb']
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: posix
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -15,10 +15,15 @@ description: Wrappers for some posix functions that I couldn't find in the stdli
 email:
 - richo@psych0tik.net
 executables: []
-extensions: []
+extensions:
+- ext/posix/extconf.rb
 extra_rdoc_files: []
 files:
 - README.md
+- ext/posix/extconf.rb
+- ext/posix/posix.c
+- lib/posix.rb
+- lib/posix/sigset.rb
 - posix.gemspec
 homepage: http://github.com/richo/ruby-posix
 licenses: []