w2k_dbg.c

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

    }

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

BOOL WINAPI dbgMemoryStatus (PDWORD pdMemoryNow,
                             PDWORD pdMemoryMax)
    {
    BOOL fMemorySign = FALSE;

    EnterCriticalSection (&gcsMemory);

    fMemorySign = (glMemorySign < 0);

    if (pdMemoryNow != NULL) *pdMemoryNow = gdMemoryNow;
    if (pdMemoryMax != NULL) *pdMemoryMax = gdMemoryMax;

    LeaveCriticalSection (&gcsMemory);
    return fMemorySign;
    }

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

DWORD WINAPI dbgMemoryAlign (DWORD dSize)
    {
    return (((dSize - 1) >> SIZE_ALIGNMENT) + 1) << SIZE_ALIGNMENT;
    }

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

DWORD WINAPI dbgMemoryAlignEx (DWORD dFixed,
                               DWORD dText)
    {
    return dbgMemoryAlign (dFixed + (dText * sizeof (WORD)));
    }

// =================================================================
// FILE MANAGEMENT
// =================================================================

DWORD WINAPI dbgFileRoot (PWORD pwPath)
    {
    DWORD dRoot = 0;

    if ((pwPath != NULL) && pwPath [0])
        {
        if (pwPath [0] == '\\')
            {
            if (pwPath [1] == '\\')
                {
                for (dRoot = 2;
                     pwPath [dRoot] && (pwPath [dRoot] != '\\');
                     dRoot++);
                }
            }
        else
            {
            if (pwPath [1] == ':') dRoot = 2;
            }
        }
    return dRoot;
    }

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

HANDLE WINAPI dbgFileOpen (PWORD pwPath)
    {
    HANDLE hf = INVALID_HANDLE_VALUE;

    if ((pwPath != NULL) && pwPath [0])
        {
        hf = CreateFile (pwPath, GENERIC_READ,
                         FILE_SHARE_READ, NULL, OPEN_EXISTING,
                         FILE_FLAG_SEQUENTIAL_SCAN, NULL);
        }
    return hf;
    }

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

HANDLE WINAPI dbgFileNew (PWORD pwPath)
    {
    DWORD  i;
    HANDLE hf = INVALID_HANDLE_VALUE;

    if ((pwPath != NULL) && pwPath [0])
        {
        i = dbgFileRoot (pwPath);

        while (pwPath [i])
            {
            while (pwPath [i] && (pwPath [++i] != '\\'));

            if (pwPath [i] == '\\')
                {
                pwPath [i] = 0;
                CreateDirectory (pwPath, NULL);
                pwPath [i] = '\\';
                }
            }
        hf = CreateFile (pwPath, GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ, NULL, CREATE_ALWAYS,
                         FILE_FLAG_SEQUENTIAL_SCAN |
                         FILE_ATTRIBUTE_NORMAL, NULL);
        }
    return hf;
    }

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

HANDLE WINAPI dbgFileClose (HANDLE hf)
    {
    if (hf != INVALID_HANDLE_VALUE) CloseHandle (hf);
    return INVALID_HANDLE_VALUE;
    }

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

PVOID WINAPI dbgFileUnload (PVOID pData)
    {
    return dbgMemoryDestroy (pData);
    }

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

PVOID WINAPI dbgFileLoad (PWORD  pwPath,
                          PDWORD pdData)
    {
    HANDLE hf;
    DWORD  n;
    DWORD  dData  = 0;
    PBYTE  pbData = NULL;

    if ((hf = dbgFileOpen (pwPath)) != INVALID_HANDLE_VALUE)
        {
        dData = GetFileSize (hf, NULL);

        if ((dData != INVALID_FILE_SIZE) && (dData < MAXDWORD) &&
            ((pbData = dbgMemoryCreate (dData+1)) != NULL))
            {
            if (ReadFile (hf, pbData, dData, &n, NULL) &&
                (dData == n))
                {
                pbData [dData] = 0;
                }
            else
                {
                pbData = dbgFileUnload (pbData);
                }
            }
        dbgFileClose (hf);

        if (pbData == NULL) dData = 0;
        }
    if (pdData != NULL) *pdData = dData;
    return pbData;
    }

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

BOOL WINAPI dbgFileSave (PWORD pwPath,
                         PVOID pData,
                         DWORD dData)
    {
    HANDLE hf;
    DWORD  dData1, n;
    BOOL   fOk = FALSE;

    if ((pData != NULL) &&
        ((hf = dbgFileNew (pwPath)) != INVALID_HANDLE_VALUE))
        {
        dData1 = (dData != MAXDWORD ? dData : lstrlenA (pData));

        fOk = WriteFile (hf, pData, dData1, &n, NULL) &&
              (dData1 == n);

        dbgFileClose (hf);
        }
    return fOk;
    }

// =================================================================
// SIZE CONVERSION
// =================================================================

DWORD WINAPI dbgSizeDivide (DWORD dShift,
                            DWORD dSize,
                            BOOL  fRoundUp,
                            BOOL  fRoundDown)
    {
    DWORD dFactor;
    DWORD dSize1 = (dShift ? 0 : dSize);

    if (dShift && (dShift < 32))
        {
        dFactor = 1     << dShift;
        dSize1  = dSize >> dShift;

        if ((dSize & (dFactor-1)) && (fRoundUp || !fRoundDown))
            {
            if ((fRoundUp && !fRoundDown) ||
                (dSize & (dFactor >> 1))) dSize1++;
            }
        }
    return dSize1;
    }

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

DWORD WINAPI dbgSizeKB (DWORD dBytes,
                        BOOL  fRoundUp,
                        BOOL  fRoundDown)
    {
    return dbgSizeDivide (10, dBytes, fRoundUp, fRoundDown);
    }

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

DWORD WINAPI dbgSizeMB (DWORD dBytes,
                        BOOL  fRoundUp,
                        BOOL  fRoundDown)
    {
    return dbgSizeDivide (20, dBytes, fRoundUp, fRoundDown);
    }

// =================================================================
// STRING OPERATIONS
// =================================================================

PBYTE WINAPI dbgStringAnsi (PWORD pwData,
                            PBYTE pbData)
    {
    DWORD n;
    PBYTE pbData1 = NULL;

    if (pwData != NULL)
        {
        for (n = 0; pwData [n]; n++);

        if ((pbData1 = (pbData != NULL ? pbData
                                       : dbgMemoryCreate (n+1)))
            != NULL)
            {
            if (!WideCharToMultiByte
                     (CP_ACP, WC_COMPOSITECHECK | WC_DISCARDNS,
                      pwData, -1, pbData1, n+1, NULL, NULL))
                {
                do  {
                    pbData1 [n] = (pwData [n] < 0x0100
                                   ? (BYTE) pwData [n]
                                   : UNICODE_UNMAPPED);
                    }
                while (n--);
                }
            }
        }
    return pbData1;
    }

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

BOOL WINAPI dbgStringMatch (PWORD pwFilter,
                            PWORD pwData,
                            BOOL  fCase)
    {
    DWORD i = 0;
    DWORD j = 0;

    if (pwData   == NULL) return FALSE;
    if (pwFilter == NULL) return TRUE;

    while (pwFilter [i] && pwData [j])
        {
        if (pwFilter [i] != '?')
            {
            if (pwFilter [i] == '*')
                {
                i++;

                if ((pwFilter [i] != '*') &&
                    (pwFilter [i] != '?'))
                    {
                    if (pwFilter [i])
                        {
                        while (pwData [j]
                               &&
                               (!dbgStringMatch (pwFilter + i,
                                                 pwData   + j,
                                                 fCase)))
                            {
                            j++;
                            }
                        }
                    return pwData [j] != 0;
                    }
                }
            if (fCase ?        pwFilter [i]  !=        pwData [j]
                      : LCASE (pwFilter [i]) != LCASE (pwData [j]))
                {
                return FALSE;
                }
            }
        i++;
        j++;
        }
    if (pwFilter [i] == '*') i++;
    return !(pwFilter [i] || pwData [j]);
    }

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

PWORD WINAPI dbgStringDay (DWORD dDay)
    {
    PWORD pwDay = L"";

    switch (dDay % 7)
        {
        case 0: pwDay = L"Sunday";    break;
        case 1: pwDay = L"Monday";    break;
        case 2: pwDay = L"Tuesday";   break;
        case 3: pwDay = L"Wednesday"; break;
        case 4: pwDay = L"Thursday";  break;
        case 5: pwDay = L"Friday";    break;
        case 6: pwDay = L"Saturday";  break;
        }
    return pwDay;
    }

// =================================================================
// PATH MANAGEMENT
// =================================================================

DWORD WINAPI dbgPathFile (PWORD pwPath)
    {
    DWORD dFile = (pwPath != NULL ? lstrlen (pwPath) : 0);

    while (dFile && (pwPath [dFile-1] != '\\')
                 && (pwPath [dFile-1] != ':' )) dFile--;

    return dFile;
    }

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

DWORD WINAPI dbgPathDriver (PWORD pwFile,
                            PWORD pwBuffer,
                            DWORD dBuffer)
    {
    WORD  awPath [MAX_PATH] = L"drivers\\";
    DWORD n1, n2, i;
    DWORD n = 0;

    if (pwFile != NULL)
        {
        i = n2 = lstrlen (pwFile);

        while (i && (pwFile [i-1] != '\\')
                 && (pwFile [i-1] != ':' )) i--;

        if ((!i) && ((n1 = lstrlen (awPath)) + n2 < MAX_PATH))
            {
            lstrcpy (awPath + n1, pwFile);
            n = n1 + n2 + 1;
            }
        }
    if (!n) awPath [0] = 0;

    if (dBuffer)
        {
        lstrcpyn ((pwBuffer != NULL ? pwBuffer : pwFile),
                  awPath, dBuffer);
        }
    return n;
    }

// =================================================================
// LIST MANAGEMENT
// =================================================================

PDBG_LIST WINAPI dbgListCreate (void)
    {
    return dbgListCreateEx (0, 0, 0, NULL, NULL);
    }

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

PDBG_LIST WINAPI dbgListCreateEx (DWORD       dData,
                                  DWORD       dEntries,
                                  DWORD       dContext,
                                  PVOID       pContext,
                                  PSYSTEMTIME pst)
    {
    DWORD     dSize = dbgMemoryAlign  (DBG_LIST_);
    PDBG_LIST pdl   = dbgMemoryCreate (dSize + dData);

    if (pdl != NULL)
        {
        ZeroMemory (pdl, dSize + dData);

        pdl->dTag     = DBG_LIST_TAG;
        pdl->dFirst   = dSize - DBG_LIST_;
        pdl->dMemory  = pdl->dFirst + dData;
        pdl->dOffset  = pdl->dFirst;
        pdl->dEntries = dEntries;