home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / bts314b4 / b_spawn.c < prev    next >
C/C++ Source or Header  |  1994-01-08  |  12KB  |  474 lines
  1. /*--------------------------------------------------------------------------*/
  2. /*                                                                          */
  3. /*                                                                          */
  4. /*      ------------         Bit-Bucket Software, Co.                       */
  5. /*      \ 10001101 /         Writers and Distributors of                    */
  6. /*       \ 011110 /          Freely Available<tm> Software.                 */
  7. /*        \ 1011 /                                                          */
  8. /*         ------                                                           */
  9. /*                                                                          */
  10. /*  (C) Copyright 1987-90, Bit Bucket Software Co., a Delaware Corporation. */
  11. /*                                                                          */
  12. /*                                                                          */
  13. /*            This module was originally written by Bob Hartman             */
  14. /*                                                                          */
  15. /*                                                                          */
  16. /*                        BinkleyTerm "Spawn" module                        */
  17. /*                                                                          */
  18. /*                                                                          */
  19. /*    For complete  details  of the licensing restrictions, please refer    */
  20. /*    to the License  agreement,  which  is published in its entirety in    */
  21. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.240.    */
  22. /*                                                                          */
  23. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  24. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  25. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  26. /*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  27. /*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  28. /*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
  29. /*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  30. /*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
  31. /*                                                                          */
  32. /*                                                                          */
  33. /* You can contact Bit Bucket Software Co. at any one of the following      */
  34. /* addresses:                                                               */
  35. /*                                                                          */
  36. /* Bit Bucket Software Co.        FidoNet  1:104/501, 1:132/491, 1:141/491  */
  37. /* P.O. Box 460398                AlterNet 7:491/0                          */
  38. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  39. /*                                Internet f491.n132.z1.fidonet.org         */
  40. /*                                                                          */
  41. /* Please feel free to contact us at any time to share your comments about  */
  42. /* our software and/or licensing policies.                                  */
  43. /*                                                                          */
  44. /*--------------------------------------------------------------------------*/
  45.  
  46. #include <stdio.h>
  47. #include <time.h>
  48. #include <stdlib.h>
  49. #ifndef LATTICE
  50. #include <process.h>
  51. #endif    /* LATTICE */
  52. #include <string.h>
  53.  
  54. #ifdef __TOS__
  55. #include <ext.h>
  56. #else
  57. #include <dos.h>
  58. #endif    /* __TOS__ */
  59.  
  60. #ifdef OS_2
  61. #define  INCL_DOS
  62. #include <os2.h>
  63. #endif    /* OS_2 */
  64.  
  65. #if defined(__TURBOC__)
  66. #if !defined(__TOS__)
  67. #include <dir.h>
  68. #include <mem.h>
  69. #endif    /* __TOS__ */
  70.  
  71. #elif defined(LATTICE)
  72. #include <string.h>
  73. #include <dos.h>
  74.  
  75. #else    /* !(LATTICE or TURBOC) */
  76. #include <direct.h>
  77. #include <memory.h>
  78. #endif    /* __TURBOC */
  79.  
  80. #include "bink.h"
  81. #include "msgs.h"
  82. #include "sbuf.h"
  83. #include "com.h"
  84. #include "vfossil.h"
  85.  
  86. #if defined(ATARIST)
  87.  
  88. #if !defined(__TURBOC__)
  89.  
  90.     /* This is "borrowed" from the Turbo C include file "TOS.H" */
  91.  
  92.     typedef struct        /* used by Pexec */
  93.     {
  94.         unsigned char    length;
  95.         char            command_tail[128];
  96.     } COMMAND;
  97.  
  98. #endif    /* __TURBOC__ */
  99.  
  100.  
  101. #if defined(LATTICE)
  102.   #include <basepage.h>
  103.   extern BASEPAGE *_pbase;
  104.   #define environment _pbase->p_env
  105. #elif defined(__TURBOC__)
  106.   #define environment _BasPag->p_env
  107. #endif    /* __TURBOC__ */
  108.  
  109.  
  110. #if defined(__PUREC__) || defined(__TURBOC__)
  111.  
  112. char *CLIcommand = NULL;
  113. BOOLEAN useCLIcommand = FALSE;
  114.  
  115. /*
  116.  * Replacement system() function to duplicate the Lattice one
  117.  *
  118.  * Now also uses the new configuration option CLIcommand
  119.  */
  120.  
  121. typedef int cdecl (* fn)(const char *);
  122.  
  123. #define _shellp ((long *)(0x4f6L))
  124.  
  125. int system(const char *command)
  126. {
  127.     long ssp;
  128.     fn func;
  129.     char *prog;
  130.     char *extra;
  131.     
  132.     /* See if there is a resident shell */
  133.     ssp = Super(NULL);
  134.     func = (fn)*_shellp;
  135.     Super((void *)ssp);
  136.     if(func)
  137.         return (*func)(command);
  138.     prog = getenv("SHELL");
  139.     if(prog)
  140.         extra = "-c";
  141.     else
  142.     {
  143.         prog = getenv("COMSPEC");
  144.         if(prog)
  145.             extra = "/c";
  146.     }
  147.     if(prog)    
  148.     {
  149.         int result, error;
  150.         char *com;
  151.         size_t len;
  152.         
  153.         if(useCLIcommand)
  154.             extra = CLIcommand;
  155.  
  156.         len = strlen(command) + 1;
  157.         if(extra)
  158.             len += strlen(extra) + 1;
  159.         com = malloc(len);
  160.         com[0] = 0;
  161.         if(!com)
  162.             return -1;
  163.         if(extra)
  164.         {
  165.             strcpy(com, extra);
  166.             strcat(com, " ");
  167.         }
  168.         strcat(com, command);
  169.             
  170.         error = exec(prog, com, environment, &result);
  171.         free(com);
  172.         if(error)
  173.             return -1;
  174.         else
  175.             return result;
  176.     }
  177.     return -1;
  178. }
  179.  
  180.  
  181. #endif    /* __PUREC__ */
  182.  
  183. /*
  184.  * Execute a shell or program
  185.  */
  186.  
  187. long b_spawn( char *cmd_str )
  188. {
  189.     /* Some of this is by Enno Borgsteede */
  190.     
  191.    char this_dir[160];
  192.    char *comspec;
  193.    char cmd_line[160];
  194.    COMMAND par;
  195.    char *p, *p1;
  196.    long ret;
  197.  
  198.    getcwd (this_dir,79);
  199.  
  200.    if (cmd_str)
  201.    {
  202.         /* If extended is .PRG .TOS .TTP then use Pexec otherwise system() */
  203.  
  204.         strncpy(cmd_line, cmd_str, 79);
  205.         cmd_line[79] = 0;
  206.         p = strtok(cmd_line, " \t");    /* 1st token is the command name */
  207.         if(p && (p1 = strrchr(p, '.')) != NULL)
  208.         {
  209.             strupr(p);
  210.             if( (strcmp(p1, ".PRG") == 0) ||
  211.                 (strcmp(p1, ".TOS") == 0) ||
  212.                 (strcmp(p1, ".TTP") == 0) )
  213.             {
  214.                 if(strcmp(p1, ".PRG") == 0)        /* Its a GEM program */
  215.                     Cconws("\033f");
  216.                 p1 = strtok(NULL, "\n");
  217.                 if(p1)
  218.                 {
  219.                     strcpy(par.command_tail, p1);
  220.                     par.length = strlen(p1);
  221.                 }
  222.                 else
  223.                 {
  224.                     par.command_tail[0] = 0;
  225.                     par.length = 0;
  226.                 }
  227. #ifdef LATTICE
  228.                 ret = Pexec(0, cmd_line, (char *)&par, environment);
  229. #else
  230.                 ret = Pexec(0, cmd_line, &par, environment);
  231. #endif
  232.                 goto done;
  233.             }
  234.         }
  235.         ret = system(cmd_str);
  236.    }
  237.    else
  238.    {
  239.         if ((( comspec = getenv ("COMSPEC")) != NULL ) || (( comspec = getenv("SHELL"))) != NULL )
  240.             ret = Pexec(0, comspec, "\0", environment);
  241.    }
  242. done:
  243.    chgdsk (*this_dir - 'A');
  244.    chdir (this_dir);
  245.    
  246.    return ret;
  247. }
  248.  
  249.  
  250. #else    /* !ATARIST */
  251.  
  252.  
  253. long b_spawn (cmd_str)
  254. char *cmd_str;
  255. {
  256.  
  257. #if defined(OS_2)
  258.  
  259.    char this_dir[80];
  260.    char *comspec;
  261.    
  262.    getcwd (this_dir,79);
  263.    if (cmd_str)
  264.       system (cmd_str);
  265.    else
  266.       {
  267.       if (comspec = getenv ("COMSPEC"))
  268.          spawnlp (P_WAIT, comspec, comspec, NULL);
  269.       }
  270.    DosSelectDisk (*this_dir - 'A' + 1);
  271.    chdir (this_dir);
  272.  
  273. #elif defined(ATARIST)
  274.  
  275.    char this_dir[80];
  276.    char *comspec;
  277. #ifdef PEXEC
  278.    char cmd_line[80];
  279.    COMMAND par;
  280.    char *p;
  281. #endif
  282.    
  283.    getcwd (this_dir,79);
  284.    if (cmd_str) {
  285. #ifdef PEXEC
  286.         strcpy( cmd_line, cmd_str);
  287.         strtok( cmd_line, " \t");
  288.         strupr( cmd_line);
  289.         if (strstr( cmd_line, ".PRG")) Cconws( "\033f");
  290.         p = strtok( NULL, "\n");
  291.         if (p) {
  292.             strcpy( par.command_tail, p);
  293.             par.length = strlen( p);
  294.         } else {
  295.             par.command_tail[0] = 0;
  296.             par.length = 0;
  297.         }
  298.         Pexec( 0, cmd_line, &par, _BasPag->p_env);
  299. #else    /* !PEXEC */
  300.       system (cmd_str);
  301. #endif
  302.    } else {
  303.       if (comspec = getenv ("COMSPEC"))
  304.          Pexec(0, comspec, "\0", NULL);
  305.       }
  306.    chgdsk (*this_dir - 'A');
  307.    chdir (this_dir);
  308.  
  309. #else    /* Not ATARIST or OS2 */
  310.  
  311.    char *p, *p1;
  312.    char **envp, *env, *save, **vp;
  313.    char this_dir[80];
  314.    int ecount;
  315.    /* unsigned j; */
  316.  
  317.    /* Save where we are */
  318.    (void) fflush (status_log);
  319.    (void) real_flush (fileno (status_log));
  320.    need_update = 0;
  321.  
  322.    (void) getcwd (this_dir, 79);
  323.  
  324.    if ((p = getenv ("COMSPEC")) == NULL)
  325.       p = "COMMAND.COM";
  326.  
  327.    if (swapdir == NULL)
  328.       {
  329.       if (cmd_str != NULL)
  330.          (void) system (cmd_str);
  331.       else
  332.          (void) spawnlp (P_WAIT, p, p, NULL);
  333.       }
  334.    else
  335.       {
  336.       /*
  337.        * The following lines are really wierd.  Basically, we need to
  338.        * pass a valid environment to DOS when we do the spawn.  Unfortunately,
  339.        * it is very likely that we have changed the environment (like when
  340.        * we alter the prompt), and therefore we have to make yet another
  341.        * copy of it, and make sure it can be paragraph aligned.  We pass the
  342.        * offset in paragraph format so it can just be added to the DS in
  343.        * order to get the actual paragraph location.
  344.        */
  345.       ecount = 0;
  346.       envp = environ;
  347.  
  348.       /* Count the chars in the environment */
  349.       for (vp = envp; *vp; ecount += (int) strlen (*vp++) + 1)
  350.          ;
  351.  
  352.       /* Add some fudge for nulls, etc */
  353.       ecount += 5;
  354.  
  355.       /* Allocate space for a copy of the environment to be para aligned */
  356.       save = env = malloc ((size_t) (ecount + 15));
  357.  
  358.       /* Align on a paragraph boundary - yucky, but it works */
  359.       *((unsigned int *)&env) = (*((unsigned int *)&env)+0xf) & (~0xf);
  360.  
  361.       p1 = env;
  362.  
  363.       /* Copy old environment to the new */
  364.       for (vp = envp; *vp; vp++)
  365.          p1 = strchr(strcpy(p1, *vp), '\0') + 1;
  366.       *p1++ = '\0';
  367.       *p1++ = '\0';
  368.  
  369.       /* Now actually call our code that does the swapping */
  370.       swapper (p, swapdir, (int) strlen (cmd_str), cmd_str, ((unsigned) (env)) >> 4);
  371.  
  372.       /* Free the stuff we allocated */
  373.       free (save);
  374.       }
  375.  
  376.    /* Go back to the proper directory */
  377. #ifdef __TURBOC__
  378.    setdisk ((unsigned) (this_dir[0] - 'A'));
  379. #else /* __TURBOC__ */
  380.    _dos_setdrive ((unsigned) ((int) this_dir[0] - 'A' + 1), &j);
  381. #endif
  382.    (void) chdir (this_dir);
  383.  
  384. #endif /* OS_2 */
  385.  
  386.     return 0;
  387. }
  388.  
  389. #endif    /* ATARIST */
  390.  
  391.  
  392.  
  393. /*
  394.  * popup window to execute command directly
  395.  *
  396.  * x=0 : from mailer
  397.  * x=1 : from terminal
  398.  */
  399.  
  400. do_shell(SAVEP p, int x)
  401. {
  402.     REGIONP r;
  403.     char cmd[80];
  404.     
  405.     if ( x )
  406.     {
  407.     }
  408.     
  409.     if(p)
  410.     {
  411.         r = p->region;
  412.  
  413.  
  414.         sb_fill (r, ' ', colors.popup);
  415.  
  416.         /* Now draw the box */
  417.  
  418.            sb_box (r, boxtype, colors.popup);
  419.            sb_move (r, 0, 1);
  420.            sb_puts (r, (unsigned char *) msgtxt[M_DO_SHELL]);
  421.  
  422.         /* Now do the fields */
  423.  
  424.         if (!sb_input_chars (r, 1, 2, cmd, 70, FALSE))
  425.         {
  426. #ifdef NEW
  427.             if(p)                /* Remove popup box */
  428.                 sb_restore(p);
  429. #endif
  430. #ifdef NEW
  431.             status_line ("%s '%s'", msgtxt[M_SHELLING], cmd);
  432. #endif
  433.             set_prior(4);
  434.             mdm_init (modem_busy);
  435.             exit_DTR ();
  436.             set_prior(2);
  437.             if (fullscreen)
  438.                 screen_clear ();
  439.             vfossil_cursor (1);
  440.             close_up ();
  441.             change_prompt ();
  442.  
  443.             if(cmd[0])
  444.             {
  445.                 b_spawn (cmd);
  446.                 cputs(msgtxt[M_ANYKEY]);
  447.                 READKB();
  448.             }
  449.             else
  450.             {
  451.             shellout:
  452.                 cputs (msgtxt[M_TYPE_EXIT]);
  453.                 b_spawn(NULL);
  454.             }
  455.  
  456.             come_back ();
  457.             set_up_outbound ();
  458.             set_prior(4);                                         /* Always High */
  459.             DTR_ON ();
  460.             mdm_init (modem_init);
  461.             reinit_ctr = reinit_time;
  462. #ifdef NEW
  463.             status_line (msgtxt[M_BINKLEY_BACK]);
  464. #endif
  465.             set_prior(2);                                         /* Regular */
  466.             return 1;
  467.         }
  468.     }
  469.     else
  470.         goto shellout;
  471.     return 0;
  472. }
  473.  
  474.