w2k_dbg.c

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

        pdl->dCrc32   = 0;
        pdl->dContext = dContext;
        pdl->pContext = pContext;

        if (pst != NULL)
            {
            pdl->st = *pst;
            }
        else
            {
            GetSystemTime (&pdl->st);
            }
        }
    return pdl;
    }

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

PDBG_LIST WINAPI dbgListDestroy (PDBG_LIST pdl)
    {
    return dbgMemoryDestroy (pdl);
    }

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

PDBG_LIST WINAPI dbgListResize (PDBG_LIST pdl,
                                DWORD     dData)
    {
    PDBG_LIST pdl1 = pdl;

    if (dData)
        {
        if (pdl != NULL)
            {
            if (pdl->dMemory - pdl->dOffset < dData)
                {
                pdl->dMemory += max (SIZE_INCREMENT, dData);

                pdl1 = dbgMemoryResize (pdl,
                                        DBG_LIST_ + pdl->dMemory,
                                        NULL);
                }
            }
        if (pdl1 != NULL)
            {
            ZeroMemory (pdl1->abData + pdl1->dOffset, dData);
            }
        }
    return pdl1;
    }

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

DWORD WINAPI dbgListNext (PDBG_LIST pdl,
                          DWORD     dData,
                          BOOL      fCount)
    {
    DWORD dEntries = 0;

    if (pdl != NULL)
        {
        pdl->dOffset += dData;
        if (fCount) pdl->dEntries++;
        dEntries =  pdl->dEntries;
        }
    return dEntries;
    }

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

PDBG_LIST WINAPI dbgListFinish (PDBG_LIST pdl)
    {
    PDBG_LIST pdl1 = pdl;

    if ((pdl1 != NULL) && (pdl1->dMemory != pdl1->dOffset))
        {
        pdl1->dMemory = pdl1->dOffset;

        pdl1 = dbgMemoryResize (pdl1,
                                DBG_LIST_ + pdl1->dOffset,
                                NULL);
        }
    if (pdl1 != NULL)
        {
        pdl1->dCrc32 = dbgCrc32Block (NULL, pdl1->abData,
                                            pdl1->dMemory);
        }
    return pdl1;
    }

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

PDBG_INDEX WINAPI dbgListIndex (PDBG_LIST pdl,
                                DWORD     dMemberNext)
    {
    DWORD      dOffset, dNext, i;
    PDBG_INDEX pdi = NULL;

    if ((pdl != NULL)
        &&
        ((pdi = dbgMemoryCreate (DBG_INDEX__ (pdl->dEntries)))
         != NULL))
        {
        pdi->ppbData     = pdi->apbData;
        pdi->pdl         = pdl;
        pdi->pdlDestroy  = NULL;
        pdi->dMemberNext = dMemberNext;
        pdi->dData       = 0;
        pdi->dEntries    = pdl->dEntries;
        pdi->dContext    = pdl->dContext;
        pdi->pContext    = pdl->pContext;

        dOffset = pdl->dFirst;

        for (i = 0; i < pdl->dEntries; i++)
            {
            pdi->apbData [i] = pdl->abData + dOffset;
            dNext = *(PDWORD) (pdl->abData + dOffset + dMemberNext);

            pdi->dData += dNext;
            dOffset    += dNext;
            }
        }
    return pdi;
    }

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

PDBG_LIST WINAPI dbgListLoad (PWORD pwPath)
    {
    DWORD     dData;
    PDBG_LIST pdl = dbgFileLoad (pwPath, &dData);

    if ((pdl != NULL)
        &&
        ((dData       <  DBG_LIST_               ) ||
         (pdl->dTag   != DBG_LIST_TAG            ) ||
         (dData       != DBG_LIST_ + pdl->dMemory) ||
         (pdl->dCrc32 != dbgCrc32Block (NULL, pdl->abData,
                                              pdl->dMemory))))
        {
        pdl = dbgFileUnload (pdl);
        }
    return pdl;
    }

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

BOOL WINAPI dbgListSave (PWORD     pwPath,
                         PDBG_LIST pdl)
    {
    DWORD dContext;
    PVOID pContext;
    BOOL  fOk = FALSE;

    if (pdl != NULL)
        {
        dContext = pdl->dContext;
        pContext = pdl->pContext;

        pdl->dContext = 0;
        pdl->pContext = NULL;

        fOk = dbgFileSave (pwPath, pdl, DBG_LIST_ + pdl->dMemory);

        pdl->dContext = dContext;
        pdl->pContext = pContext;
        }
    return fOk;
    }

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

PDBG_INDEX WINAPI dbgIndexCreate (PDBG_LIST pdl,
                                  DWORD     dMemberNext)
    {
    PDBG_INDEX pdi = dbgListIndex (pdl, dMemberNext);

    if (pdi != NULL) pdi->pdlDestroy = pdl;
    return pdi;
    }

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

PDBG_INDEX WINAPI dbgIndexCreateEx (PDBG_LIST pdl,
                                    DWORD     dMemberNext,
                                    DWORD     dMemberAddress,
                                    DWORD     dMemberSize,
                                    DWORD     dMemberId,
                                    DWORD     dMemberNameData,
                                    DWORD     dMemberNameOffset,
                                    DWORD     dSort,
                                    BOOL      fReverse)
    {
    DWORD      dMemberData, dMemberOffset, dControl;
    PDBG_INDEX pdi = dbgIndexCreate (pdl, dMemberNext);

    if (pdi != NULL)
        {
        dMemberData   = MAXDWORD;
        dMemberOffset = MAXDWORD;
        dControl      = (fReverse ? DBG_SORT_REVERSE : 0);

        switch (dSort)
            {
            case DBG_SORT_BY_ADDRESS:
                {
                dMemberData    = dMemberAddress;
                dControl      |= DBG_SORT_PVOID;
                break;
                }
            case DBG_SORT_BY_SIZE:
                {
                dMemberData    = dMemberSize;
                dControl      |= DBG_SORT_DWORD;
                break;
                }
            case DBG_SORT_BY_ID:
                {
                dMemberData    = dMemberId;
                dControl      |= DBG_SORT_DWORD;
                break;
                }
            case DBG_SORT_BY_NAME_CS:
                {
                dControl      |= DBG_SORT_CASE;
                }
            case DBG_SORT_BY_NAME:
                {
                dMemberData    = dMemberNameData;
                dMemberOffset  = dMemberNameOffset;
                dControl      |= DBG_SORT_STRING;
                break;
                }
            default:
                {
                dControl      |= DBG_SORT_NONE;
                break;
                }
            }
        dbgIndexSort (pdi, dMemberData, dMemberOffset, dControl);
        }
    return pdi;
    }

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

PDBG_INDEX WINAPI dbgIndexDestroy (PDBG_INDEX pdi)
    {
    if (pdi != NULL) dbgListDestroy (pdi->pdlDestroy);
    return dbgMemoryDestroy (pdi);
    }

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

PDBG_INDEX WINAPI dbgIndexDestroyEx (PDBG_INDEX pdi)
    {
    DWORD i;

    if (pdi != NULL)
        {
        for (i = 0; i < pdi->dEntries; i++)
            {
            dbgIndexDestroy (pdi->ppdi [i]);
            }
        }
    return dbgIndexDestroy (pdi);
    }

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

void WINAPI dbgIndexReverse (PDBG_INDEX pdi)
    {
    DWORD i, j;
    PBYTE pbData;

    if ((pdi != NULL) && (pdi->dEntries > 1))
        {
        for (i = 0, j = pdi->dEntries-1; i < j; i++, j--)
            {
            pbData           = pdi->apbData [i];
            pdi->apbData [i] = pdi->apbData [j];
            pdi->apbData [j] = pbData;
            }
        }
    return;
    }

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

INT WINAPI dbgIndexCompare (PVOID pData1,
                            PVOID pData2,
                            DWORD dControl)
    {
    UNICODE_STRING us1, us2;
    BOOL           fOk = FALSE;
    INT            i   = -1;

    if ((pData1 != NULL) && (pData2 != NULL))
        {
        fOk = TRUE;

        switch (dControl & DBG_SORT_TYPE)
            {
            case DBG_SORT_RESTORE:
                {
                i = ((DWORD_PTR) pData1 < (DWORD_PTR) pData2
                     ? -1
                     : ((DWORD_PTR) pData1 > (DWORD_PTR) pData2
                        ? 1 : 0));
                break;
                }
            case DBG_SORT_DWORD:
                {
                i = (*(PDWORD) pData1 < *(PDWORD) pData2
                     ? -1
                     : (*(PDWORD) pData1 > *(PDWORD) pData2
                        ? 1 : 0));
                break;
                }
            case DBG_SORT_PVOID:
                {
                i = (*(PDWORD_PTR) pData1 < *(PDWORD_PTR) pData2
                     ? -1
                     : (*(PDWORD_PTR) pData1 > *(PDWORD_PTR) pData2
                        ? 1 : 0));
                break;
                }
            case DBG_SORT_STRING:
                {
                RtlInitUnicodeString (&us1, pData1);
                RtlInitUnicodeString (&us2, pData2);

                i = RtlCompareUnicodeString
                        (&us1, &us2,
                         (BOOLEAN) !(dControl & DBG_SORT_CASE));
                break;
                }
            default:
                {
                fOk = FALSE;
                break;
                }
            }
        }
    if (fOk && (dControl & DBG_SORT_REVERSE)) i = 0 - i;
    return i;
    }

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

void WINAPI dbgIndexSort (PDBG_INDEX pdi,
                          DWORD      dMemberData,
                          DWORD      dMemberOffset,
                          DWORD      dControl)
    {
    INT   i;
    DWORD dControl1, dCount, dBase, dDelta, dTrans, n1, n2;
    PBYTE pbData1, pbData2;

    dControl1 = (dControl & ~DBG_SORT_TYPE) | DBG_SORT_RESTORE;

    if ((dControl & DBG_SORT_TYPE) == DBG_SORT_NONE)
        {
        if (dControl & DBG_SORT_REVERSE) dbgIndexReverse (pdi);
        }
    else
        {
        if ((pdi != NULL) && (pdi->dEntries > 1) &&
            (dMemberData != MAXDWORD))
            {
            dTrans = 1;
            dDelta = dCount = pdi->dEntries;

            while ((dDelta > 1) || dTrans)
                {
                dTrans  = 0;
                dDelta -= (dDelta > 3 ? dDelta >> 2
                                      : (dDelta > 1 ? 1 : 0));

                for (dBase = 0; dBase < dCount - dDelta; dBase++)
                    {
                    pbData1 = pdi->apbData [dBase];
                    pbData2 = pdi->apbData [dBase + dDelta];

                    n1 = n2 = dMemberData;
                    
                    if (dMemberOffset != MAXDWORD)
                        {
                        n1 += *(PDWORD) (pbData1 + dMemberOffset) *
                              sizeof (WORD);

                        n2 += *(PDWORD) (pbData2 + dMemberOffset) *
                              sizeof (WORD);
                        }
                    if (!(i = dbgIndexCompare (pbData1 + n1,
                                               pbData2 + n2,
                                               dControl)))
                        {
                        i = dbgIndexCompare (pbData1,
                                             pbData2,