w2k_call.c

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

                pwof->Object.pName  = &pwof->Name;

                pwof->Header.NameOffset =
                    OFFSET (W2K_OBJECT_FRAME, Header) -
                    OFFSET (W2K_OBJECT_FRAME, Name);

                pus = &pwof->Name.Name;
                }
            pwof->Object.pwName = pwBuffer;
            pwBuffer = w2kStringCopy (pus, pus, pwBuffer);

            if (wo.pHandleDB != NULL)
                {
                pwof->HandleDB         = *wo.pHandleDB;
                pwof->Object.pHandleDB = &pwof->HandleDB;

                pwof->Header.HandleDBOffset =
                    OFFSET (W2K_OBJECT_FRAME, Header) -
                    OFFSET (W2K_OBJECT_FRAME, HandleDB);
                }
            if (wo.pQuotaCharges != NULL)
                {
                pwof->QuotaCharges         = *wo.pQuotaCharges;
                pwof->Object.pQuotaCharges = &pwof->QuotaCharges;

                pwof->Header.QuotaChargesOffset =
                    OFFSET (W2K_OBJECT_FRAME, Header) -
                    OFFSET (W2K_OBJECT_FRAME, QuotaCharges);
                }
            pus = NULL;
            if (wo.pType != NULL)
                {
                pwof->Type              = *wo.pType;
                pwof->Object.pType      = &pwof->Type;
                pwof->Header.ObjectType = &pwof->Type;

                pus = &pwof->Type.ObjectTypeName;
                }
            pwof->Object.pwType = pwBuffer;
            pwBuffer = w2kStringCopy (pus, pus, pwBuffer);

            if (wo.pQuotaBlock != NULL)
                {
                pwof->QuotaBlock         = *wo.pQuotaBlock;
                pwof->Object.pQuotaBlock = &pwof->QuotaBlock;
                pwof->Header.QuotaBlock  = &pwof->QuotaBlock;
                }
            if (wo.pCreateInfo != NULL)
                {
                pwof->CreateInfo              = *wo.pCreateInfo;
                pwof->Object.pCreateInfo      = &pwof->CreateInfo;
                pwof->Header.ObjectCreateInfo = &pwof->CreateInfo;
                }
            }
        w2kMemoryDestroy (wo.pHeader      );
        w2kMemoryDestroy (wo.pCreatorInfo );
        w2kMemoryDestroy (wo.pName        );
        w2kMemoryDestroy (wo.pHandleDB    );
        w2kMemoryDestroy (wo.pQuotaCharges);
        w2kMemoryDestroy (wo.pType        );
        w2kMemoryDestroy (wo.pQuotaBlock  );
        w2kMemoryDestroy (wo.pCreateInfo  );
        }
    return (pwof != NULL ? &pwof->Object : NULL);
    }

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

PW2K_OBJECT WINAPI
w2kObjectClose (PW2K_OBJECT pwo)
    {
    if (pwo != NULL)
        {
        w2kMemoryDestroy
            (BACK (pwo, OFFSET (W2K_OBJECT_FRAME, Object)));
        }
    return NULL;
    }

// =================================================================
// OBJECT DIRECTORY MANAGEMENT
// =================================================================

POBJECT_DIRECTORY WINAPI
w2kDirectoryOpen (POBJECT_DIRECTORY pDir)
    {
    DWORD                    i;
    PERESOURCE               pLock;
    PPOBJECT_DIRECTORY_ENTRY ppEntry;
    POBJECT_DIRECTORY        pDir1 = NULL;

    if (((pLock = __ObpRootDirectoryMutex ()) != NULL) &&
        _ExAcquireResourceExclusiveLite (pLock, TRUE))
        {
        if ((pDir1 = w2kSpyClone (pDir, OBJECT_DIRECTORY_)) != NULL)
            {
            for (i = 0; i < OBJECT_HASH_TABLE_SIZE; i++)
                {
                ppEntry = pDir1->HashTable + i;

                while (*ppEntry != NULL)
                    {
                    if ((*ppEntry =
                            w2kSpyClone (*ppEntry,
                                         OBJECT_DIRECTORY_ENTRY_))
                        != NULL)
                        {
                        (*ppEntry)->Object =
                            w2kObjectOpen ((*ppEntry)->Object);

                        ppEntry = &(*ppEntry)->NextEntry;
                        }
                    }
                }
            }
        _ExReleaseResourceLite (pLock);
        }
    return pDir1;
    }

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

POBJECT_DIRECTORY WINAPI
w2kDirectoryClose (POBJECT_DIRECTORY pDir)
    {
    POBJECT_DIRECTORY_ENTRY pEntry, pEntry1;
    DWORD                   i;

    if (pDir != NULL)
        {
        for (i = 0; i < OBJECT_HASH_TABLE_SIZE; i++)
            {
            for (pEntry  = pDir->HashTable [i];
                 pEntry != NULL;
                 pEntry  = pEntry1)
                {
                pEntry1 = pEntry->NextEntry;

                w2kObjectClose   (pEntry->Object);
                w2kMemoryDestroy (pEntry);
                }
            }
        w2kMemoryDestroy (pDir);
        }
    return NULL;
    }

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

DWORD WINAPI
w2kDirectorySize (POBJECT_DIRECTORY pDir,
                  PWORD             pwType)
    {
    POBJECT_DIRECTORY_ENTRY  pEntry;
    POBJECT_NAME_INFORMATION pInfo;
    DWORD                    dInfo, i, n;
    DWORD                    dSize = 0;

    if (pDir != NULL)
        {
        dInfo = OBJECT_NAME_INFORMATION_ + (1000 * WORD_);
        pInfo = (pwType != NULL ? w2kMemoryCreate (dInfo) : NULL);

        if ((pwType == NULL) || (pInfo != NULL))
            {
            for (i = 0; i < OBJECT_HASH_TABLE_SIZE; i++)
                {
                for (pEntry  = pDir->HashTable [i];
                     pEntry != NULL;
                     pEntry  = pEntry->NextEntry)
                    {
                    n = 0;

                    if ((pwType == NULL)
                        ||
                        ((__ObQueryTypeName (pEntry->Object,
                                             pInfo, dInfo, &n)
                          == STATUS_SUCCESS)
                         &&
                         ((!lstrcmp (L"Directory",
                                     pInfo->Name.Buffer))
                          ||
                          w2kStringFilter (pwType,
                                           pInfo->Name.Buffer,
                                           TRUE))))
                        {
                        dSize++;
                        }
                    }
                }
            w2kMemoryDestroy (pInfo);
            }
        }
    return dSize;
    }

// =================================================================
// EXECUTIVE
// =================================================================

BOOLEAN WINAPI
_ExAcquireResourceExclusiveLite (PERESOURCE Resource,
                                 BOOLEAN    Wait)
    {
    return w2kCall08 (FALSE, "ExAcquireResourceExclusiveLite",FALSE,
                      8, Resource, Wait);
    }

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

BOOLEAN WINAPI
_ExAcquireResourceSharedLite (PERESOURCE Resource,
                              BOOLEAN    Wait)
    {
    return w2kCall08 (FALSE, "ExAcquireResourceSharedLite", FALSE,
                      8, Resource, Wait);
    }

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

PVOID WINAPI
_ExAllocatePool (POOL_TYPE PoolType,
                 SIZE_T    NumberOfBytes)
    {
    return w2kCallP (NULL, "ExAllocatePool", FALSE,
                     8, PoolType, NumberOfBytes);
    }

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

PVOID WINAPI
_ExAllocatePoolWithTag (POOL_TYPE PoolType,
                        SIZE_T    NumberOfBytes,
                        DWORD     Tag)
    {
    return w2kCallP (NULL, "ExAllocatePoolWithTag", FALSE,
                     12, PoolType, NumberOfBytes, Tag);
    }

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

VOID WINAPI
_ExFreePool (PVOID P)
    {
    w2kCallV (NULL, "ExFreePool", FALSE,
              4, P);
    return;
    }

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

VOID WINAPI
_ExFreePoolWithTag (PVOID P,
                    DWORD Tag)
    {
    w2kCallV (NULL, "ExFreePoolWithTag", FALSE,
              8, P, Tag);
    return;
    }

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

BOOLEAN WINAPI
__ExLockHandleTableEntry (PHANDLE_TABLE HandleTable,
                          PHANDLE_ENTRY HandleEntry)
    {
    return w2kXCall08 (FALSE, "ExLockHandleTableEntry",
                       8, HandleTable, HandleEntry);
    }

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

BOOLEAN WINAPI
__ExLockHandleTableExclusive (PHANDLE_TABLE HandleTable)
    {
    return w2kXCall08 (FALSE, "ExLockHandleTableExclusive",
                       4, HandleTable);
    }

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

BOOLEAN WINAPI
__ExLockHandleTableShared (PHANDLE_TABLE HandleTable)
    {
    return w2kXCall08 (FALSE, "ExLockHandleTableShared",
                       4, HandleTable);
    }

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

PHANDLE_ENTRY WINAPI
__ExMapHandleToPointer (PHANDLE_TABLE HandleTable,
                        HANDLE        Handle)
    {
    return w2kXCallP (NULL, "ExMapHandleToPointer",
                      8, HandleTable, Handle);
    }

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

VOID WINAPI
_ExReleaseResourceLite (PERESOURCE Resource)
    {
    w2kCallV (NULL, "ExReleaseResourceLite", TRUE,
              4, Resource);
    return;
    }

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

VOID WINAPI
__ExUnlockHandleTableEntry (PHANDLE_TABLE HandleTable,
                            PHANDLE_ENTRY HandleEntry)
    {
    w2kXCallV (NULL, "ExUnlockHandleTableEntry",
               8, HandleTable, HandleEntry);
    return;
    }

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

VOID WINAPI
__ExUnlockHandleTableShared (PERESOURCE Resource)
    {
    w2kXCallV (NULL, "ExUnlockHandleTableShared",
               4, Resource);
    return;
    }

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

PHANDLE_ENTRY WINAPI
__ExpLookupHandleTableEntry (PHANDLE_TABLE HandleTable,
                             HANDLE        Handle)
    {
    return w2kXCallP (NULL, "ExpLookupHandleTableEntry",
                      8, HandleTable, Handle);
    }

// =================================================================
// FILE SYSTEM RUNTIME LIBRARY
// =================================================================

PBYTE WINAPI
_FsRtlLegalAnsiCharacterArray (VOID)
    {
    return w2kCopyP (NULL, "FsRtlLegalAnsiCharacterArray");
    }

// =================================================================
// HARDWARE ABSTRACTION LAYER
// =================================================================
// pitch: 0 = off, 1..18 invalid, 19+ ok

BOOLEAN WINAPI
_HalMakeBeep (DWORD Pitch)
    {
    return w2kCall08 (FALSE, "hal.dll!HalMakeBeep", FALSE,
                      4, Pitch);
    }

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

VOID WINAPI
_HalQueryRealTimeClock (PTIME_FIELDS TimeFields)
    {
    w2kCallV (NULL, "hal.dll!HalQueryRealTimeClock", FALSE,
              4, TimeFields);
    return;
    }

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

VOID WINAPI
_HalSetRealTimeClock (PTIME_FIELDS TimeFields)
    {
    w2kCallV (NULL, "hal.dll!HalSetRealTimeClock", FALSE,
              4, TimeFields);
    return;
    }

// =================================================================
// HANDLE TABLES
// =================================================================

PLIST_ENTRY WINAPI
__HandleTableListHead (VOID)
    {
    return w2kXCopyEP (NULL, "HandleTableListHead");
    }

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

PERESOURCE WINAPI
__HandleTableListLock (VOID)
    {
    return w2kXCopyP (NULL, "HandleTableListLock");
    }

// =================================================================
// KERNEL
// =================================================================

DWORD WINAPI
_KeI386MachineType (VOID)
    {
    return w2kCopy32 (0, "KeI386MachineType");
    }

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

BYTE WINAPI
_KeNumberProcessors (VOID)
    {
    return w2kCopy08 (0, "KeNumberProcessors");
    }

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

PSERVICE_DESCRIPTOR_TABLE WINAPI
_KeServiceDescriptorTable (VOID)
    {
    return w2kCopyEP (NULL, "KeServiceDescriptorTable");
    }

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

QWORD WINAPI
_KeTickCount (VOID)
    {
    return w2kCopy64 (0, "KeTickCount");
    }

// =================================================================
// MEMORY MANAGER
// =================================================================

PHYSICAL_ADDRESS WINAPI
_MmGetPhysicalAddress (PVOID BaseAddress)
    {
    PHYSICAL_ADDRESS pa;

    pa.QuadPart = w2kCall64 (0, "MmGetPhysicalAddress", FALSE,