home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / dd2.zip / DDEXEC.C < prev    next >
C/C++ Source or Header  |  1995-01-14  |  12KB  |  436 lines
  1.  
  2. #define INCL_DOSSESMGR
  3. #define INCL_DOSMISC
  4. #define INCL_DOSQUEUES
  5. #define INCL_DOSPROCESS
  6. #define INCL_DOSERRORS
  7. #define INCL_DOSNDDIPES
  8.  
  9. #include <os2.h>
  10.  
  11. #include <string.h>
  12. #include <stdio.h>
  13. #include <io.h>
  14.  
  15. #include "ddexec.h"
  16. #include "dd.h"
  17.  
  18. APIRET RedirPgm(PDDEXEC pDDExec, PCHAR szExe, PCHAR szInput,
  19.    ULONG lFlags);
  20.  
  21.  
  22. APIRET ddExec(PSZ pszTitle, PSZ pszExe, PSZ pszArgs, PPID pPid, PTID pTid,
  23.    PDDEXEC pDDExec, ULONG lFlags)
  24. {
  25.  
  26. #define CMD_FILE          0
  27. #define NOT_WINDOWABLE    1
  28. #define EXE_WINDOWABLE    2
  29. #define PM_WINDOWABLE     3
  30.  
  31.    APIRET      rc = 0;
  32.    ULONG       flFlag;
  33.    RESULTCODES ResultCodes;
  34.    ULONG       sid;
  35.    PCHAR       pch;
  36.    PHQUEUE     phQueue;
  37.    ULONG       ulExecFlags;
  38.    CHAR        szInput    [MAXPATH];
  39.    CHAR        szExe      [MAXPATH];
  40.    CHAR        szArgs     [MAXPATH];
  41.    STARTDATA   SessionData;
  42.  
  43.    if (pDDExec) {
  44.       phQueue = (PHQUEUE) &pDDExec->hQueue;
  45.       *phQueue = 0;
  46.    } else {
  47.       phQueue = NULL;
  48.    }
  49. //   phQueue  = pVoid;
  50.    *pPid    = 0;
  51.    *pTid    = 0;
  52.  
  53. //   if (*phQueue) {
  54. //      ddExec(pszTitle, pszExe, pszArgs, pPid, pTid, pVoid, lFlags);
  55. //   }
  56.  
  57.    strcpy(szExe, pszExe);
  58.  
  59.    if (!strpbrk(szExe, "\\:")) {
  60.       flFlag = SEARCH_IGNORENETERRS |
  61.                SEARCH_CUR_DIRECTORY |
  62.                SEARCH_ENVIRONMENT,
  63.       strcpy(szArgs, "PATH");
  64.    } else {
  65.       pch = strrchr(szExe, '\\');
  66.       if (pch) {
  67.          pch++;
  68.          strncpy(szArgs, szExe, (unsigned) (pch - szExe));
  69.          szArgs[pch - szExe] = 0;
  70.       } else {
  71.          pch = strrchr(szExe, ':');
  72.          pch++;
  73.          strncpy(szArgs, szExe, (unsigned) (pch - szExe));
  74.          szArgs[pch - szExe] = 0;
  75.       }
  76.       strcpy(szExe, pch);
  77.       flFlag = 0;
  78.    }
  79.    if (!strstr(szExe, ".")) {
  80.       strcat(szExe, ".EXE");
  81.    }
  82.  
  83.    rc = DosSearchPath(flFlag, szArgs, szExe, szInput, MAXPATH);
  84.    if (rc) {
  85.       return rc;
  86.    }
  87.    strcpy(szExe, szInput);
  88.  
  89.  
  90.    if (lFlags & EXEC_DETACHED ||
  91.        lFlags & EXEC_REDIR    ||
  92.        lFlags & EXEC_SILENT) {
  93.       strcpy(szInput, szExe);
  94.       strcpy(&szInput[strlen(szInput) + 1], pszArgs);
  95.  
  96.       if (lFlags & EXEC_REDIR) {
  97.          rc = RedirPgm(pDDExec, szExe, szInput, lFlags);
  98.          if (rc) {
  99.             return rc;
  100.          }
  101.       }
  102.       if (lFlags & EXEC_TRACED) {
  103.          ulExecFlags  = EXEC_TRACE; //ASYNCRESULTDB;
  104.  
  105.       } else {
  106.          if (lFlags & EXEC_DETACHED) {
  107.             ulExecFlags  = EXEC_BACKGROUND;
  108.          } else {
  109.             ulExecFlags  = EXEC_ASYNCRESULT;
  110.          }
  111.  
  112.       } 
  113.  
  114.       rc = DosExecPgm(szInput, MAXPATH,
  115.          ulExecFlags, szInput, NULL, &ResultCodes, szExe);
  116.       if (!rc) {
  117.          *pPid = ResultCodes.codeTerminate;
  118.       }
  119.  
  120.    } else {
  121.  
  122.       SessionData.PgmTitle    = pszTitle;
  123.  
  124.       DosQAppType((PSZ) szExe, &flFlag);
  125.  
  126.       flFlag &= 3;
  127.  
  128.       switch (flFlag) {
  129.       case NOT_WINDOWABLE:
  130.       case EXE_WINDOWABLE:
  131.       case PM_WINDOWABLE:
  132.         SessionData.PgmName     = szExe;
  133.         SessionData.SessionType = (USHORT) flFlag;
  134.         SessionData.PgmInputs   = pszArgs;
  135.         break;
  136.        
  137.       case CMD_FILE:
  138.         SessionData.PgmName     = 0;   /* Use CMD.EXE             */
  139.         SessionData.SessionType = EXE_WINDOWABLE;
  140.  
  141.         strcpy(szInput, "/C ");        /* Auto Close after ending */
  142.         strcat(szInput, szExe);
  143.         strcat(szInput, " ");
  144.         strcat(szInput, pszArgs);
  145.         SessionData.PgmInputs   = szInput;
  146.         break;
  147.  
  148.       default:
  149.         SessionData.PgmName     = "";
  150.         SessionData.SessionType = EXE_WINDOWABLE;
  151.  
  152.         strcpy(szInput, "/C ");
  153.         strcat(szInput, pszArgs);
  154.         SessionData.PgmInputs   = szInput;
  155.         break;
  156.       }
  157.  
  158.       SessionData.Length      = 50;
  159.  
  160.       if (lFlags & EXEC_RELATED) {
  161.          SessionData.Related     = 1;   /* 1 related  */
  162.       } else {
  163.          SessionData.Related     = 0;   /* 0 independent */
  164.       }
  165.  
  166.       if (lFlags & EXEC_FULLSCR) {
  167.          SessionData.SessionType = 1;
  168.       }
  169.  
  170.       if (lFlags & EXEC_FOREGRD) {
  171.          SessionData.FgBg        = 0;      /* 0 foreground        */
  172.       } else {
  173.          SessionData.FgBg        = 1;      /* 1 background        */
  174.       }
  175.  
  176.       if (lFlags & EXEC_TRACED) {
  177.          SessionData.TraceOpt    = 1;      /* 1 trace             */
  178.          SessionData.Related     = 1;      /* 1 related           */
  179. //         lFlags |= EXEC_TERMQ;
  180.          SessionData.FgBg        = 0;      /* 0 foreground        */
  181.       } else {
  182.          SessionData.TraceOpt    = 0;      /* 0 no trace          */
  183.       }
  184.  
  185.       if (lFlags & EXEC_REDIR) {
  186.          if (flFlag == PM_WINDOWABLE) {
  187.             return ERROR_NOT_SUPPORTED;
  188.          }
  189.          if (SessionData.PgmInputs  == pszArgs) {
  190.             strcpy(szInput, pszArgs);
  191.             SessionData.PgmInputs  = szInput;
  192.          }
  193.          rc = RedirPgm(pDDExec, szExe, szInput, lFlags);
  194.          if (rc) {
  195.             return rc;
  196.          }
  197.          SessionData.InheritOpt  = 1;   // 0 inherit Shell - 1 calling process
  198.          SessionData.Related     = 1;   // 1 related
  199.  
  200.       } else {
  201.          SessionData.InheritOpt  = 0;   // 0 inherit Shell - 1 calling process
  202.       }
  203.  
  204.       if (lFlags & EXEC_INHERIT) {
  205.          SessionData.InheritOpt  = 1;   // 0 inherit Shell - 1 calling process
  206.       } else {
  207.          SessionData.InheritOpt  = 0;   // 0 inherit Shell - 1 calling process
  208.       }
  209.  
  210.       SessionData.Environment = NULL;
  211.       SessionData.IconFile    = NULL;   /* pszIncon                              */
  212.  
  213.       if (lFlags & EXEC_TERMQ) {
  214.  
  215.          PTIB         pTib;
  216.          PPIB         pPib;
  217.          CHAR        szTermQ[32];
  218.  
  219.  
  220.          DosGetInfoBlocks(&pTib, &pPib);
  221.          sprintf(szTermQ, "\\QUEUES\\EXECPROG\\%li", pPib->pib_ulpid);
  222.  
  223.          SessionData.TermQ       = szTermQ;
  224.  
  225.          SessionData.Related     = 1;      /* 1 related                              */
  226.  
  227.          if (!pDDExec) {
  228.             rc = ERROR_MON_BUFFER_TOO_SMALL;
  229.             return rc;
  230.          }
  231.          rc = DosCreateQueue(phQueue, 0, szTermQ);
  232.  
  233.       } else {
  234.          SessionData.TermQ       = NULL;   /* pszTermQueue                          */
  235.       }
  236.  
  237.       SessionData.PgmHandle   = 0;
  238.       SessionData.PgmControl  = 0;
  239.       SessionData.InitXPos    = 0;
  240.       SessionData.InitYPos    = 0;
  241.       SessionData.InitXSize   = 0;
  242.       SessionData.InitYSize   = 0;
  243.  
  244.       if (!rc) {
  245.          rc = DosStartSession((PSTARTDATA) &SessionData, &sid, pPid);
  246.          if (rc == ERROR_SMG_START_IN_BACKGROUND && !SessionData.FgBg) {
  247.             rc = 0;
  248.          }
  249.       }
  250.  
  251.    }
  252.    if (lFlags & EXEC_REDIR) {
  253.       rc = RedirPgm(pDDExec, NULL, NULL, lFlags);
  254.    } 
  255.  
  256.    if (!rc && (lFlags & EXEC_TRACED)) {
  257.       rc = DDbug(*pPid, pDDExec, pTid, lFlags, szExe);
  258.    }
  259.  
  260.  
  261.    return rc;
  262. }
  263.  
  264. APIRET RedirPgm(PDDEXEC pDDExec, PCHAR szExe, PCHAR szInput, ULONG lFlags)
  265. {
  266. #define STDIN  0
  267. #define STDOUT 1
  268. #define STDERR 2
  269.    APIRET   rc;
  270. //   CHAR     sz1[256];
  271. //   CHAR     sz2[256];
  272. /*
  273.    HFILE    hStdin  = STDIN;
  274.    HFILE    hStdout = STDOUT;
  275.    HFILE    hStderr = STDERR;
  276. */
  277.    HFILE    Stdin;
  278.    HFILE    Stdout;
  279.    HFILE    Stderr;
  280.  
  281.    lFlags = 0;
  282.    rc     = 0;
  283.    if (!pDDExec) {
  284.       rc = ERROR_MON_BUFFER_TOO_SMALL;
  285.       return rc;
  286.    }
  287.    if (szExe) {
  288.       phStdin  = 0xFFFF;
  289.       phStdout = 0xFFFF;
  290.       phStderr = 0xFFFF;
  291.       Stdin    = STDIN;
  292.       Stdout   = STDOUT;
  293.       Stderr   = STDERR;
  294.       rc = DosDupHandle(Stdin,  &phStdin);
  295.       rc = DosDupHandle(Stdout, &phStdout);
  296.       rc = DosDupHandle(Stderr, &phStderr);
  297.       if (!(rc = DosCreatePipe(&phPipe1Read, &phPipe1Write, SIZE_PIPE)) &&
  298.           !(rc = DosCreatePipe(&phPipe2Read, &phPipe2Write, SIZE_PIPE)) &&
  299.           !(rc = DosCreatePipe(&phPipe3Read, &phPipe3Write, SIZE_PIPE))) {
  300.  
  301.          rc = DosClose(Stdin);
  302.          rc = DosClose(Stdout);
  303.          rc = DosClose(Stderr);
  304.  
  305.          rc = DosDupHandle(phPipe1Read,  &Stdin);
  306.          rc = DosDupHandle(phPipe2Write, &Stdout);
  307.          rc = DosDupHandle(phPipe3Write, &Stderr);
  308.  
  309.          rc = DosClose(phPipe1Read);
  310.          rc = DosClose(phPipe2Write);
  311.          rc = DosClose(phPipe3Write);
  312.  
  313.          phPipeStdin  = phPipe1Write;
  314.          phPipeStdout = phPipe2Read;
  315.          phPipeStderr = phPipe3Read;
  316.       }
  317.    } else {
  318.       return rc;
  319.  
  320.    }
  321.    return rc;
  322. }
  323.  
  324. /*
  325.       hPipe1Write = hPipeStdin;
  326.       hPipe2Read  = hPipeStdout;
  327.       hPipe3Read  = hPipeStderr;
  328.  
  329.       hPipeStdin  = 0xFFFF;
  330.       hPipeStdout = 0xFFFF;
  331.       hPipeStderr = 0xFFFF;
  332.       rc = DosDupHandle(hPipe1Write,  &hPipeStdin);
  333.       rc = DosDupHandle(hPipe2Read,   &hPipeStdout);
  334.       rc = DosDupHandle(hPipe3Read,   &hPipeStderr);
  335.       rc = DosClose(hPipe1Write);
  336.       rc = DosClose(hPipe2Read);
  337.       rc = DosClose(hPipe3Read);
  338.  
  339.       Stdin  = STDIN;
  340.       Stdout = STDOUT;
  341.       Stderr = STDERR;
  342.       rc = DosClose(Stdin);
  343.       rc = DosClose(Stdout);
  344.       rc = DosClose(Stderr);
  345.       rc = DosDupHandle(hStdin,  &Stdin);
  346.       rc = DosDupHandle(hStderr, &Stdout);
  347.       rc = DosDupHandle(hStderr, &Stderr);
  348.  
  349.       rc = DosClose(hStdin);
  350.       rc = DosClose(hStdout);
  351.       rc = DosClose(hStderr);
  352.  
  353.    } else {
  354.       phStdin  = 0xFFFF;
  355.       phStdout = 0xFFFF;
  356.       phStderr = 0xFFFF;
  357.       Stdin    = STDIN;
  358.       Stdout   = STDOUT;
  359.       Stderr   = STDERR;
  360.       rc = DosDupHandle(Stdin,  &phStdin);
  361.       rc = DosDupHandle(Stdout, &phStdout);
  362.       rc = DosDupHandle(Stderr, &phStderr);
  363.       if (!(rc = DosCreatePipe(&phPipe1Read, &phPipe1Write, SIZE_PIPE)) &&
  364.           !(rc = DosCreatePipe(&phPipe2Read, &phPipe2Write, SIZE_PIPE)) &&
  365.           !(rc = DosCreatePipe(&phPipe3Read, &phPipe3Write, SIZE_PIPE))) {
  366.  
  367.          rc = DosClose(Stdin);
  368.          rc = DosClose(Stdout);
  369.          rc = DosClose(Stderr);
  370.  
  371.          rc = DosDupHandle(phPipe1Read,  &Stdin);
  372.          rc = DosDupHandle(phPipe2Write, &Stdout);
  373.          rc = DosDupHandle(phPipe3Write, &Stderr);
  374.  
  375.          rc = DosClose(phPipe1Read);
  376.          rc = DosClose(phPipe2Write);
  377.          rc = DosClose(phPipe3Write);
  378.  
  379.          phPipeStdin  = phPipe1Write;
  380.          phPipeStdout = phPipe2Read;
  381.          phPipeStderr = phPipe3Read;
  382.  
  383.          if (lFlags & EXEC_SILENT) {
  384.             Stdin  = -1;
  385.             Stdout = -1;
  386.             Stderr = -1;
  387.             rc = DosDupHandle(STDIN,  &Stdin);
  388.             rc = DosDupHandle(STDOUT, &Stdout);
  389.             rc = DosDupHandle(STDERR, &Stderr);
  390.  
  391.             hStdin  = STDIN;
  392.             hStdout = STDOUT;
  393.             hStderr = STDERR;
  394.             rc = DosDupHandle(hPipe1Read,  &hStdin);
  395.             rc = DosDupHandle(hPipe2Write, &hStdout);
  396.             rc = DosDupHandle(hPipe3Write, &hStderr);
  397.  
  398.  
  399.          } else {
  400.            if (phPipe1Read < 10 && phPipe2Write < 10) {
  401.                rc = DosClose(phPipe3Read);
  402.                rc = DosClose(phPipe3Write);
  403.                if (lFlags & EXEC_DETACHED) {
  404.                   strcpy(sz1, szExe);
  405.                   strcpy(sz2, &szInput[strlen(szInput) + 1]);
  406.                   strcpy(szExe, "C:\\OS2\\CMD.EXE");
  407.  
  408.                   strcpy(szInput, szExe);
  409.                   sprintf(&szInput[strlen(szInput) + 1],
  410.                      "0<&%i 1>&%i 2>&%i",
  411.                      hPipe1Read, hPipe1Write, hPipe2Write);
  412.    
  413.                } else {
  414.                   strcpy(sz1, szExe);
  415.                   strcpy(sz2, szInput);
  416.                   strcpy(szExe, "C:\\OS2\\CMD.EXE");
  417.                   sprintf(szInput, "/C 0<&%i 2>&%i 1>&%i %s %s",
  418.                      hPipe1Read, hPipe1Write, hPipe2Write, sz1, sz2);
  419.                }
  420.                printf("\n%s %s\n", szExe, szInput);
  421.    
  422.                hPipeStdout = hPipe2Read;
  423.                hPipeStdin  = hPipe1Write;
  424.    
  425.             } else {
  426.                rc = ERROR_TOO_MANY_OPEN_FILES;
  427.             }
  428.  
  429.          } 
  430.       }
  431.    }
  432.  
  433.    return rc;
  434. }
  435. */
  436.