home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / dd2.zip / DDM.C < prev    next >
C/C++ Source or Header  |  1995-01-19  |  13KB  |  448 lines
  1. //#define INCL_DOSFILEMGR
  2. #define INCL_DOSMODULEMGR
  3. #include <os2.h>
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8.  
  9.  
  10. #include "ddexec.h"
  11. #include "ddi.h"
  12.  
  13. int   ParseArgs    (int * pcArg, int argc, char * argv[], PSZ pszExe, PSZ pszMap,
  14.                     PULONG peip, PULONG plFlag, PDDEXEC pDDExec);
  15.  
  16. void  CrashTest    (ULONG ul);
  17. void  CrashTest2   (ULONG ul);
  18. void  Usage        (PSZ psz, PSZ pszFlag);
  19.  
  20.  
  21. int main(int argc, char *argv[]);
  22.  
  23. int main(int argc, char *argv[])
  24. {
  25.    APIRET rc;
  26.    CHAR   szMap[256];
  27.    PSZ    pszArgs = szMap;
  28.    ULONG  lFlag;
  29.    ULONG  ulEIP;
  30.    CHAR   sz   [1024];
  31.    LIB    lib;
  32.    int    cArg;
  33.    int    cLib = 0;
  34.    int    cBytes;
  35.    ULONG  cSource;
  36.    ULONG  cFunction;
  37.    ULONG  cLine;
  38.    ULONG  lddFlag = EXEC_TRACED | EXEC_WAIT | EXEC_FOREGRD | EXEC_INHERIT;
  39.    PID    pid;
  40.    TID    tid;
  41.    DDEXEC DDExec;
  42. //   ULONG  Void;
  43.  
  44.  
  45.    setvbuf(stdout, NULL, _IONBF, 0);
  46.    cArg          = 1;
  47.    lFlag         = 0;
  48.    cSource       = 0;
  49.    cFunction     = 0;
  50.    cLine         = 0;
  51.    cBytes        = 0;
  52.    lib.sz[0]     = 0;
  53.    DDExec.pszDDD = NULL;
  54.  
  55.    while (ParseArgs(&cArg, argc, argv, lib.sz, szMap, &ulEIP, &lFlag, &DDExec)) {
  56.       if (lFlag & DDI_DDI) {
  57.          if (lFlag & DDI_BUILD) {
  58.             if (DdiBuild(lib.sz, szMap, &lib.pDdi, lFlag)) {
  59.  
  60.                strcpy(sz, lib.sz);
  61.                if (lFlag & DDI_WRITEDDI) {
  62.                   Extention(sz, ".ddI");
  63.                } 
  64.                DdiWrite(sz, lib.pDdi);
  65.                DdiFree(lib.pDdi);
  66.             }
  67.          }
  68.          if (lFlag & DDI_SHOW) {
  69.             DdiRead(1, &lib, DDI_READASYNC);
  70.             DdiRead(1, &lib, DDI_READSYNC);
  71.             if (lib.pDdi) {
  72.                cLib++;
  73.                printf("\n     %-32s", lib.sz);
  74.                cBytes += DdiShow(lib.pDdi, lFlag, &cSource, &cFunction,
  75.                   &cLine);
  76.                DdiFree(lib.pDdi);
  77.             }
  78.          }
  79.          if (lFlag & DDI_MAP) {
  80.             DdiRead(1, &lib, DDI_READASYNC);
  81.             DdiLineInfo(1, &lib, ulEIP, sz, DDI_MAP);
  82.             if (*sz) {
  83.                printf("\nEIP %08lX (%lu) maps to %s\n%s", 
  84.                   ulEIP, ulEIP, lib.sz, sz);
  85.             }
  86.             DdiFree(lib.pDdi);
  87.          }
  88.          if (lFlag & DDI_MOVEDEBUGINFO) {
  89.             if (!DdiHeader(DDI_MOVEDEBUGINFO, &lib, sz)) {
  90.                printf("\n%s", sz);
  91.             }
  92.          }
  93.          if (lFlag & DDI_ADDDEBUGINFO) {
  94.             if (!DdiHeader(DDI_ADDDEBUGINFO, &lib, sz)) {
  95.                printf("\n%s", sz);
  96.             }
  97.          }
  98.          if (lFlag & DDI_DROPDEBUGINFO) {
  99.             if (!DdiHeader(DDI_DROPDEBUGINFO, &lib, sz)) {
  100.                printf("\n%s", sz);
  101.             }
  102.          }
  103.          if (lFlag & DDI_CRASHTEST) {
  104.             CrashTest(0);
  105.          } 
  106.  
  107.       } else {
  108.          if (lFlag & DDI_DDD) {
  109.            DDExec.pszDDD = szMap;
  110.          } 
  111.  
  112.          lddFlag |= (lFlag & 0xF0000000);
  113.  
  114.          sprintf(sz, "dd %s", lib.sz);
  115.          rc = ddExec(sz, lib.sz, pszArgs, &pid, &tid, &DDExec, lddFlag);
  116.          if (rc) {
  117.             printf("\nCould not execute %s, rc = %u.", lib.sz, rc);
  118.          }
  119.       }
  120.  
  121.       lib.sz[0] = 0;
  122.       lib.pDdi  = NULL;
  123.    }
  124.  
  125.    if (lFlag & DDI_DDI && lFlag & DDI_SHOW && cLib > 1) {
  126.       printf("\n\n     %-32s%5i Bytes", "Totals", cBytes);
  127.       printf("\n%-5i Module%s",            cLib,      cLib      == 1 ? "" : "s");
  128.       printf("\n%-5i Source%s",            cSource,   cSource   == 1 ? "" : "s");
  129.       printf("\n%-5i Function%s",          cFunction, cFunction == 1 ? "" : "s");
  130.       printf("\n%-5i Statement%s %s",      cLine,     cLine     == 1 ? "" : "s",
  131.          cLine > 0 ? "or more" : "");
  132.    }
  133.  
  134. #ifdef DUMP_ALLOC
  135.    printf("\n");
  136.    _dump_allocated(79);
  137. #endif
  138.  
  139.    return 0;
  140. }
  141.  
  142. #include "ddT.c"
  143.  
  144.  
  145. int ParseArgs(int * pcArg, int argc, char * argv[], PSZ pszExe, PSZ pszMap,
  146.               PULONG pulEIP, PULONG plFlag, PDDEXEC pDDExec)
  147. {
  148.    PCHAR  pch;
  149.    int    i;
  150.    PSZ    pszArgs = pszMap;
  151. //   int   j;
  152.  
  153.    pszMap[0] = 0;
  154.    pszExe[0] = 0;
  155. //   *plFlag   = 0;
  156.  
  157.    for (i = *pcArg; argc > i && !pszExe[0]; i++) {
  158.       switch (argv[i][0]) {
  159.       case '-':
  160.       case '/':
  161.          strupr(argv[i]);
  162.          if (*plFlag & DDI_DDI) {
  163.             if (!strncmp(&argv[i][1], "B", 2)) {
  164.                *plFlag |= DDI_BUILD;
  165.  
  166.             } else if (!strncmp(&argv[i][1], "BDDI", 2)) {
  167.                *plFlag |= DDI_WRITEDDI;
  168.                *plFlag |= DDI_BUILD;
  169.    
  170.             } else if (!strncmp(&argv[i][1], "MAPFILE:", 8)) {
  171.                strcpy(pszMap, strupr(&argv[i][9]));
  172.  
  173.  
  174.             } else if (!strncmp(&argv[i][1], "INFO", 5) ||
  175.                        !strncmp(&argv[i][1], "I", 2)) {
  176.    
  177.                *plFlag |= DDI_SHOW;
  178.                *plFlag |= DDI_VERBOSE;
  179.    
  180.             } else if (!strncmp(&argv[i][1], "CHECK", 6) ||
  181.                        !strncmp(&argv[i][1], "C", 2)) {
  182.    
  183.                *plFlag |= DDI_SHOW;
  184.                *plFlag |= DDI_CHECK;
  185.    
  186.    
  187.             } else if (!strncmp(&argv[i][1], "DDEBUG", 6)) {
  188.    
  189.                *plFlag |= DDI_DROPDEBUGINFO;
  190.    
  191.             } else if (!strncmp(&argv[i][1], "MDEBUG", 6)) {
  192.  
  193.                *plFlag |= DDI_MOVEDEBUGINFO;
  194.  
  195.             } else if (!strncmp(&argv[i][1], "ADEBUG", 6)) {
  196.  
  197.                *plFlag |= DDI_ADDDEBUGINFO;
  198.  
  199.             } else if (!strncmp(&argv[i][1], "D", 2)) {
  200.    
  201.                *plFlag |= DDI_DELMAP;
  202.    
  203.             } else if (!strncmp(&argv[i][1], "T", 1)) {
  204.    
  205.                *plFlag |= DDI_CRASHTEST;
  206.  
  207.                ddT(argv[i]);
  208.  
  209.             } else if (!strncmp(&argv[i][1], "M:", 2)) {
  210.                if (sscanf(&argv[i][3], "%lX", pulEIP) ||
  211.                    sscanf(&argv[i][3], "%lu", pulEIP)) {
  212.                   *plFlag |= DDI_MAP;
  213.                } else {
  214.                   Usage("Invalid ulEIP", argv[i]);
  215.                }
  216.  
  217.             } else if (!strncmp(&argv[i][1], "?", 2)  ||
  218.                        !strncmp(&argv[i][1], "H", 2)) {
  219.                Usage(NULL, NULL);
  220.    
  221.             } else {
  222.    
  223.                Usage("Invalid flag", argv[i]);
  224.             }
  225.  
  226.          } else {
  227.             if (       !strncmp(&argv[i][1], "VERB", 5) ||
  228.                        !strncmp(&argv[i][1], "V", 2)) {
  229.    
  230.                *plFlag |= EXEC_VERBOSE;
  231.                *plFlag &= ~EXEC_SILENT;
  232. /*
  233.             } else if (!strncmp(&argv[i][1], "O", 1)) {
  234.    
  235.                *plFlag |= DDI_DDD;
  236.                strcpy(pszMap, strupr(&argv[i][1]));
  237. */
  238.             } else if (!strncmp(&argv[i][1], "T", 1) ) {
  239.    
  240.                *plFlag |= DDI_CRASHTEST;
  241.  
  242.                ddT(argv[i]);
  243.  
  244.             } else if (!strncmp(&argv[i][1], "F", 1)) {
  245.                pDDExec->pszDDD = &argv[i][2];
  246.  
  247.             } else if (!strncmp(&argv[i][1], "S", 2)) {
  248.    
  249.                *plFlag |= EXEC_SILENT;
  250.                *plFlag &= ~EXEC_VERBOSE;
  251.  
  252.  
  253.             } else {
  254.                Usage("Invalid flag", argv[i]);
  255.             }
  256.          } 
  257.          break;
  258.  
  259.       case '?':
  260.          Usage(NULL, NULL);
  261.          break;
  262.  
  263.       default:
  264.          if ((argv[i][0] == 'i' ||
  265.              argv[i][0] == 'I') && !argv[i][1]) {
  266.  
  267.             *plFlag |= DDI_DDI;
  268.  
  269.          } else if ((argv[i][0] == 't' || argv[i][0] == 'T') &&
  270.              !strstr(argv[i], ".") ) {
  271.  
  272.             if (!argv[i][1] && i + 1 < argc) {
  273.                strcpy(pszExe, strupr(argv[++i]));
  274.                *pszArgs = 0;
  275.                i++;
  276.                while (i < argc) {
  277.                   strcat(pszArgs, argv[i++]);
  278.                   strcat(pszArgs, " ");
  279.                }
  280.                if (*pszArgs) {
  281.                   pszArgs[strlen(pszArgs) - 1] = 0;
  282.                }
  283.  
  284.             } else {
  285.    
  286.                PID    pid;
  287.                TID    tid;
  288. //               LONG   l;
  289.                CHAR   szExe  [20];
  290.                CHAR   szArgs [80];
  291.                CHAR   szTitle[80];
  292.                BOOL   fDDD   = FALSE;
  293.                DDEXEC DDExec;
  294.    
  295.                DDExec.pszDDD = NULL;
  296.    
  297.                if (argv[i][1] == 'T' || argv[i][1] == 't') {
  298.                   fDDD = TRUE;
  299.                   strcpy(szExe,    "cmd.exe");
  300.                   strcpy(szArgs,   "/C copy dd.Exe ddd.exe");
  301.                   sprintf(szTitle, "Desinfecting: %s %s", szExe, szArgs);
  302.    
  303.                   ddExec(szTitle, szExe, szArgs, &pid, &tid,
  304.                      &DDExec, EXEC_TRACED | EXEC_WAIT | EXEC_FOREGRD |
  305.                      EXEC_INHERIT | EXEC_DDT);
  306.    
  307.                   strcpy(szExe,    "dd.exe");
  308.                   strcpy(szArgs,   "/I /b /MapFile:dd.map ddd");
  309.                   sprintf(szTitle, "Desinfecting: %s %s", szExe, szArgs);
  310.                   ddExec(szTitle, szExe, szArgs, &pid, &tid, 
  311.                      &DDExec, EXEC_TRACED | EXEC_WAIT | EXEC_FOREGRD |
  312.                      EXEC_INHERIT | EXEC_DDT);
  313.                } 
  314.    
  315.                strcpy(szExe,    "dd.exe");
  316.                DDExec.pszDDD = "ddT.ddD";
  317.                if (fDDD) {
  318.                   sprintf(szArgs, "ddd T dd /%s", &argv[i][1]);
  319.                } else {
  320.                   sprintf(szArgs, "/%s", argv[i]);
  321.                } 
  322.    
  323.                sprintf(szTitle, "Desinfecting: %s %s", szExe, szArgs);
  324.                ddExec(szTitle, szExe, szArgs, &pid, &tid, &DDExec,
  325.                   EXEC_TRACED | EXEC_WAIT | EXEC_FOREGRD |
  326.                   EXEC_INHERIT | EXEC_DDT);
  327.    
  328.                *pszExe = 0;
  329.                *pcArg  = 0;
  330.  
  331.             } 
  332.             *plFlag |= EXEC_DDT;
  333.  
  334.          } else {
  335.             if (*plFlag & DDI_DDI) {
  336.                strcpy(pszExe, strupr(argv[i]));
  337.                pch = strstr(pszExe, ".EXE");
  338.                if (!pch) {
  339.                   if (!(pch = strstr(pszExe, ".DLL"))) {
  340.                      if (!strstr(pszExe, ".")) {
  341.                         strcat(pszExe, ".EXE");
  342.                         pch = strstr(pszExe, ".");
  343.                      }
  344.                   }
  345.                }
  346.                if (!pszMap[0]) {
  347.                   strcpy(pszMap, pszExe);
  348.                   if (pch) {
  349.                      strcpy(&pszMap[pch - pszExe], ".MAP");
  350.                   } else {
  351.                      strcat(pszMap, ".MAP");
  352.                   } 
  353.                }
  354.                if (*plFlag == DDI_DDI) {
  355.                   *plFlag |= DDI_CHECK;
  356.                   *plFlag |= DDI_SHOW;
  357.                }
  358.  
  359.             } else {
  360.                strcpy(pszExe, strupr(argv[i++]));
  361.                *pszArgs = 0;
  362.                while (i < argc) {
  363.                   strcat(pszArgs, argv[i++]);
  364.                   strcat(pszArgs, " ");
  365.                }
  366.                if (*pszArgs) {
  367.                   pszArgs[strlen(pszArgs) - 1] = 0;
  368.                }
  369.             } 
  370.          } 
  371.       }
  372.    }
  373.  
  374.    if (!pszExe[0] && *pcArg == 1) {
  375.  
  376.       Usage(NULL, NULL);
  377.    }
  378.    *pcArg = i;
  379.  
  380.    return pszExe[0];
  381. }
  382.  
  383. void CrashTest(ULONG ul)
  384. {
  385.    char  sz[1024];
  386.    PVOID pVoid;
  387.  
  388.    pVoid = sz;
  389.    sprintf(pVoid, "%lu %08lx", ul, ul);
  390.    ul += 4;
  391.  
  392.    if (ul % 16) {
  393.       CrashTest2(ul);
  394.    } else {
  395.       CrashTest(ul);
  396.    }
  397.    return;
  398. }
  399.  
  400. void CrashTest2(ULONG ul)
  401. {
  402.    char  sz[1024];
  403.    PVOID pVoid;
  404.  
  405.    pVoid = sz;
  406.    sprintf(pVoid, "%lu %08lx", ul, ul);
  407.    ul += 4;
  408.  
  409.    if (!(ul % 16)) {
  410.       CrashTest2(ul);
  411.    } else {
  412.       CrashTest(ul);
  413.    }
  414.    return;
  415. }
  416.  
  417.  
  418. void Usage(PSZ psz, PSZ pszFlag)
  419. {
  420.    if (psz) {
  421.       printf("\n%-10s %s", pszFlag, psz);
  422.    } else {
  423.       printf("\ndd DosDebugs at the sourcelevel");
  424.       printf("\ndd I works on dd's sourcelevel-information");
  425.       printf("\n");
  426.    }
  427.  
  428.    printf("\nUsage    : dd   [/Flags]     <1[.exe]> [arg1] [arg2] [..]  DosDebug one");
  429.    printf("\n           dd T [/Flags]     <1[.exe]> [arg1] [arg2] [..]  DosDebug & dump .ddT");
  430.    printf("\n                [/F<file.ddD>]         Write trace to file.ddD");
  431.    printf("\n                [/V[erbose]]           Verbose mode");
  432.    printf("\n           dd Tn                       Desinfects dd.exe for 1 < n > 9");
  433.    printf("\nOr       : dd I [/Flags]     <1[.exe]> [2.dll] [[/Flags] <?.dll>]");
  434.    printf("\n                [/B]                   Build ddI");
  435.    printf("\n                [/BDDI]                Build ddI and write .ddI");
  436.    printf("\n                [/D]                   Delete .map after build");
  437.    printf("\n                [/DDEBUG]              Delete DebugInfo from executable");
  438.    printf("\n                [/MDEBUG]              Move DebugInfo to .deB");
  439.    printf("\n                [/ADEBUG]              Add .deB to executable");
  440.    printf("\n                [/C[heck]]             Check ddI");
  441.    printf("\n                [/I[nfo]]              Display contents of ddI");
  442.    printf("\n                [/MAPFILE:<file.map>]  Use file.map to build ddI");
  443.    printf("\n                [/M:<[hex][dec]>]      Map EIP (hex/dec) in executable");
  444.  
  445.    exit(-1);
  446.    return;
  447. }
  448.