proc.c File Reference

#include "basesrv.h"
#include "vdm.h"
#include <debug.h>

Include dependency graph for proc.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
	CSR_API (BaseSrvDebugProcess)
	CSR_API (BaseSrvRegisterThread)
	CSR_API (BaseSrvSxsCreateActivationContext)
	CSR_API (BaseSrvSetTermsrvAppInstallMode)
	CSR_API (BaseSrvSetTermsrvClientTimeZone)
	CSR_API (BaseSrvGetTempFile)
	CSR_API (BaseSrvCreateProcess)
	CSR_API (BaseSrvCreateThread)
	CSR_API (BaseSrvExitProcess)
	CSR_API (BaseSrvGetProcessShutdownParam)
	CSR_API (BaseSrvSetProcessShutdownParam)
VOID NTAPI	BaseSetProcessCreateNotify (IN BASE_PROCESS_CREATE_NOTIFY_ROUTINE ProcessCreateNotifyProc)

Variables
static BASE_PROCESS_CREATE_NOTIFY_ROUTINE	UserNotifyProcessCreate = NULL

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file proc.c.

Function Documentation

BaseSetProcessCreateNotify()

VOID NTAPI BaseSetProcessCreateNotify

(

IN BASE_PROCESS_CREATE_NOTIFY_ROUTINE

ProcessCreateNotifyProc

)

Definition at line 321 of file proc.c.

{
    /* Set the user notification procedure to be called when a process is created */
    UserNotifyProcessCreate = ProcessCreateNotifyProc;
}

Referenced by CSR_SERVER_DLL_INIT().

CSR_API() [1/11]

CSR_API

(

BaseSrvCreateProcess

)

Definition at line 67 of file proc.c.

{
    NTSTATUS Status;
    PBASE_CREATE_PROCESS CreateProcessRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.CreateProcessRequest;
    HANDLE ProcessHandle, ThreadHandle;
    PCSR_THREAD CsrThread;
    PCSR_PROCESS Process;
    ULONG Flags = 0, DebugFlags = 0, VdmPower = 0;
 
    /* Get the current client thread */
    CsrThread = CsrGetClientThread();
    ASSERT(CsrThread != NULL);
 
    Process = CsrThread->Process;
 
    /* Extract the flags out of the process handle */
    Flags = (ULONG_PTR)CreateProcessRequest->ProcessHandle & 3;
    CreateProcessRequest->ProcessHandle = (HANDLE)((ULONG_PTR)CreateProcessRequest->ProcessHandle & ~3);
 
    /* Some things should be done if this is a VDM process */
    if (CreateProcessRequest->VdmBinaryType)
    {
        /* We need to set the VDM power later on */
        VdmPower = 1;
    }
 
    /* Duplicate the process handle */
    Status = NtDuplicateObject(Process->ProcessHandle,
                               CreateProcessRequest->ProcessHandle,
                               NtCurrentProcess(),
                               &ProcessHandle,
                               0,
                               0,
                               DUPLICATE_SAME_ACCESS);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to duplicate process handle: %lx\n", Status);
        return Status;
    }
 
    /* Duplicate the thread handle */
    Status = NtDuplicateObject(Process->ProcessHandle,
                               CreateProcessRequest->ThreadHandle,
                               NtCurrentProcess(),
                               &ThreadHandle,
                               0,
                               0,
                               DUPLICATE_SAME_ACCESS);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to duplicate thread handle: %lx\n", Status);
        NtClose(ProcessHandle);
        return Status;
    }
 
    /* If this is a VDM process, request VDM power */
    if (VdmPower)
    {
        Status = NtSetInformationProcess(ProcessHandle,
                                         ProcessWx86Information,
                                         &VdmPower,
                                         sizeof(VdmPower));
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to get VDM powers\n");
            NtClose(ProcessHandle);
            NtClose(ThreadHandle);
            return Status;
        }
    }
 
    /* Flags conversion. FIXME: More need conversion */
    if (CreateProcessRequest->CreationFlags & CREATE_NEW_PROCESS_GROUP)
    {
        DebugFlags |= CsrProcessCreateNewGroup;
    }
    if ((Flags & 2) == 0)
    {
        /* We are launching a console process */
        DebugFlags |= CsrProcessIsConsoleApp;
    }
 
    /* FIXME: SxS Stuff */
 
    /* Call CSRSRV to create the CSR_PROCESS structure and the first CSR_THREAD */
    Status = CsrCreateProcess(ProcessHandle,
                              ThreadHandle,
                              &CreateProcessRequest->ClientId,
                              Process->NtSession,
                              DebugFlags,
                              NULL);
    if (Status == STATUS_THREAD_IS_TERMINATING)
    {
        DPRINT1("Thread already dead\n");
 
        /* Set the special reply value so we don't reply this message back */
        *ReplyCode = CsrReplyDeadClient;
 
        return Status;
    }
 
    /* Check for other failures */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create process/thread structures: %lx\n", Status);
        return Status;
    }
 
    /* Call the user notification procedure */
    if (UserNotifyProcessCreate)
    {
        UserNotifyProcessCreate(CreateProcessRequest->ClientId.UniqueProcess,
                                Process->ClientId.UniqueThread,
                                0,
                                Flags);
    }
 
    /* Check if this is a VDM process */
    if (CreateProcessRequest->VdmBinaryType)
    {
        PVDM_CONSOLE_RECORD ConsoleRecord;
 
        if (CreateProcessRequest->VdmTask != 0)
        {
            /* Get the console record using the task ID */
            Status = GetConsoleRecordBySessionId(CreateProcessRequest->VdmTask,
                                                 &ConsoleRecord);
        }
        else
        {
            /* Get the console record using the console handle */
            Status = BaseSrvGetConsoleRecord(CreateProcessRequest->hVDM,
                                             &ConsoleRecord);
        }
 
        /* Check if it failed */
        if (!NT_SUCCESS(Status)) return Status;
 
        /* Store the process ID of the VDM in the console record */
        ConsoleRecord->ProcessId = HandleToUlong(CreateProcessRequest->ClientId.UniqueProcess);
    }
 
    /* Return the result of this operation */
    return Status;
}

CSR_API() [2/11]

CSR_API

(

BaseSrvCreateThread

)

Definition at line 213 of file proc.c.

{
    NTSTATUS Status;
    PBASE_CREATE_THREAD CreateThreadRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.CreateThreadRequest;
    PCSR_THREAD CurrentThread;
    HANDLE ThreadHandle;
    PCSR_PROCESS CsrProcess;
 
    /* Get the current CSR thread */
    CurrentThread = CsrGetClientThread();
    if (!CurrentThread)
    {
        DPRINT1("Server Thread TID: [%lx.%lx]\n",
                CreateThreadRequest->ClientId.UniqueProcess,
                CreateThreadRequest->ClientId.UniqueThread);
        return STATUS_SUCCESS; // server-to-server
    }
 
    /* Get the CSR Process for this request */
    CsrProcess = CurrentThread->Process;
    if (CsrProcess->ClientId.UniqueProcess !=
        CreateThreadRequest->ClientId.UniqueProcess)
    {
        /* This is a remote thread request -- is it within the server itself? */
        if (CreateThreadRequest->ClientId.UniqueProcess == NtCurrentTeb()->ClientId.UniqueProcess)
        {
            /* Accept this without any further work */
            return STATUS_SUCCESS;
        }
 
        /* Get the real CSR Process for the remote thread's process */
        Status = CsrLockProcessByClientId(CreateThreadRequest->ClientId.UniqueProcess,
                                          &CsrProcess);
        if (!NT_SUCCESS(Status)) return Status;
    }
 
    /* Duplicate the thread handle so we can own it */
    Status = NtDuplicateObject(CurrentThread->Process->ProcessHandle,
                               CreateThreadRequest->ThreadHandle,
                               NtCurrentProcess(),
                               &ThreadHandle,
                               0,
                               0,
                               DUPLICATE_SAME_ACCESS);
    if (NT_SUCCESS(Status))
    {
        /* Call CSRSRV to tell it about the new thread */
        Status = CsrCreateThread(CsrProcess,
                                 ThreadHandle,
                                 &CreateThreadRequest->ClientId,
                                 TRUE);
    }
 
    /* Unlock the process and return */
    if (CsrProcess != CurrentThread->Process) CsrUnlockProcess(CsrProcess);
    return Status;
}

CSR_API() [3/11]

CSR_API

(

BaseSrvDebugProcess

)

Definition at line 24 of file proc.c.

{
    /* Deprecated */
    return STATUS_UNSUCCESSFUL;
}

CSR_API() [4/11]

CSR_API

(

BaseSrvExitProcess

)

Definition at line 271 of file proc.c.

{
    PCSR_THREAD CsrThread = CsrGetClientThread();
    ASSERT(CsrThread != NULL);
 
    /* Set the special reply value so we don't reply this message back */
    *ReplyCode = CsrReplyDeadClient;
 
    /* Remove the CSR_THREADs and CSR_PROCESS */
    return CsrDestroyProcess(&CsrThread->ClientId,
                             (NTSTATUS)((PBASE_API_MESSAGE)ApiMessage)->Data.ExitProcessRequest.uExitCode);
}

CSR_API() [5/11]

CSR_API

(

BaseSrvGetProcessShutdownParam

)

Definition at line 284 of file proc.c.

{
    PBASE_GETSET_PROCESS_SHUTDOWN_PARAMS ShutdownParametersRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.ShutdownParametersRequest;
    PCSR_THREAD CsrThread = CsrGetClientThread();
    ASSERT(CsrThread);
 
    ShutdownParametersRequest->ShutdownLevel = CsrThread->Process->ShutdownLevel;
    /* Only SHUTDOWN_NORETRY flag is valid for this API. The other private flags are for CSRSRV/WINSRV only. */
    ShutdownParametersRequest->ShutdownFlags = CsrThread->Process->ShutdownFlags & SHUTDOWN_NORETRY;
 
    return STATUS_SUCCESS;
}

CSR_API() [6/11]

CSR_API

(

BaseSrvGetTempFile

)

Definition at line 54 of file proc.c.

{
    static UINT BaseGetTempFileUnique = 0;
    PBASE_GET_TEMP_FILE GetTempFile = &((PBASE_API_MESSAGE)ApiMessage)->Data.GetTempFileRequest;
 
    /* Return 16-bits ID */
    GetTempFile->UniqueID = (++BaseGetTempFileUnique & 0xFFFF);
 
    DPRINT("Returning: %u\n", GetTempFile->UniqueID);
 
    return GetTempFile->UniqueID;
}

CSR_API() [7/11]

CSR_API

(

BaseSrvRegisterThread

)

Definition at line 30 of file proc.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

CSR_API() [8/11]

CSR_API

(

BaseSrvSetProcessShutdownParam

)

Definition at line 297 of file proc.c.

{
    PBASE_GETSET_PROCESS_SHUTDOWN_PARAMS ShutdownParametersRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.ShutdownParametersRequest;
    PCSR_THREAD CsrThread = CsrGetClientThread();
    ASSERT(CsrThread);
 
    /* Only SHUTDOWN_NORETRY flag is valid for this API. The other private flags are for CSRSRV/WINSRV only. */
    if (ShutdownParametersRequest->ShutdownFlags & ~SHUTDOWN_NORETRY)
    {
        /* If there were other flags specified, fail the call */
        return STATUS_INVALID_PARAMETER;
    }
 
    CsrThread->Process->ShutdownLevel = ShutdownParametersRequest->ShutdownLevel;
    /* Notice that all the possible other private flags are reinitialized here */
    CsrThread->Process->ShutdownFlags = ShutdownParametersRequest->ShutdownFlags;
 
    return STATUS_SUCCESS;
}

CSR_API() [9/11]

CSR_API

(

BaseSrvSetTermsrvAppInstallMode

)

Definition at line 42 of file proc.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

CSR_API() [10/11]

CSR_API

(

BaseSrvSetTermsrvClientTimeZone

)

Definition at line 48 of file proc.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

CSR_API() [11/11]

CSR_API

(

BaseSrvSxsCreateActivationContext

)

Definition at line 36 of file proc.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

Variable Documentation

UserNotifyProcessCreate

BASE_PROCESS_CREATE_NOTIFY_ROUTINE UserNotifyProcessCreate = NULL

static

Definition at line 20 of file proc.c.

Referenced by BaseSetProcessCreateNotify(), and CSR_API().