w2k_sym.c

Undocumented Windows 2000 Secrets简体中文版.+源码光盘

                }
            dTotal1 += dTotal2;

            if (n) DisplayTotal (gawTotalModules, dTotal2);
            if ((pwFilter != NULL) && n) DisplayMatches (n);
            }
        if (dTotal1) DisplayTotal (gawTotalSystem, dTotal1);

        if (fWrite) dbgIndexSaveEx (gawFileModules, pdi);
        dbgIndexDestroyEx (pdi);
        }
    else
        {
        DisplayError (L"module");
        }
    return;
    }

// -----------------------------------------------------------------

void WINAPI DisplayDrivers (PWORD pwFilter,
                            DWORD dSort,
                            BOOL  fReverse,
                            BOOL  fLoad,
                            BOOL  fWrite,
                            BOOL  fEnd,
                            BOOL  fVerbose,
                            BOOL  fCase)
    {
    PDBG_INDEX  pdi;
    PDBG_DRIVER pdd;
    PWORD       pwPath;
    DWORD       dEnd, dTotal, i, n;

    printf (gawTitleDrivers);

    if ((pdi = dbgDriverIndex ((fLoad ? gawFileDrivers : NULL),
                               dSort, fReverse))
        != NULL)
        {
        DisplayCount (L"driver", L"drivers", pdi->dEntries,
                      (!fVerbose
                       ? L" - use the /v switch to view full paths"
                       : NULL));

        DisplayTime   (&pdi->pdl->st);
        DisplayFilter (pwFilter);

        for (i = n = dTotal = 0; i < pdi->dEntries; i++)
            {
            pdd    = pdi->ppdd [i];
            pwPath = pdd->awPath + (fVerbose ? 0 : pdd->dFile);

            if (dbgStringMatch (pwFilter, pwPath, fCase))
                {
                if (fEnd)
                    {
                    if (!n++) printf (gawTableDrivers, gawEnd);

                    dEnd = (DWORD_PTR) pdd->pBase + pdd->dSize;

                    printf (L"%5lu: %08lX %08lX %s\r\n",
                            i+1, pdd->pBase, dEnd,
                            pwPath);
                    }
                else
                    {
                    if (!n++) printf (gawTableDrivers, gawSize);

                    printf (L"%5lu: %08lX %8lX %s\r\n",
                            i+1, pdd->pBase, pdd->dSize,
                            pwPath);
                    }
                dTotal += pdd->dSize;
                }
            }
        if (n) DisplayTotal (gawTotalDrivers, dTotal);
        if (pwFilter != NULL) DisplayMatches (n);

        if (fWrite) dbgIndexSave (gawFileDrivers, pdi);
        dbgIndexDestroy (pdi);
        }
    else
        {
        DisplayError (L"driver");
        }
    return;
    }

// -----------------------------------------------------------------

void WINAPI DisplaySymbols (PWORD pwPath,
                            PWORD pwFilter,
                            DWORD dSort,
                            BOOL  fReverse,
                            BOOL  fLoad,
                            BOOL  fWrite,
                            BOOL  fEnd,
                            BOOL  fVerbose,
                            BOOL  fCase)
    {
    PDBG_INDEX  pdi;
    PDBG_SYMBOL pds;
    PVOID       pBase;
    DWORD       dSize, dEnd, dTotal, i, n;

    printf (gawTitleSymbols);

    if (((pBase = dbgBaseDriver (pwPath, &dSize)) != NULL) ||
        ((pBase = dbgBaseModule (pwPath, &dSize)) != NULL))
        {
        if (dSize)
            {
            printf (L"\r\nModule %s at %08lX (%lX bytes)\r\n",
                    pwPath, pBase, dSize);
            }
        else
            {
            printf (L"\r\nModule %s at %08lX (unknown size)\r\n",
                    pwPath, pBase);
            }
        }
    if ((pdi = dbgSymbolIndex (pwPath, pBase,
                               (fLoad ? gawFileSymbols : NULL),
                               dSort, fReverse))
        != NULL)
        {
        DisplayCount (L"symbol", L"symbols", pdi->dEntries,
                      (!fVerbose
                       ? L" - use the /v switch to view all symbols"
                       : NULL));

        DisplayTime (&pdi->pdl->st);

        if (fVerbose)
            {
            DisplayFilter (pwFilter);

            for (i = n = dTotal = 0; i < pdi->dEntries; i++)
                {
                pds = pdi->ppds [i];

                if (dbgStringMatch (pwFilter, pds->awName, fCase))
                    {
                    if (fEnd)
                        {
                        if (!n++) printf (gawTableSymbols, gawEnd);

                        dEnd = (DWORD_PTR) pds->pBase + pds->dSize;

                        printf (L"%5lu: %08lX %08lX %s\r\n",
                                i+1, pds->pBase, dEnd,
                                pds->awName);
                        }
                    else
                        {
                        if (!n++) printf (gawTableSymbols, gawSize);

                        printf (L"%5lu: %08lX %8lX %s\r\n",
                                i+1, pds->pBase, pds->dSize,
                                pds->awName);
                        }
                    if (pds->pBase &&
                        ((DWORD_PTR) pds->pBase + pds->dSize))
                        {
                        dTotal += pds->dSize;
                        }
                    }
                }
            if (n) DisplayTotal (gawTotalSymbols, dTotal);
            if (pwFilter != NULL) DisplayMatches (n);
            }
        if (fWrite) dbgIndexSave (gawFileSymbols, pdi);
        dbgIndexDestroy (pdi);
        }
    else
        {
        DisplayError (L"symbol");
        }
    return;
    }

// =================================================================
// COMMAND DISPATCHER
// =================================================================

void WINAPI Dispatch (PWORD *ppwArguments,
                      DWORD  dArguments)
    {
    DWORD i, j;
    WORD  wOption;
    BOOL  fReset;
    BOOL  fReverse = FALSE;
    BOOL  fLoad    = FALSE;
    BOOL  fWrite   = FALSE;
    BOOL  fEnd     = FALSE;
    BOOL  fVerbose = FALSE;
    BOOL  fCase    = FALSE;
    BOOL  fFilter  = FALSE;
    PWORD pwFilter = NULL;
    DWORD dSort    = DBG_UNSORTED;

    printf (L"\r\nRequesting the debugging privilege ... %s\r\n",
            (dbgPrivilegeDebug () ? L"OK" : L"ERROR"));

    for (i = 0; i < dArguments; i++)
        {
        for (j = 0; ppwArguments [i] [j];)
            {
            if (fFilter)
                {
                fFilter  = FALSE;
                pwFilter = ppwArguments [i] + j;

                j += lstrlen (ppwArguments [i] + j);
                }
            else
                {
                fReset = FALSE;

                if (ppwArguments [i] [j] == '/')
                    {
                    wOption = ppwArguments [i] [++j];

                    switch (LCASE (wOption))
                        {
                        case 'a':
                            {
                            dSort = DBG_SORT_BY_ADDRESS;
                            break;
                            }
                        case 's':
                            {
                            dSort = DBG_SORT_BY_SIZE;
                            break;
                            }
                        case 'i':
                            {
                            dSort = DBG_SORT_BY_ID;
                            break;
                            }
                        case 'n':
                            {
                            dSort = DBG_SORT_BY_NAME;
                            break;
                            }
                        case 'c':
                            {
                            dSort = DBG_SORT_BY_NAME_CS;
                            break;
                            }
                        case 'r':
                            {
                            fReverse = TRUE;
                            break;
                            }
                        case 'l':
                            {
                            fLoad    = TRUE;
                            break;
                            }
                        case 'w':
                            {
                            fWrite   = TRUE;
                            break;
                            }
                        case 'e':
                            {
                            fEnd     = TRUE;
                            break;
                            }
                        case 'v':
                            {
                            fVerbose = TRUE;
                            break;
                            }
                        case 'f':
                            {
                            fCase    = (wOption == 'F');
                            fFilter  = TRUE;
                            break;
                            }
                        case 'p':
                            {
                            DisplayProcesses (pwFilter, dSort,
                                              fReverse, fLoad,
                                              fWrite,   fEnd,
                                              fVerbose, fCase);
                            fReset = TRUE;
                            break;
                            }
                        case 'm':
                            {
                            DisplayModules (pwFilter, dSort,
                                            fReverse, fLoad,
                                            fWrite,   fEnd,
                                            fVerbose, fCase);
                            fReset = TRUE;
                            break;
                            }
                        case 'd':
                            {
                            DisplayDrivers (pwFilter, dSort,
                                            fReverse, fLoad,
                                            fWrite,   fEnd,
                                            fVerbose, fCase);
                            fReset = TRUE;
                            break;
                            }
                        }
                    if (wOption) j++;
                    }
                else
                    {
                    DisplaySymbols (ppwArguments [i] + j,
                                    pwFilter, dSort, 
                                    fReverse, fLoad,
                                    fWrite,   fEnd,
                                    fVerbose, fCase);

                    j += lstrlen (ppwArguments [i] + j);

                    fReset = TRUE;
                    }
                if (fReset)
                    {
                    fReverse = FALSE;
                    fLoad    = FALSE;
                    fWrite   = FALSE;
                    fEnd     = FALSE;
                    fVerbose = FALSE;
                    fCase    = FALSE;
                    fFilter  = FALSE;
                    pwFilter = NULL;
                    dSort    = DBG_UNSORTED;
                    }
                }
            }
        }
    if (fLoad)
        {
        DisplaySymbols (NULL,
                        pwFilter, dSort, 
                        fReverse, fLoad,
                        fWrite,   fEnd,
                        fVerbose, fCase);
        }
    return;
    }

// =================================================================
// MAIN PROGRAM
// =================================================================

DWORD Main (DWORD argc, PTBYTE *argv, PTBYTE *argp)
    {
    DWORD dMemoryNow, dMemoryMax;
    BOOL  fMemorySign;

    printf (atAbout);

    if (argc < 2)
        {
        printf (atUsage, gawArguments);

        printf (gawOptions, gawFileProcesses, gawFileModules,
                            gawFileDrivers,   gawFileSymbols);
        }
    else
        {
        Dispatch (argv+1, argc-1);

        fMemorySign = dbgMemoryStatus (&dMemoryNow, &dMemoryMax);
        printf (L"\r\nMemory usage: %lu bytes\r\n", dMemoryMax);

#ifdef _MORE_INFO_

        printf (L"Memory leak: %s%lu bytes\r\n",
                (fMemorySign ? L"-" : L" "), dMemoryNow);

#endif // #ifdef _MORE_INFO_

        }
    return 0;
    }

// =================================================================
// END OF PROGRAM
// =================================================================