handle.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
NTSTATUS	ConSrvInheritHandlesTable (IN PCONSOLE_PROCESS_DATA SourceProcessData, IN PCONSOLE_PROCESS_DATA TargetProcessData)
VOID	ConSrvFreeHandlesTable (IN PCONSOLE_PROCESS_DATA ProcessData)
VOID	ConSrvInitObject (IN OUT PCONSOLE_IO_OBJECT Object, IN CONSOLE_IO_OBJECT_TYPE Type, IN PCONSOLE Console)
NTSTATUS	ConSrvInsertObject (IN PCONSOLE_PROCESS_DATA ProcessData, OUT PHANDLE Handle, IN PCONSOLE_IO_OBJECT Object, IN ULONG Access, IN BOOLEAN Inheritable, IN ULONG ShareMode)
NTSTATUS	ConSrvRemoveObject (IN PCONSOLE_PROCESS_DATA ProcessData, IN HANDLE Handle)
NTSTATUS	ConSrvGetObject (IN PCONSOLE_PROCESS_DATA ProcessData, IN HANDLE Handle, OUT PCONSOLE_IO_OBJECT *Object, OUT PVOID *Entry OPTIONAL, IN ULONG Access, IN BOOLEAN LockConsole, IN CONSOLE_IO_OBJECT_TYPE Type)
VOID	ConSrvReleaseObject (IN PCONSOLE_IO_OBJECT Object, IN BOOLEAN IsConsoleLocked)

Function Documentation

ConSrvFreeHandlesTable()

VOID ConSrvFreeHandlesTable

(

IN PCONSOLE_PROCESS_DATA

ProcessData

)

Definition at line 172 of file handle.c.

{
    RtlEnterCriticalSection(&ProcessData->HandleTableLock);
 
    if (ProcessData->HandleTable != NULL)
    {
        ULONG i;
 
        /*
         * ProcessData->ConsoleHandle is NULL (and the assertion fails) when
         * ConSrvFreeHandlesTable is called in ConSrvConnect during the
         * allocation of a new console.
         */
        // ASSERT(ProcessData->ConsoleHandle);
        if (ProcessData->ConsoleHandle != NULL)
        {
            /* Close all the console handles */
            for (i = 0; i < ProcessData->HandleTableSize; i++)
            {
                ConSrvCloseHandle(&ProcessData->HandleTable[i]);
            }
        }
        /* Free the handles table memory */
        ConsoleFreeHeap(ProcessData->HandleTable);
        ProcessData->HandleTable = NULL;
    }
 
    ProcessData->HandleTableSize = 0;
 
    RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
}

Referenced by ConSrvAllocateConsole(), ConSrvInheritConsole(), ConSrvInitProcessHandles(), and ConSrvRemoveConsole().

ConSrvGetObject()

NTSTATUS ConSrvGetObject	(	IN PCONSOLE_PROCESS_DATA	ProcessData,
		IN HANDLE	Handle,
		OUT PCONSOLE_IO_OBJECT *	Object,
		OUT PVOID *Entry	OPTIONAL,
		IN ULONG	Access,
		IN BOOLEAN	LockConsole,
		IN CONSOLE_IO_OBJECT_TYPE	Type
	)

Definition at line 318 of file handle.c.

{
    // NTSTATUS Status;
    ULONG Index = HandleToULong(Handle) >> 2;
    PCONSOLE_IO_HANDLE HandleEntry = NULL;
    PCONSOLE_IO_OBJECT ObjectEntry = NULL;
    // PCONSRV_CONSOLE ObjectConsole;
 
    ASSERT(Object);
    if (Entry) *Entry = NULL;
 
    DPRINT("ConSrvGetObject -- Object: 0x%x, Handle: 0x%x\n", Object, Handle);
 
    RtlEnterCriticalSection(&ProcessData->HandleTableLock);
 
    if ( IsConsoleHandle(Handle) &&
         Index < ProcessData->HandleTableSize )
    {
        HandleEntry = &ProcessData->HandleTable[Index];
        ObjectEntry = HandleEntry->Object;
    }
 
    if ( HandleEntry == NULL ||
         ObjectEntry == NULL ||
         (HandleEntry->Access & Access) == 0 ||
         /*(Type != 0 && ObjectEntry->Type != Type)*/
         (Type != 0 && (ObjectEntry->Type & Type) == 0) )
    {
        DPRINT("ConSrvGetObject -- Invalid handle 0x%x of type %lu with access %lu ; retrieved object 0x%x (handle 0x%x) of type %lu with access %lu\n",
               Handle, Type, Access, ObjectEntry, HandleEntry, (ObjectEntry ? ObjectEntry->Type : 0), (HandleEntry ? HandleEntry->Access : 0));
 
        RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
        return STATUS_INVALID_HANDLE;
    }
 
    RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
 
    // Status = ConSrvGetConsole(ProcessData, &ObjectConsole, LockConsole);
    // if (NT_SUCCESS(Status))
    if (ConDrvValidateConsoleUnsafe(ObjectEntry->Console, CONSOLE_RUNNING, LockConsole))
    {
        _InterlockedIncrement(&ObjectEntry->Console->ReferenceCount);
 
        /* Return the objects to the caller */
        *Object = ObjectEntry;
        if (Entry) *Entry = HandleEntry;
 
        // RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
        return STATUS_SUCCESS;
    }
    else
    {
        // RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
        return STATUS_INVALID_HANDLE;
    }
}

Referenced by CON_API().

ConSrvInheritHandlesTable()

NTSTATUS ConSrvInheritHandlesTable	(	IN PCONSOLE_PROCESS_DATA	SourceProcessData,
		IN PCONSOLE_PROCESS_DATA	TargetProcessData
	)

Definition at line 120 of file handle.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG i, j;
 
    RtlEnterCriticalSection(&SourceProcessData->HandleTableLock);
 
    /* Inherit a handles table only if there is no already */
    if (TargetProcessData->HandleTable != NULL /* || TargetProcessData->HandleTableSize != 0 */)
    {
        Status = STATUS_UNSUCCESSFUL;
        goto Quit;
    }
 
    /* Allocate a new handle table for the child process */
    TargetProcessData->HandleTable = ConsoleAllocHeap(HEAP_ZERO_MEMORY,
                                                      SourceProcessData->HandleTableSize
                                                        * sizeof(CONSOLE_IO_HANDLE));
    if (TargetProcessData->HandleTable == NULL)
    {
        Status = STATUS_NO_MEMORY;
        goto Quit;
    }
 
    TargetProcessData->HandleTableSize = SourceProcessData->HandleTableSize;
 
    /*
     * Parse the parent process' handles table and, for each handle,
     * do a copy of it and reference it, if the handle is inheritable.
     */
    for (i = 0, j = 0; i < SourceProcessData->HandleTableSize; i++)
    {
        if (SourceProcessData->HandleTable[i].Object != NULL &&
            SourceProcessData->HandleTable[i].Inheritable)
        {
            /*
             * Copy the handle data and increment the reference count of the
             * pointed object (via the call to ConSrvCreateHandleEntry == AdjustHandleCounts).
             */
            TargetProcessData->HandleTable[j] = SourceProcessData->HandleTable[i];
            AdjustHandleCounts(&TargetProcessData->HandleTable[j], +1);
            ++j;
        }
    }
 
Quit:
    RtlLeaveCriticalSection(&SourceProcessData->HandleTableLock);
    return Status;
}

Referenced by ConSrvNewProcess().

ConSrvInitObject()

VOID ConSrvInitObject	(	IN OUT PCONSOLE_IO_OBJECT	Object,
		IN CONSOLE_IO_OBJECT_TYPE	Type,
		IN PCONSOLE	Console
	)

Definition at line 211 of file handle.c.

{
    ASSERT(Object);
    // if (!Object) return;
 
    Object->Type    = Type;
    Object->Console = Console;
    Object->ReferenceCount = 0;
 
    Object->AccessRead    = Object->AccessWrite    = 0;
    Object->ExclusiveRead = Object->ExclusiveWrite = 0;
}

Referenced by ConDrvInitInputBuffer(), and CONSOLE_SCREEN_BUFFER_Initialize().

ConSrvInsertObject()

NTSTATUS ConSrvInsertObject	(	IN PCONSOLE_PROCESS_DATA	ProcessData,
		OUT PHANDLE	Handle,
		IN PCONSOLE_IO_OBJECT	Object,
		IN ULONG	Access,
		IN BOOLEAN	Inheritable,
		IN ULONG	ShareMode
	)

Definition at line 227 of file handle.c.

{
#define IO_HANDLES_INCREMENT    2 * 3
 
    ULONG i = 0;
    PCONSOLE_IO_HANDLE Block;
 
    // NOTE: Commented out because calling code always lock HandleTableLock before.
    // RtlEnterCriticalSection(&ProcessData->HandleTableLock);
 
    ASSERT( (ProcessData->HandleTable == NULL && ProcessData->HandleTableSize == 0) ||
            (ProcessData->HandleTable != NULL && ProcessData->HandleTableSize != 0) );
 
    if (ProcessData->HandleTable)
    {
        for (i = 0; i < ProcessData->HandleTableSize; i++)
        {
            if (ProcessData->HandleTable[i].Object == NULL)
                break;
        }
    }
 
    if (i >= ProcessData->HandleTableSize)
    {
        /* Allocate a new handles table */
        Block = ConsoleAllocHeap(HEAP_ZERO_MEMORY,
                                 (ProcessData->HandleTableSize +
                                    IO_HANDLES_INCREMENT) * sizeof(CONSOLE_IO_HANDLE));
        if (Block == NULL)
        {
            // RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
            return STATUS_UNSUCCESSFUL;
        }
 
        /* If we previously had a handles table, free it and use the new one */
        if (ProcessData->HandleTable)
        {
            /* Copy the handles from the old table to the new one */
            RtlCopyMemory(Block,
                          ProcessData->HandleTable,
                          ProcessData->HandleTableSize * sizeof(CONSOLE_IO_HANDLE));
            ConsoleFreeHeap(ProcessData->HandleTable);
        }
        ProcessData->HandleTable = Block;
        ProcessData->HandleTableSize += IO_HANDLES_INCREMENT;
    }
 
    ProcessData->HandleTable[i].Object      = Object;
    ProcessData->HandleTable[i].Access      = Access;
    ProcessData->HandleTable[i].Inheritable = Inheritable;
    ProcessData->HandleTable[i].ShareMode   = ShareMode;
    AdjustHandleCounts(&ProcessData->HandleTable[i], +1);
    *Handle = ULongToHandle((i << 2) | 0x3);
 
    // RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
 
    return STATUS_SUCCESS;
}

Referenced by CON_API(), and ConSrvInitProcessHandles().

ConSrvReleaseObject()

VOID ConSrvReleaseObject	(	IN PCONSOLE_IO_OBJECT	Object,
		IN BOOLEAN	IsConsoleLocked
	)

Definition at line 382 of file handle.c.

{
    PCONSRV_CONSOLE ObjectConsole = (PCONSRV_CONSOLE)Object->Console;
    ConSrvReleaseConsole(ObjectConsole, IsConsoleLocked);
}

Referenced by CON_API().

ConSrvRemoveObject()

NTSTATUS ConSrvRemoveObject	(	IN PCONSOLE_PROCESS_DATA	ProcessData,
		IN HANDLE	Handle
	)

Definition at line 292 of file handle.c.

{
    ULONG Index = HandleToULong(Handle) >> 2;
 
    RtlEnterCriticalSection(&ProcessData->HandleTableLock);
 
    ASSERT(ProcessData->HandleTable);
    // ASSERT( (ProcessData->HandleTable == NULL && ProcessData->HandleTableSize == 0) ||
    //         (ProcessData->HandleTable != NULL && ProcessData->HandleTableSize != 0) );
 
    if (Index >= ProcessData->HandleTableSize ||
        ProcessData->HandleTable[Index].Object == NULL)
    {
        RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
        return STATUS_INVALID_HANDLE;
    }
 
    ASSERT(ProcessData->ConsoleHandle);
    ConSrvCloseHandle(&ProcessData->HandleTable[Index]);
 
    RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
    return STATUS_SUCCESS;
}

Referenced by CON_API().