src/posix/generic/Dsw/Mod/HostProcs.cp

   1 MODULE DswHostProcs;
   2
   3   IMPORT SYSTEM, DswProcs, HostLang, unistd := PosixCunistd, stdlib := PosixCstdlib,
   4     signal := PosixCsignal, sys_wait := PosixCsys_wait, macro := PosixCmacro,
   5     errno := PosixCerrno, sys_stat := PosixCsys_stat;
   6
   7   TYPE
   8     Directory = POINTER TO RECORD (DswProcs.Directory) END;
   9
  10     String = POINTER TO ARRAY OF SHORTCHAR;
  11     SString = POINTER TO ARRAY OF String;
  12
  13     Process = POINTER TO RECORD (DswProcs.Process)
  14       argv: SString;
  15       pid: unistd.pid_t;
  16       code: unistd.int;
  17     END;
  18
  19   PROCEDURE ToHost (IN s: ARRAY OF CHAR): String;
  20     VAR ss: String; res: INTEGER;
  21   BEGIN
  22     NEW(ss, LEN(s$) * 3 + 1);
  23     ASSERT(ss # NIL, 100);
  24     HostLang.StringToHost(s, ss, HostLang.pep383x, res);
  25     ASSERT(res = 0, 101);
  26     RETURN ss
  27   END ToHost;
  28
  29   PROCEDURE IsRegular (mode: sys_stat.mode_t): BOOLEAN;
  30   BEGIN
  31     RETURN BITS(mode) * BITS(sys_stat.S_IFMT) = BITS(sys_stat.S_IFREG)
  32   END IsRegular;
  33
  34   PROCEDURE (d: Directory) New* (): Process;
  35     VAR p: Process;
  36   BEGIN
  37     NEW(p); p.argv := NIL; p.pid := -1; p.code := 0;
  38     RETURN p
  39   END New;
  40
  41   PROCEDURE (d: Directory) GetPath (IN name: ARRAY OF CHAR): DswProcs.String;
  42     VAR
  43       ch: CHAR;
  44       v: POINTER [untagged] TO ARRAY [untagged] OF SHORTCHAR;
  45       s, e, ret: POINTER TO ARRAY OF CHAR;
  46       w: String;
  47       cres: sys_stat.int;
  48       i, j, k, len, res: INTEGER;
  49       buf: sys_stat.struct_stat;
  50       found: BOOLEAN;
  51   BEGIN
  52     v := stdlib.getenv("PATH");
  53     IF v # NIL THEN
  54       NEW(s, LEN(v$) * 3 + 1);
  55       HostLang.HostToString(v$, s, HostLang.pep383x, res);
  56       ASSERT(res = 0, 100);
  57       len := LEN(name$);
  58       NEW(e, LEN(s$) + len + 2);
  59       i := 0;
  60       REPEAT
  61         j := -1; found := FALSE;
  62         REPEAT ch := s[i]; INC(i); INC(j); e[j] := ch UNTIL (ch = ":") OR (ch = 0X);
  63         IF e[0] = "/" THEN
  64           e[j] := "/"; INC(j);
  65           FOR k := 0 TO len DO
  66             e[j + k] := name[k]
  67           END;
  68           e[j + k] := 0X;
  69           w := ToHost(e);
  70           cres := macro.stat(w, buf);
  71           found := (cres = 0) & IsRegular(buf.st_mode) & (unistd.access(w, unistd.X_OK) = 0)
  72         END
  73       UNTIL found OR (ch = 0X);
  74       IF ~found THEN e := NIL END
  75     END;
  76     RETURN e
  77   END GetPath;
  78
  79   PROCEDURE (p: Process) Program* (IN exe: ARRAY OF CHAR);
  80     VAR argv: SString;
  81   BEGIN
  82     ASSERT(p.pid = -1, 20);
  83     NEW(argv, 1); argv[0] := ToHost(exe);
  84     p.argv := argv
  85   END Program;
  86
  87   PROCEDURE (p: Process) PutParam* (IN par: ARRAY OF CHAR);
  88     VAR i: INTEGER; argv: SString;
  89   BEGIN
  90     ASSERT(p.pid = -1, 20);
  91     ASSERT(p.argv # NIL, 21);
  92     NEW(argv, LEN(p.argv) + 1);
  93     FOR i := 0 TO LEN(p.argv) - 1 DO
  94       argv[i] := p.argv[i]
  95     END;
  96     argv[i] := ToHost(par);
  97     p.argv := argv
  98   END PutParam;
  99
 100   PROCEDURE (p: Process) Execute* (OUT ok: BOOLEAN);
 101     TYPE
 102       UString = POINTER [untagged] TO ARRAY [untagged] OF SHORTCHAR;
 103       SUString = POINTER TO ARRAY OF UString;
 104     VAR
 105       i, j: INTEGER; pid: unistd.pid_t; res: unistd.int; argv: SUString;
 106   BEGIN
 107     ASSERT(p.pid = -1, 20);
 108     ASSERT(p.argv # NIL, 21);
 109     NEW(argv, LEN(p.argv) + 1);
 110     FOR i := 0 TO LEN(p.argv) - 1 DO
 111       argv[i] := SYSTEM.VAL(UString, SYSTEM.ADR(p.argv[i, 0]))
 112     END;
 113     pid := unistd.fork();
 114     IF pid = 0 THEN
 115       res := unistd.execv(argv[0], argv);
 116       unistd._exit(127); (* system() and most utils exit with 126/127 *)
 117       ok := FALSE
 118     ELSIF pid = -1 THEN
 119       ok := FALSE
 120     ELSE
 121       p.argv := NIL; (* or save it for debugging and reuse? *)
 122       p.pid := pid;
 123       ok := TRUE
 124     END
 125   END Execute;
 126
 127   PROCEDURE (p: Process) Terminate* (OUT ok: BOOLEAN);
 128     VAR res, e: signal.int;
 129   BEGIN
 130     ASSERT(p.pid > 0, 20);
 131     res := signal.kill(p.pid, signal.SIGTERM);
 132     IF res = 0 THEN p.Wait; ok := TRUE
 133     ELSIF res = -1 THEN
 134       e := macro.errno();
 135       CASE e OF
 136       | errno.EINVAL: HALT(100) (* wat *)
 137       | errno.EPERM: ok := FALSE (* process can not be killed *)
 138       | errno.ESRCH: p.code := 0; p.pid := -1; ok := TRUE (* process already killed *)
 139       END
 140     ELSE HALT(101) (* wat *)
 141     END
 142   END Terminate;
 143
 144   PROCEDURE (p: Process) IsTerminated* (): BOOLEAN;
 145     VAR pid: unistd.pid_t; e: unistd.int;
 146   BEGIN
 147     IF p.pid # -1 THEN
 148       ASSERT(p.pid > 0, 100); (* wat *)
 149       pid := sys_wait.waitpid(p.pid, p.code, sys_wait.WNOHANG);
 150       IF pid = 0 THEN (* process still executes *)
 151       ELSIF pid = p.pid THEN p.pid := -1 (* process returns code *)
 152       ELSIF pid = -1 THEN
 153         e := macro.errno();
 154         CASE e OF
 155         | errno.ECHILD: p.code := 0; p.pid := -1 (* process was killed externally *)
 156         | errno.EINVAL: HALT(101) (* wat *)
 157         | errno.EINTR: (* assume that process still executes *)
 158         END
 159       ELSE HALT(102) (* wat *)
 160       END
 161     END;
 162     RETURN p.pid = -1
 163   END IsTerminated;
 164
 165   PROCEDURE (p: Process) Wait*;
 166     VAR pid: unistd.pid_t; e: unistd.int;
 167   BEGIN
 168     ASSERT(p.pid > 0, 20);
 169     REPEAT
 170       pid := sys_wait.waitpid(p.pid, p.code, 0);
 171       IF pid = p.pid THEN p.pid := -1 (* was terminated *)
 172       ELSIF pid = -1 THEN
 173         e := macro.errno();
 174         CASE e OF
 175         | errno.ECHILD: p.code := 0; p.pid := -1 (* process was killed externally *)
 176         | errno.EINVAL: HALT(100) (* wat *)
 177         | errno.EINTR: (* continue wait for process termination *)
 178         END
 179       ELSE HALT(101) (* wat *)
 180       END
 181     UNTIL p.pid = -1
 182   END Wait;
 183
 184   PROCEDURE (p: Process) Result (): INTEGER;
 185   BEGIN
 186     IF p.pid # -1 THEN p.Wait END;
 187     (* RETURN SYSTEM.CONV(INTEGER, sys_wait.WEXITSTATUS(p.code)) *) (* !!! *)
 188     RETURN SYSTEM.VAL(INTEGER, p.code) DIV 256 MOD 128
 189   END Result;
 190
 191   PROCEDURE Init;
 192     VAR d: Directory;
 193   BEGIN
 194     NEW(d); DswProcs.SetDir(d)
 195   END Init;
 196
 197 BEGIN
 198   Init
 199 END DswHostProcs.