home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / code / tkern10 / src / links.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  6.2 KB  |  346 lines
  1. /*
  2.  *  This file forms part of "TKERN" - "Troy's Kernel for Windows".
  3.  *
  4.  *  Copyright (C) 1994  Troy Rollo <troy@cbme.unsw.EDU.AU>
  5.  *
  6.  *  This file is explicitly placed in the public domain. You may use it
  7.  *  it for any purpose you see fit, including, but not limited to,
  8.  *  incorperating it into a private, commercial, public domain,
  9.  *  shareware, freeware or free software work.
  10.  */
  11.  
  12.  
  13. #include <windows.h>
  14. #include <stdarg.h>
  15. #include <dos.h>
  16. #include <fcntl.h>
  17. #include <stdio.h>
  18. #include <sys/tkexec.h>
  19. #include <sys/wait.h>
  20. #include <signal.h>
  21. #include <stdlib.h>
  22.  
  23. CATCHBUF    __intr_catch_buf;
  24.  
  25. int    _creattype = O_TEXT;
  26.  
  27. extern    int    tkern_valid_file(int);
  28. extern    int    tkern_errno(void);
  29. extern    void    _init_all_files(void);
  30. extern    void    _close_all_files(void);
  31. extern    void    tkern_register_program(    int    *argc,
  32.                     char    ***argv,
  33.                     char    ***envp);
  34. extern    int    tkern_close(int);
  35. extern    int    tkern_open(char const *, int, ...);
  36. extern    int    tkern_dup(int);
  37. extern    int    tkern_dup2(int, int);
  38. extern    int    tkern_read(int, char *, int);
  39. extern    int    tkern_write(int, char const *, int);
  40. extern    long    tkern_seek(int, long, int);
  41. extern    int    tkern_isatty(int);
  42. extern    int    tkern_ioctl(int, long, void *);
  43. extern    void    tkern_register_sighandler(void far pascal (*_proc)(int));
  44. extern    int    tkern_pipe(int *pfd);
  45.  
  46. /* _exitbuf is a global which stores the location of the file flushing
  47.  * routine called by exit().
  48.  */
  49. extern    void    (*_exitbuf)(void);
  50.  
  51. /*
  52.  * The char * const * below should really be 
  53.  * char const * const *, but BC doesn't seem
  54.  * to like it.
  55.  */
  56. extern    int    tkern_exec(    char const *,
  57.                 void *,
  58.                 char * const *,
  59.                 char const *);
  60. extern short    tkern_wait(    union wait *wstatus);
  61. extern short    tkern_wait3(    union wait *wstatus,
  62.                 int    nFlags,
  63.                 struct rusage *pZero);
  64. extern short    tkern_waitpid(    int    pid,
  65.                 union wait *wstatus,
  66.                 int    nFlags);
  67. extern int    tkern_kill(    int    pid,
  68.                 int    nSignal);
  69.  
  70. extern    int    main(int, char **, char **);
  71.  
  72. CATCHBUF    fork_buf;
  73. extern    int    errno;
  74.  
  75. int    open(char const *pchPath, int nMode, int nAccess)
  76. {
  77.     int    rval;
  78.  
  79.     rval = tkern_open(pchPath, nMode, nAccess);
  80.     if (rval == -1)
  81.         errno = tkern_errno();
  82.     return rval;
  83. }
  84.  
  85. int    creat(char const *pchPath, int nAccess)
  86. {
  87.     return open(pchPath, O_WRONLY | O_CREAT | O_TRUNC | _creattype, nAccess);
  88. }
  89.  
  90. int    close(int fd)
  91. {
  92.     int    rval;
  93.  
  94.     rval = tkern_close(fd);
  95.     if (rval == -1)
  96.         errno = tkern_errno();
  97.     return rval;
  98. }
  99.  
  100.  
  101. int    read(int fd, char *pchBuffer, int nBytes)
  102. {
  103.     int    rval;
  104.  
  105.     rval = tkern_read(fd, pchBuffer, nBytes);
  106.     if (rval == -1)
  107.         errno = tkern_errno();
  108.     return rval;
  109. }
  110.  
  111. int    write(int fd, char *pchBuffer, int nBytes)
  112. {
  113.     int    rval;
  114.  
  115.     rval = tkern_write(fd, pchBuffer, nBytes);
  116.     if (rval == -1)
  117.         errno = tkern_errno();
  118.     return rval;
  119. }
  120.  
  121. int    dup(int fd)
  122. {
  123.     int    rval;
  124.  
  125.     rval = tkern_dup(fd);
  126.     if (rval == -1)
  127.         errno = tkern_errno();
  128.     return rval;
  129. }
  130.  
  131. int    dup2(int fd1, int fd2)
  132. {
  133.     int    rval;
  134.  
  135.     rval = tkern_dup2(fd1, fd2);
  136.     if (rval == -1)
  137.         errno = tkern_errno();
  138.     return rval;
  139. }
  140.  
  141. int    pipe(int *pfd)
  142. {
  143.     int    rval;
  144.  
  145.     rval = tkern_pipe(pfd);
  146.     if (rval == -1)
  147.         errno = tkern_errno();
  148.     return rval;
  149. }
  150.  
  151. long    lseek(int fd, long nPosition, int nStart)
  152. {
  153.     long    rval;
  154.  
  155.     rval = tkern_seek(fd, nPosition, nStart);
  156.     if (rval == -1)
  157.         errno = tkern_errno();
  158.     return rval;
  159. }
  160.  
  161. int    isatty(int fd)
  162. {
  163.     int    rval;
  164.  
  165.     rval = tkern_isatty(fd);
  166.     if (rval == -1)
  167.         errno = tkern_errno();
  168.     return rval;
  169. }
  170.  
  171. int
  172. ioctl(int fd, long nIOCtl, void *pvBuffer)
  173. {
  174.     int    rval;
  175.  
  176.     rval = tkern_ioctl(fd, nIOCtl, pvBuffer);
  177.     if (rval == -1)
  178.         errno = tkern_errno();
  179.     return rval;
  180. }
  181.  
  182. static    void
  183. doexec(    char    const *pchPath,
  184.     void    const *pvArgs,
  185.     char    * const *ppchEnv,
  186.     char    const *pchCmdLine)
  187. {
  188.     int    iTask;
  189.  
  190.     iTask = tkern_exec(pchPath, pvArgs, ppchEnv, pchCmdLine);
  191.     if (iTask == -1)
  192.         errno = tkern_errno();
  193.     Throw(fork_buf, iTask);
  194. }
  195.  
  196. void
  197. execl(    char const *pchPath, ...)
  198. {
  199.     va_list    args;
  200.  
  201.     va_start(args, pchPath);
  202.     doexec(pchPath, args, environ, 0);
  203. }
  204.  
  205. void
  206. execl_ext(    char const *pchCmdLine,
  207.         char const *pchPath,
  208.         ...)
  209. {
  210.     va_list    args;
  211.  
  212.     va_start(args, pchPath);
  213.     doexec(pchPath, args, environ, pchCmdLine);
  214. }
  215.  
  216. void
  217. execv(    char    const    *pchPath,
  218.     void    const    *pvArgs)
  219. {
  220.  
  221.     doexec(pchPath, pvArgs, environ, 0);
  222. }
  223.  
  224. void
  225. execv_ext(    char    const    *pchCmdLine,
  226.         char    const    *pchPath,
  227.         void    const    *pvArgs)
  228. {
  229.     doexec(pchPath, pvArgs, environ, pchCmdLine);
  230. }
  231.  
  232. short
  233. wait(union wait *wstatus)
  234. {
  235.     short    rval;
  236.  
  237.     rval = tkern_wait(wstatus);
  238.     if (rval == -1)
  239.         errno = tkern_errno();
  240.     return rval;
  241. }
  242.  
  243. short
  244. wait3(    union wait    *wstatus,
  245.     int        nFlags,
  246.     struct rusage    *pZero)
  247. {
  248.     short    rval;
  249.  
  250.     rval = tkern_wait3(wstatus, nFlags, pZero);
  251.     if (rval == -1)
  252.         errno = tkern_errno();
  253.     return rval;
  254. }
  255.  
  256. short
  257. waitpid(int    pid,
  258.     long    *wstatus,
  259.     int    nFlags)
  260. {
  261.     short    rval;
  262.  
  263.     rval = tkern_waitpid(pid, (union wait *) wstatus, nFlags);
  264.     if (rval == -1)
  265.         errno = tkern_errno();
  266.     return rval;
  267. }
  268.  
  269. int
  270. kill(    int    pid,
  271.     int    nSignal)
  272. {
  273.     int    rval;
  274.  
  275.     rval = tkern_kill(pid, nSignal);
  276.     if (rval == -1)
  277.         errno = tkern_errno();
  278.     return rval;
  279. }
  280.  
  281. void    far    pascal
  282. InterruptMe(    int    nSignal)
  283. {
  284.     typedef    void (*sigfunc)(int);
  285.     sigfunc cp;
  286.  
  287.     _DS = _SS;
  288.     switch(nSignal)
  289.     {
  290.     case SIGINT:
  291.         cp = signal(SIGINT, SIG_IGN);
  292.         if (cp == SIG_IGN)
  293.             return;
  294.         if (cp == SIG_DFL)
  295.             exit(-1);
  296.         (*cp)(2);
  297.         break;
  298.  
  299.     default:
  300.         raise(nSignal);
  301.     }
  302. }
  303.  
  304. #pragma argsused
  305. int    far        pascal
  306. WinMain(HINSTANCE    hInstance,
  307.     HINSTANCE    hPrec,
  308.     LPSTR        lpCmdLine,
  309.     int        nShow)
  310. {
  311.     int    argc;
  312.     char    **argv;
  313.     char    **envp;
  314.     int    rval;
  315.  
  316.     tkern_register_program(&argc, &argv, &envp);
  317.     tkern_register_sighandler(InterruptMe);
  318.     if (!tkern_valid_file(0) ||
  319.         !tkern_valid_file(1) ||
  320.         !tkern_valid_file(2))
  321.     {
  322.         if (tkern_valid_file(0))
  323.             tkern_close(0);
  324.         if (tkern_valid_file(1))
  325.             tkern_close(1);
  326.         if (tkern_valid_file(2))
  327.             tkern_close(2);
  328.         tkern_open("/dev/window/console", O_RDWR);
  329.         tkern_dup(0);
  330.         tkern_dup(0);
  331.     }
  332.     _init_all_files();
  333.     fdopen(0, "r");
  334.     fdopen(1, "w");
  335.     fdopen(2, "w");
  336.     _exitbuf = _close_all_files;
  337.     switch(Catch(__intr_catch_buf))
  338.     {
  339.     case 0:
  340.         rval = main(argc, argv, envp);
  341.         break;
  342.     }
  343.     exit(rval);
  344.     return -1;
  345. }
  346.