sse 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cacf1342bcfbfa1b2bda184e4b3429b929bbdaf0
+  data.tar.gz: b44c93e823f9e10ea98a64c5b2bf03cf124d1a7e
+SHA512:
+  metadata.gz: 5411de312e3e9b64b8ea7da6444f38452602a3a7b3f6ec5a003a6aa6e6b9143d29997bce79eeaf233d01c9dd6ada73d2a9a76ebc95fa1226bd9d933debf6d819
+  data.tar.gz: 0cf7e670f95a4ff498806cb4ad64af82ac3b7c4651da48eec7a18bf174e0ad53b82306c7a5d2e508d4adb3359a0ffe64abd100058e8c1699c721fbea9ba1df6a

data/ext/sse/extconf.rb

@@ -0,0 +1,16 @@
+require 'mkmf'
+
+[
+    'ruby.h', 'stdio.h', 'stdlib.h', 'string.h',
+    'errno.h', 'time.h', 'signal.h'
+].each { |header| abort("missing library #{header}") unless have_header(header) }
+
+[
+    'close', 'difftime', 'dup2', 'execvp',
+    'fork', 'malloc', 'pipe', 'read',
+    'realloc', 'select', 'strerror', 'strlen',
+    'strncpy', 'strtok', 'time', 'waitpid',
+    'write'
+].each { |func| abort("missing #{func}\(\)") unless have_func(func) }
+
+create_makefile('sse/sse')

data/ext/sse/sse.c

@@ -0,0 +1,214 @@
+#include <ruby.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <time.h>
+#include <signal.h>
+
+/*
+ * Module handle
+*/
+
+static VALUE sse_module;
+
+/*
+ * All exceptions for this module
+*/
+
+static VALUE sse_FileNotFoundError;
+static VALUE sse_ForkFailureError;
+static VALUE sse_PipeFailureError;
+static VALUE sse_WriteFailureError;
+static VALUE sse_ReadFailureError;
+static VALUE sse_WaitpidFailureError;
+static VALUE sse_TimeoutError;
+
+/*
+ * General utilities
+*/
+
+char **split(char *str, char *sep) {
+    char *arg = strtok(str, sep);
+    size_t arg_list_size = 1;
+    char **arg_list = malloc(sizeof(char*));
+
+    arg_list[0] = malloc(strlen(arg)+1);
+    strncpy(arg_list[0], arg, strlen(arg));
+    arg_list[0][strlen(arg)] = '\0';
+
+    while((arg = strtok(NULL, sep)) != NULL) {
+        arg_list = realloc(arg_list, (sizeof(char*))*(arg_list_size+2));
+        arg_list[arg_list_size] = malloc(strlen(arg));
+        strncpy(arg_list[arg_list_size], arg, strlen(arg));
+        arg_list[arg_list_size][strlen(arg)] = '\0';
+        ++arg_list_size;
+    }
+
+    arg_list = realloc(arg_list, (sizeof(char*))*(arg_list_size));
+    arg_list[arg_list_size] = malloc(sizeof(char*));
+    arg_list[arg_list_size] = (char*)NULL;
+
+    return arg_list;
+}
+
+/*
+ * Ruby classes and functions
+*/
+
+VALUE rb_execute_sh(VALUE self, VALUE rb_stdin, VALUE rb_timeout, VALUE rb_command) {
+    int stdin_ends[2];
+    int stdout_ends[2];
+    int stderr_ends[2];
+
+    if(pipe(stdin_ends) == -1 || pipe(stdout_ends) == -1 || pipe(stderr_ends) == -1) {
+        rb_raise(sse_PipeFailureError, "%s:%d (%d) pipe: %s\n", __FILE__, __LINE__, errno, strerror(errno));
+    }
+
+    char **command_list = split(StringValueCStr(rb_command), (char*)" ");
+    char *stdin_buf = StringValueCStr(rb_stdin);
+    pid_t pid = fork();
+
+    if(pid > 0) {
+        size_t stdout_buf_size = 0;
+        size_t stderr_buf_size = 0;
+        size_t stdout_buf_max = 1;
+        size_t stderr_buf_max = 1;
+        char *stdout_buf = malloc(1);
+        char *stderr_buf = malloc(1);
+
+        stdout_buf[0] = '\0';
+        stderr_buf[0] = '\0';
+
+        time_t start = time(NULL);
+        time_t timeout = NUM2INT(rb_timeout);
+        int sent_stdin = 0;
+
+        close(stdin_ends[0]);
+        close(stdout_ends[1]);
+        close(stderr_ends[1]);
+
+        while(difftime(time(NULL), start) < timeout) {
+            int status = waitpid(pid, NULL, WNOHANG);
+
+            if(status == -1) {
+                rb_raise(sse_WaitpidFailureError, "%s:%d (%d) waitpid: %s\n", __FILE__, __LINE__, errno, strerror(errno));
+            } else if(status == 0) {
+                fd_set write_set;
+                fd_set read_set;
+                struct timeval select_timeout = { 0, 0 };
+                int maxfd = (stdin_ends[1] > stdout_ends[0] ? (stdin_ends[1] > stderr_ends[0] ? stdin_ends[1] : stderr_ends[0]) : (stdout_ends[0] > stderr_ends[0] ? stdout_ends[0] : stderr_ends[0]));
+
+                FD_ZERO(&write_set);
+                FD_ZERO(&read_set);
+
+                if(sent_stdin == 0) {
+                    FD_SET(stdin_ends[1], &write_set);
+                }
+
+                FD_SET(stdout_ends[0], &read_set);
+                FD_SET(stderr_ends[0], &read_set);
+
+                select(maxfd+1, &read_set, &write_set, NULL, &select_timeout);
+
+                if(FD_ISSET(stdin_ends[1], &write_set)) {
+                    sent_stdin = 1;
+
+                    if(write(stdin_ends[1], stdin_buf, strlen(stdin_buf)) == -1) {
+                        rb_raise(sse_WriteFailureError, "%s:%d (%d) write: %s\n", __FILE__, __LINE__, errno, strerror(errno));
+                    }
+
+                    close(stdin_ends[1]);
+                }
+
+                if(FD_ISSET(stdout_ends[0], &read_set)) {
+                    char tmp_buf[251];
+                    ssize_t bytes_read = read(stdout_ends[0], tmp_buf, 250);
+
+                    if(bytes_read == -1) {
+                        rb_raise(sse_ReadFailureError, "%s:%d (%d) read: %s\n", __FILE__, __LINE__, errno, strerror(errno));
+                    }
+
+                    tmp_buf[bytes_read] = '\0';
+
+                    while((stdout_buf_size + bytes_read+1) >= stdout_buf_max) {
+                        stdout_buf_max *= 2;
+                        stdout_buf = realloc(stdout_buf, stdout_buf_max);
+                    }
+
+                    strncpy(stdout_buf, tmp_buf, bytes_read);
+                    stdout_buf_size += bytes_read;
+                    stdout_buf[stdout_buf_size] = '\0';
+                }
+
+                if(FD_ISSET(stderr_ends[0], &read_set)) {
+                    char tmp_buf[251];
+                    ssize_t bytes_read = read(stderr_ends[0], tmp_buf, 250);
+
+                    if(bytes_read == -1) {
+                        rb_raise(sse_ReadFailureError, "%s:%d (%d) read: %s\n", __FILE__, __LINE__, errno, strerror(errno));
+                    }
+
+                    tmp_buf[bytes_read] = '\0';
+
+                    while((stderr_buf_size + bytes_read+1) >= stderr_buf_max) {
+                        stderr_buf_max *= 2;
+                        stderr_buf = realloc(stderr_buf, stderr_buf_max);
+                    }
+
+                    strncpy(stderr_buf, tmp_buf, bytes_read);
+                    stderr_buf_size += bytes_read;
+                    stderr_buf[stderr_buf_size] = '\0';
+                }
+            } else {
+                close(stdout_ends[0]);
+                close(stderr_ends[1]);
+                VALUE result = rb_ary_new2(3);
+                rb_ary_store(result, 0, INT2NUM(difftime(time(NULL), start)));
+                rb_ary_store(result, 1, rb_str_new_cstr(stdout_buf));
+                rb_ary_store(result, 2, rb_str_new_cstr(stderr_buf));
+                return result;
+            }
+        }
+
+        kill(SIGINT, pid);
+        rb_raise(sse_TimeoutError, "Proccess took too long to finish.\n");
+    } else if(pid == 0) {
+        dup2(stdin_ends[0], STDIN_FILENO);
+        dup2(stdout_ends[1], STDOUT_FILENO);
+        dup2(stderr_ends[1], STDERR_FILENO);
+        close(stdin_ends[1]);
+        close(stdout_ends[0]);
+        close(stderr_ends[0]);
+
+        if(execvp(command_list[0], command_list) == -1) {
+            rb_raise(sse_ForkFailureError, "%s:%d (%d) execvp: %s\n", __FILE__, __LINE__, errno, strerror(errno));
+        }
+    } else {
+        rb_raise(sse_FileNotFoundError, "%s:%d (%d) execvp: %s\n", __FILE__, __LINE__, errno, strerror(errno));
+    }
+
+    VALUE thunderfury_blessed_blade_of_the_windseeker = rb_ary_new2(3);
+    rb_ary_store(thunderfury_blessed_blade_of_the_windseeker, 0, INT2NUM(42));
+    rb_ary_store(thunderfury_blessed_blade_of_the_windseeker, 1, rb_str_new_cstr("this is stdout"));
+    rb_ary_store(thunderfury_blessed_blade_of_the_windseeker, 2, rb_str_new_cstr("this is stderr"));
+    return thunderfury_blessed_blade_of_the_windseeker;
+}
+
+/*
+ * Initialize the module
+*/
+
+void Init_sse() {
+    sse_module = rb_define_module("sse");
+
+    sse_FileNotFoundError = rb_define_class_under(sse_module, "FileNotFoundError", rb_eStandardError);
+    sse_ForkFailureError = rb_define_class_under(sse_module, "ForkFailureError", rb_eStandardError);
+    sse_PipeFailureError = rb_define_class_under(sse_module, "PipeFailureError", rb_eStandardError);
+    sse_WriteFailureError = rb_define_class_under(sse_module, "WriteFailureError", rb_eStandardError);
+    sse_ReadFailureError = rb_define_class_under(sse_module, "ReadFailureError", rb_eStandardError);
+    sse_WaitpidFailureError = rb_define_class_under(sse_module, "WaitpidFailureError", rb_eStandardError);
+    sse_TimeoutError = rb_define_class_under(sse_module, "TimeoutError", rb_eStandardError);
+
+    rb_define_global_function("execute_sh", rb_execute_sh, 3);
+}

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: sse
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Nicholas Chambers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-22 00:00:00.000000000 Z
+dependencies: []
+description: A ruby gem for safe and secure execution of POSIX sh.
+email: nchambers@spookyinternet.com
+executables: []
+extensions:
+- ext/sse/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/sse/extconf.rb
+- ext/sse/sse.c
+homepage: http://spookypac.com/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Safe Shell Execution
+test_files: []