added dynamic resolution of executables

Author: MrBlaTi

TODO

@@ -1 +1,14 @@
-falls sysopen nicht zu viel code ist, rüberkopieren und tiny_io als dep für beide plattformen verwenden
+funktion zum auflösen eines relativen pfad auf einen absoluten pafd. sowohl für unix als auch für windows. "inspiration" von cruby holen
+
+https://github.com/ruby/ruby/blob/202bbda2bf5f25343e286099140fb9282880ecba/dln_find.c
+dln_find_exe_r
+
+wenn fertig eingebunden und getestet seb schreiben, damit der pull request schreiben kann..
+
+mruby-io
+grundsätzlich mruby-io auf einen ähnlichen stand bringen wie mruby process, heisst alles das, was noch nicht für windows funktioniert, für windows zum funktionieren bringen
+wenn bei mruby-io als dependency mruby-process drin ist, das auf unseren mruby-process fork windows branch ändern.
+
+pipes, den sysopenmock den ich gemacht habe
+
+für die CI systeme configurieren

src/dln.c

@@ -0,0 +1,291 @@
+
+#include "mruby.h"
+#define dln_warning mrb_warn
+#define dln_warning_arg
+
+//#include "dln.h"
+
+#include <stdlib.h>
+#include <strings.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#if defined(_WIN32)
+//#include "missing/file.h"
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifndef S_ISDIR
+#   define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#endif
+
+
+
+
+// TODO makros weg, wrong usage. blergh
+#ifndef PATH_ENV
+#define PATH_ENV "path"
+#endif
+#ifndef PATH_SEP
+#define PATH_SEP ";"
+#endif
+
+#if !defined(_WIN32) && !HAVE_DECL_GETENV
+char *getenv();
+#endif
+
+static char *dln_find_1(const char *fname, const char *path, char *buf, size_t size, int exe_flag /*DLN_FIND_EXTRA_ARG_DECL*/);
+char* dln_find_exe_r(const char *fname, const char *path, char *buf, size_t size /*DLN_FIND_EXTRA_ARG_DECL*/);
+char* dln_find_file_r(const char *fname, const char *path, char *buf, size_t size /*	DLN_FIND_EXTRA_ARG_DECL*/);
+
+
+
+char*
+dln_find_exe_r(const char *fname, const char *path, char *buf, size_t size /*DLN_FIND_EXTRA_ARG_DECL*/)
+{
+ 	char *envpath = 0;
+  	if (!path) {
+    	path = getenv(PATH_ENV);
+	  	if (path)
+      		path = envpath = strdup(path);
+  	}
+
+  	if (!path) {
+		path =
+	    	"/usr/local/bin" PATH_SEP
+	     	"/usr/ucb" PATH_SEP
+	     	"/usr/bin" PATH_SEP
+	     	"/bin" PATH_SEP
+	     	".";
+  	}
+  	buf = dln_find_1(fname, path, buf, size, 1 /*DLN_FIND_EXTRA_ARG*/);
+  	if (envpath)
+  		free(envpath);
+	return buf;
+}
+
+char *
+dln_find_file_r(const char *fname, const char *path, char *buf, size_t size
+/*DLN_FIND_EXTRA_ARG_DECL*/)
+{
+    if (!path) path = ".";
+    return dln_find_1(fname, path, buf, size, 0 /*DLN_FIND_EXTRA_ARG*/);
+}
+
+static char *
+dln_find_1(const char *fname, const char *path, char *fbuf, size_t size,
+	   int exe_flag /* non 0 if looking for executable. */
+   /*DLN_FIND_EXTRA_ARG_DECL*/)
+{
+	register const char *dp;
+    register const char *ep;
+    register char *bp;
+    struct stat st;
+    size_t i, fnlen, fspace;
+
+
+#ifdef DOSISH
+    static const char extension[][5] = {
+	EXECUTABLE_EXTS,
+    };
+    size_t j;
+    int is_abs = 0, has_path = 0;
+    const char *ext = 0;
+#endif
+
+
+
+    const char *p = fname;
+
+    static const char pathname_too_long[] = "openpath: pathname too long (ignored)\n\
+\tDirectory \"%.*s\"%s\n\tFile \"%.*s\"%s\n";
+/*#define PATHNAME_TOO_LONG() dln_warning(dln_warning_arg pathname_too_long, \
+					((bp - fbuf) > 100 ? 100 : (int)(bp - fbuf)), fbuf, \
+					((bp - fbuf) > 100 ? "..." : ""), \
+					(fnlen > 100 ? 100 : (int)fnlen), fname, \
+					(fnlen > 100 ? "..." : ""))*/
+
+#define RETURN_IF(expr) if (expr) return (char *)fname;
+
+    RETURN_IF(!fname);
+    fnlen = strlen(fname);
+    if (fnlen >= size) {
+		/*dln_warning(dln_warning_arg
+		    "openpath: pathname too long (ignored)\n\tFile \"%.*s\"%s\n",
+		    (fnlen > 100 ? 100 : (int)fnlen), fname,
+		    (fnlen > 100 ? "..." : ""));*/
+		return NULL;
+    }
+
+
+#ifdef DOSISH
+# ifndef CharNext
+# define CharNext(p) ((p)+1)
+# endif
+# ifdef DOSISH_DRIVE_LETTER
+    if (((p[0] | 0x20) - 'a') < 26  && p[1] == ':') {
+		p += 2;
+		is_abs = 1;
+    }
+# endif
+    switch (*p) {
+      case '/': case '\\':
+		is_abs = 1;
+		p++;
+    }
+    has_path = is_abs;
+    while (*p) {
+		switch (*p) {
+	  		case '/': case '\\':
+	    		has_path = 1;
+	    		ext = 0;
+	    		p++;
+	    		break;
+	  		case '.':
+			    ext = p;
+	    		p++;
+	    		break;
+	  		default:
+	    		p = CharNext(p);
+		}
+    }
+    if (ext) {
+		for (j = 0; STRCASECMP(ext, extension[j]); ) {
+	    	if (++j == sizeof(extension) / sizeof(extension[0])) {
+				ext = 0;
+				break;
+	    	}
+		}
+    }
+    ep = bp = 0;
+	printf("returned at  %s", "something?");
+    if (!exe_flag) {
+		printf("returned at  %s", "exe_flag?");
+		RETURN_IF(is_abs);
+		printf("nope\n");
+    }
+    else if (has_path) {
+		printf("returned at  %s", "if ext?");
+		RETURN_IF(ext);
+		printf("nope\n");
+		i = p - fname;
+		if (i + 1 > size) goto toolong;
+		fspace = size - i - 1;
+		bp = fbuf;
+		ep = p;
+		printf("ep is here %s\n", ep);
+		memcpy(fbuf, fname, i + 1);
+		goto needs_extension;
+    }
+    p = fname;
+#endif
+
+
+    if (*p == '.' && *++p == '.') ++p;
+    RETURN_IF(*p == '/');
+    RETURN_IF(exe_flag && strchr(fname, '/'));
+
+#undef RETURN_IF
+
+    for (dp = path;; dp = ++ep) {
+		register size_t l;
+
+		/* extract a component */
+		ep = strchr(dp, PATH_SEP[0]);
+		if (ep == NULL){
+	    	ep = dp+strlen(dp);
+		}
+		/* find the length of that component */
+		l = ep - dp;
+		bp = fbuf;
+		fspace = size - 2;
+		if (l > 0) {
+		    /*
+		    **	If the length of the component is zero length,
+		    **	start from the current directory.  If the
+		    **	component begins with "~", start from the
+		    **	user's $HOME environment variable.  Otherwise
+		    **	take the path literally.
+		    */
+		    if (*dp == '~' && (l == 1 ||
+#if defined(DOSISH)
+				       dp[1] == '\\' ||
+#endif
+				       dp[1] == '/')) {
+
+		   	   	char *home;
+
+				home = getenv("HOME");
+				if (home != NULL) {
+			    	i = strlen(home);
+			    	if (fspace < i)
+					goto toolong;
+			    	fspace -= i;
+			    	memcpy(bp, home, i);
+			    	bp += i;
+				}
+				dp++;
+				l--;
+		    }
+		    if (l > 0) {
+				if (fspace < l)
+			    	goto toolong;
+				fspace -= l;
+				memcpy(bp, dp, l);
+				bp += l;
+		    }
+
+		    /* add a "/" between directory and filename */
+		    if (ep[-1] != '/')
+				*bp++ = '/';
+		}
+
+		/* now append the file name */
+		i = fnlen;
+		if (fspace < i) {
+	  		toolong:
+	    	printf("Pathname is too long \n" );//PATHNAME_TOO_LONG();
+	    	goto next;
+		}
+		fspace -= i;
+		memcpy(bp, fname, i + 1);
+
+#if defined(DOSISH)
+		if (exe_flag && !ext) {
+	  		needs_extension:
+	    	for (j = 0; j < sizeof(extension) / sizeof(extension[0]); j++) {
+				if (fspace < strlen(extension[j])) {
+		    		PATHNAME_TOO_LONG();
+		    		continue;
+				}
+				strlcpy(bp + i, extension[j], fspace);
+				if (stat(fbuf, &st) == 0){
+		    		return fbuf;
+				}
+	    	}
+	    	goto next;
+		}
+#endif
+
+#ifndef S_ISREG
+# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#endif
+		if (stat(fbuf, &st) == 0 && S_ISREG(st.st_mode)) {
+	    	if (exe_flag == 0){
+		 		return fbuf;
+			}
+	    /* looking for executable */
+	    if (access(fbuf, X_OK) == 0) return fbuf;
+		}
+      	next:
+	/* if not, and no other alternatives, life is bleak */
+		if (*ep == '\0') {
+	    	return NULL;
+		}
+
+	/* otherwise try the next component in the search path */
+    }
+}

src/internal.c

@@ -27,6 +27,7 @@
 #include "mruby/hash.h"
 #include "mruby/array.h"
 #include "mruby/string.h"
+#include "dln.c"
 
 
 
@@ -86,6 +87,7 @@ mrb_execarg_fill(mrb_state *mrb, mrb_value env, mrb_value *argv, mrb_int argc, m
     char **result;
     char *shell;
     const char *tCmd;
+	char fbuf[/*MAXPATHLEN*/80]; // TODO
     mrb_value argv0 = mrb_nil_value();
 
     ai   = mrb_gc_arena_save(mrb);
@@ -112,9 +114,13 @@ mrb_execarg_fill(mrb_state *mrb, mrb_value env, mrb_value *argv, mrb_int argc, m
         argc   = 3;
         result = (char **)mrb_malloc(mrb, sizeof(char *) * (argc + 1));
 
+
+
+
+
     #if defined(__APPLE__) || defined(__linux__)
         shell = getenv("SHELL");
-        if (!shell) shell = strdup("/bin/sh");
+        if (!shell) shell = strdup(dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf)));
         result[1] = strdup("-c");
     #else
         shell = getenv("ComSpec");
@@ -129,7 +135,7 @@ mrb_execarg_fill(mrb_state *mrb, mrb_value env, mrb_value *argv, mrb_int argc, m
 
 #if defined(__APPLE__) || defined(__linux__)
     if (result[0][0] != '/') {
-        argv0 = mrb_str_new(mrb, "/bin/", 5);
+        argv0 = mrb_str_new(mrb, "/bin/", 5); //TODO redundand?
     }
 #else
     if (result[0][1] != ':') {

src/process.c

@@ -27,6 +27,7 @@
 #include "mruby/error.h"
 
 #include "internal.c"
+
 #include "status.c"
 #include "signal.c"
 

test/process.rb

@@ -138,7 +138,7 @@ def assert_windows(*args, &block)
   assert_equal var, read('tmp/spawn.txt')
 end
 
-# TODO: More tests for edge cases!
+# TODO: More tests for edge cases! whatif no valid pipe,
 assert('Process.spawn', 'pipe') do
   begin
     var = ENV['RAND']
@@ -159,6 +159,18 @@ def assert_windows(*args, &block)
   end
 end
 
+assert('Process.spawn', 'pipe error') do
+  begin
+    pip = IO.sysopen('tmp/pipe_error.txt', 'w')
+    pid = spawn("ls -asdw", err: pip)
+
+    wait_for_pid(pid)
+    assert_equal "ls: option requires an argument -- 'w'\nTry 'ls --help' for more information.", read('tmp/pipe_error.txt')
+  ensure
+    IO._sysclose(pip) if OS.posix?
+  end
+end
+
 assert('Process.exec', 'invalid signatures') do
   assert_raise(ArgumentError) { exec }
   assert_raise(TypeError)     { exec 123 }