api.h File Reference

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

Go to the source code of this file.

Functions
	CSR_API (BaseSrvCheckApplicationCompatibility)
VOID	BaseInitDefineDosDevice (VOID)
VOID	BaseCleanupDefineDosDevice (VOID)
	CSR_API (BaseSrvDefineDosDevice)
	CSR_API (BaseSrvGetTempFile)
	CSR_API (BaseSrvCreateProcess)
	CSR_API (BaseSrvCreateThread)
	CSR_API (BaseSrvExitProcess)
	CSR_API (BaseSrvGetProcessShutdownParam)
	CSR_API (BaseSrvSetProcessShutdownParam)
	CSR_API (BaseSrvDebugProcess)
	CSR_API (BaseSrvRegisterThread)
	CSR_API (BaseSrvSxsCreateActivationContext)
	CSR_API (BaseSrvSetTermsrvAppInstallMode)
	CSR_API (BaseSrvSetTermsrvClientTimeZone)
	CSR_API (BaseSrvSoundSentryNotification)
	CSR_API (BaseSrvCheckVDM)
	CSR_API (BaseSrvUpdateVDMEntry)
	CSR_API (BaseSrvGetNextVDMCommand)
	CSR_API (BaseSrvExitVDM)
	CSR_API (BaseSrvIsFirstVDM)
	CSR_API (BaseSrvGetVDMExitCode)
	CSR_API (BaseSrvSetReenterCount)
	CSR_API (BaseSrvSetVDMCurDirs)
	CSR_API (BaseSrvGetVDMCurDirs)
	CSR_API (BaseSrvBatNotification)
	CSR_API (BaseSrvRegisterWowExec)
	CSR_API (BaseSrvRefreshIniFileMapping)
VOID NTAPI	BaseSrvNLSInit (IN PBASE_STATIC_SERVER_DATA StaticData)
NTSTATUS NTAPI	BaseSrvNlsConnect (IN PCSR_PROCESS CsrProcess, IN OUT PVOID ConnectionInfo, IN OUT PULONG ConnectionInfoLength)
	CSR_API (BaseSrvNlsSetUserInfo)
	CSR_API (BaseSrvNlsSetMultipleUserInfo)
	CSR_API (BaseSrvNlsCreateSection)
	CSR_API (BaseSrvNlsUpdateCacheCount)
	CSR_API (BaseSrvNlsGetUserInfo)

Function Documentation

BaseCleanupDefineDosDevice()

VOID BaseCleanupDefineDosDevice

(

VOID

)

Definition at line 39 of file dosdev.c.

{
    RtlDeleteCriticalSection(&BaseDefineDosDeviceCritSec);
}

Referenced by DllMain().

BaseInitDefineDosDevice()

VOID BaseInitDefineDosDevice

(

VOID

)

Definition at line 34 of file dosdev.c.

{
    RtlInitializeCriticalSection(&BaseDefineDosDeviceCritSec);
}

Referenced by CSR_SERVER_DLL_INIT().

BaseSrvNlsConnect()

NTSTATUS NTAPI BaseSrvNlsConnect	(	IN PCSR_PROCESS	CsrProcess,
		IN OUT PVOID	ConnectionInfo,
		IN OUT PULONG	ConnectionInfoLength
	)

Definition at line 140 of file nls.c.

{
    /* Does nothing */
    return STATUS_SUCCESS;
}

Referenced by BaseClientConnectRoutine().

BaseSrvNLSInit()

VOID NTAPI BaseSrvNLSInit

(

IN PBASE_STATIC_SERVER_DATA

StaticData

)

Definition at line 117 of file nls.c.

{
    /* Initialize the lock */
    RtlInitializeCriticalSection(&NlsCacheCriticalSection);
 
    /* Initialize the data with all F's */
    pNlsRegUserInfo = &StaticData->NlsUserInfo;
    RtlFillMemory(&StaticData->NlsUserInfo, sizeof(StaticData->NlsUserInfo), 0xFF);
 
    /* Set empty LCID */
    pNlsRegUserInfo->UserLocaleId = 0;
 
    /* Reset the cache update counter */
    RtlEnterCriticalSection(&NlsCacheCriticalSection);
    pNlsRegUserInfo->ulCacheUpdateCount = 0;
    RtlLeaveCriticalSection(&NlsCacheCriticalSection);
 
    /* Get the LCID */
    NtQueryDefaultLocale(0, &pNlsRegUserInfo->UserLocaleId);
}

Referenced by BaseInitializeStaticServerData().

CSR_API() [1/31]

CSR_API

(

BaseSrvBatNotification

)

Definition at line 1441 of file vdm.c.

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

CSR_API() [2/31]

CSR_API

(

BaseSrvCheckApplicationCompatibility

)

Definition at line 56 of file appcompat.c.

{
    PBASE_APP_COMPAT_DATA AppCompatData = (PBASE_APP_COMPAT_DATA)&ApiMessage->Data;
    DPRINT1("BASESRV: BaseSrvCheckApplicationCompatibility(%wZ)\n",
           AppCompatData->FileName);
 
    AppCompatData->CheckRunAppResult = FALSE;
 
    return STATUS_SUCCESS;
}

CSR_API() [3/31]

CSR_API

(

BaseSrvCheckVDM

)

Definition at line 599 of file vdm.c.

{
    NTSTATUS Status;
    PBASE_CHECK_VDM CheckVdmRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.CheckVDMRequest;
    PRTL_CRITICAL_SECTION CriticalSection = NULL;
    PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
    PVDM_DOS_RECORD DosRecord = NULL;
    BOOLEAN NewConsoleRecord = FALSE;
    BOOLEAN NewDosRecord = FALSE;
 
    /* Don't do anything if the VDM has been disabled in the registry */
    if (!BaseSrvIsVdmAllowed()) return STATUS_VDM_DISALLOWED;
 
    /* Validate the message buffers */
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&CheckVdmRequest->CmdLine,
                                  CheckVdmRequest->CmdLen,
                                  sizeof(*CheckVdmRequest->CmdLine))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&CheckVdmRequest->AppName,
                                     CheckVdmRequest->AppLen,
                                     sizeof(*CheckVdmRequest->AppName))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&CheckVdmRequest->PifFile,
                                     CheckVdmRequest->PifLen,
                                     sizeof(*CheckVdmRequest->PifFile))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&CheckVdmRequest->CurDirectory,
                                     CheckVdmRequest->CurDirectoryLen,
                                     sizeof(*CheckVdmRequest->CurDirectory))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&CheckVdmRequest->Desktop,
                                     CheckVdmRequest->DesktopLen,
                                     sizeof(*CheckVdmRequest->Desktop))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&CheckVdmRequest->Title,
                                     CheckVdmRequest->TitleLen,
                                     sizeof(*CheckVdmRequest->Title))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&CheckVdmRequest->Reserved,
                                     CheckVdmRequest->ReservedLen,
                                     sizeof(*CheckVdmRequest->Reserved)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    CriticalSection = (CheckVdmRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
                      ? &DosCriticalSection
                      : &WowCriticalSection;
 
    /* Enter the critical section */
    RtlEnterCriticalSection(CriticalSection);
 
    /* Check if this is a DOS or WOW VDM */
    if (CheckVdmRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
    {
        /* Get the console record */
        Status = BaseSrvGetConsoleRecord(CheckVdmRequest->ConsoleHandle,
                                         &ConsoleRecord);
        if (!NT_SUCCESS(Status))
        {
            /* Allocate a new console record */
            ConsoleRecord = BaseSrvCreateConsoleRecord();
            if (ConsoleRecord == NULL)
            {
                Status = STATUS_NO_MEMORY;
                goto Cleanup;
            }
 
            /* Initialize the console record */
            ConsoleRecord->ConsoleHandle = CheckVdmRequest->ConsoleHandle;
            if (ConsoleRecord->ConsoleHandle == NULL)
            {
                /* The parent doesn't have a console, get a new session ID */
                ConsoleRecord->SessionId = GetNextDosSesId();
            }
            else
            {
                /* No session ID is needed */
                ConsoleRecord->SessionId = 0;
            }
 
            /* Remember that the console record was allocated here */
            NewConsoleRecord = TRUE;
        }
 
        if (!NewConsoleRecord)
        {
            /* Get the primary DOS record */
            DosRecord = (PVDM_DOS_RECORD)CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink,
                                                           VDM_DOS_RECORD, Entry);
 
            if (DosRecord->State != VDM_READY) // == VDM_NOT_READY
            {
                /* Allocate a new DOS record */
                DosRecord = (PVDM_DOS_RECORD)RtlAllocateHeap(BaseSrvHeap,
                                                             HEAP_ZERO_MEMORY,
                                                             sizeof(VDM_DOS_RECORD));
                if (DosRecord == NULL)
                {
                    Status = STATUS_NO_MEMORY;
                    goto Cleanup;
                }
 
                /* Remember that the DOS record was allocated here */
                NewDosRecord = TRUE;
            }
        }
        else
        {
            /* Allocate a new DOS record */
            DosRecord = (PVDM_DOS_RECORD)RtlAllocateHeap(BaseSrvHeap,
                                                         HEAP_ZERO_MEMORY,
                                                         sizeof(VDM_DOS_RECORD));
            if (DosRecord == NULL)
            {
                Status = STATUS_NO_MEMORY;
                goto Cleanup;
            }
 
            /* Remember that the DOS record was allocated here */
            NewDosRecord = TRUE;
        }
 
        /* Initialize the DOS record */
        DosRecord->State = VDM_NOT_READY;
        DosRecord->ExitCode = 0;
 
        /* Translate the input structure into a VDM command structure and set it in the DOS record */
        if (!BaseSrvCopyCommand(CheckVdmRequest, DosRecord))
        {
            /* The only possibility is that an allocation failure occurred */
            Status = STATUS_NO_MEMORY;
            goto Cleanup;
        }
 
        if (NewDosRecord)
        {
            /* Add the DOS record */
            InsertHeadList(&ConsoleRecord->DosListHead, &DosRecord->Entry);
        }
 
        if (!NewConsoleRecord)
        {
            Status = BaseSrvCreatePairWaitHandles(&DosRecord->ServerEvent, &DosRecord->ClientEvent);
            if (!NT_SUCCESS(Status)) goto Cleanup;
 
            /* Return the client event handle */
            CheckVdmRequest->WaitObjectForParent = DosRecord->ClientEvent;
        }
 
        // FIXME: We may notify ONLY if ConsoleRecord->nReEntrancy is > 0
        // in case NewConsoleRecord == FALSE AND NewDosRecord == TRUE.
        if (ConsoleRecord->ServerEvent)
        {
            /* Signal the session event */
            NtSetEvent(ConsoleRecord->ServerEvent, NULL);
        }
 
        if (NewConsoleRecord)
        {
            /* Add the console record */
            InsertTailList(&VDMConsoleListHead, &ConsoleRecord->Entry);
        }
 
        CheckVdmRequest->iTask = ConsoleRecord->SessionId;
        CheckVdmRequest->VDMState = NewConsoleRecord ? VDM_NOT_LOADED : VDM_READY;
        Status = STATUS_SUCCESS;
    }
    else
    {
        // TODO: NOT IMPLEMENTED
        UNIMPLEMENTED;
        Status = STATUS_NOT_IMPLEMENTED;
    }
 
Cleanup:
    /* Check if it failed */
    if (!NT_SUCCESS(Status))
    {
        /* Free the DOS record if it was allocated here */
        if (NewDosRecord)
        {
            ASSERT(DosRecord != NULL);
 
            BaseSrvDestroyPairWaitHandles(DosRecord->ServerEvent,
                                          DosRecord->ClientEvent);
 
            RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
            DosRecord = NULL;
        }
 
        /* Free the console record if it was allocated here */
        if (NewConsoleRecord)
        {
            ASSERT(ConsoleRecord != NULL);
 
            RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord);
            ConsoleRecord = NULL;
        }
    }
 
    /* Leave the critical section */
    RtlLeaveCriticalSection(CriticalSection);
 
    return Status;
}

CSR_API() [4/31]

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() [5/31]

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() [6/31]

CSR_API

(

BaseSrvDebugProcess

)

Definition at line 24 of file proc.c.

{
    /* Deprecated */
    return STATUS_UNSUCCESSFUL;
}

CSR_API() [7/31]

CSR_API

(

BaseSrvDefineDosDevice

)

Definition at line 474 of file dosdev.c.

{
    NTSTATUS Status;
    PBASE_DEFINE_DOS_DEVICE DefineDosDeviceRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.DefineDosDeviceRequest;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE LinkHandle;
    UNICODE_STRING DeviceName = {0};
    UNICODE_STRING LinkTarget = {0};
    ULONG Length;
    SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};
    SID_IDENTIFIER_AUTHORITY SystemAuthority = {SECURITY_NT_AUTHORITY};
    PSID SystemSid;
    PSID WorldSid;
    PWSTR lpBuffer;
    WCHAR Letter;
    SHORT AbsLetter;
    BOOLEAN DriveLetter = FALSE;
    BOOLEAN RemoveDefinition;
    BOOLEAN HandleTarget;
    BOOLEAN Broadcast = FALSE;
    BOOLEAN IsGlobal = FALSE;
    ULONG CchLengthLeft;
    ULONG CchLength;
    ULONG TargetLength;
    PWSTR TargetBuffer;
    PWSTR CurrentBuffer;
    /* We store them on the stack, they are known in advance */
    union {
        SECURITY_DESCRIPTOR SecurityDescriptor;
        UCHAR Buffer[20];
    } SecurityDescriptor;
    union {
        ACL Dacl;
        UCHAR Buffer[256];
    } Dacl;
    ACCESS_MASK AccessMask;
    LUID CallerLuid;
    WCHAR * CurrentPtr;
    WCHAR CurrentChar;
    PWSTR OrigPtr;
    PWSTR InterPtr;
    BOOLEAN RemoveFound;
 
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&DefineDosDeviceRequest->DeviceName.Buffer,
                                  DefineDosDeviceRequest->DeviceName.Length,
                                  sizeof(BYTE)) ||
        (DefineDosDeviceRequest->DeviceName.Length & 1) != 0 ||
        !CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&DefineDosDeviceRequest->TargetPath.Buffer,
                                  DefineDosDeviceRequest->TargetPath.Length +
                                    (DefineDosDeviceRequest->TargetPath.Length != 0
                                        ? sizeof(UNICODE_NULL) : 0),
                                  sizeof(BYTE)) ||
        (DefineDosDeviceRequest->TargetPath.Length & 1) != 0)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    DPRINT("BaseSrvDefineDosDevice entered, Flags:%d, DeviceName:%wZ (%d), TargetPath:%wZ (%d)\n",
           DefineDosDeviceRequest->Flags,
           &DefineDosDeviceRequest->DeviceName,
           DefineDosDeviceRequest->DeviceName.Length,
           &DefineDosDeviceRequest->TargetPath,
           DefineDosDeviceRequest->TargetPath.Length);
 
    /*
     * Allocate a buffer big enough to contain:
     * - device name
     * - targets
     */
    lpBuffer = RtlAllocateHeap(BaseSrvHeap, 0, 0x2000);
    if (lpBuffer == NULL)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Enter our critical section */
    Status = RtlEnterCriticalSection(&BaseDefineDosDeviceCritSec);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("RtlEnterCriticalSection() failed (Status %lx)\n",
                Status);
        RtlFreeHeap(BaseSrvHeap, 0, lpBuffer);
        return Status;
    }
 
    LinkHandle = 0;
    /* Does the caller wants to remove definition? */
    RemoveDefinition = !!(DefineDosDeviceRequest->Flags & DDD_REMOVE_DEFINITION);
    _SEH2_TRY
    {
        /* First of all, check if that's a drive letter device amongst LUID mappings */
        if (BaseStaticServerData->LUIDDeviceMapsEnabled && !(DefineDosDeviceRequest->Flags & DDD_NO_BROADCAST_SYSTEM))
        {
            if (DefineDosDeviceRequest->DeviceName.Buffer != NULL &&
                DefineDosDeviceRequest->DeviceName.Length == 2 * sizeof(WCHAR) &&
                DefineDosDeviceRequest->DeviceName.Buffer[1] == L':')
            {
                Letter = DefineDosDeviceRequest->DeviceName.Buffer[0];
 
                /* Handle both lower cases and upper cases */
                AbsLetter = Letter - L'a';
                if (AbsLetter < 26 && AbsLetter >= 0)
                {
                    Letter = RtlUpcaseUnicodeChar(Letter);
                }
 
                AbsLetter = Letter - L'A';
                if (AbsLetter < 26)
                {
                    /* That's a letter! */
                    DriveLetter = TRUE;
                }
            }
        }
 
        /* We can only broadcast drive letters in case of LUID mappings */
        if (DefineDosDeviceRequest->Flags & DDD_LUID_BROADCAST_DRIVE &&
            !DriveLetter)
        {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        /* First usage of our buffer: create device name */
        CchLength = _snwprintf(lpBuffer, 0x1000, L"\\??\\%wZ", &DefineDosDeviceRequest->DeviceName);
        CchLengthLeft = 0x1000 - 1 - CchLength; /* UNICODE_NULL */
        CurrentBuffer = lpBuffer + CchLength + 1; /* UNICODE_NULL */
        RtlInitUnicodeString(&DeviceName, lpBuffer);
 
        /* And prepare to open it */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &DeviceName,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
 
        /* Assume it's OK and has a target to deal with */
        HandleTarget = TRUE;
 
        /* Move to the client context if the mapping was local */
        if (!CsrImpersonateClient(NULL))
        {
            Status = STATUS_BAD_IMPERSONATION_LEVEL;
            _SEH2_LEAVE;
        }
 
        /*
         * While impersonating the caller, also get its LUID.
         * This is mandatory in case we have a driver letter,
         * Because we're in the case we've got LUID mapping
         * enabled and broadcasting enabled. LUID will be required
         * for the latter
         */
        if (DriveLetter)
        {
            Status = GetCallerLuid(&CallerLuid);
            if (NT_SUCCESS(Status))
            {
                Broadcast = TRUE;
            }
        }
 
        /* Now, open the device */
        Status = NtOpenSymbolicLinkObject(&LinkHandle,
                                          DELETE | SYMBOLIC_LINK_QUERY,
                                          &ObjectAttributes);
 
        /* And get back to our context */
        CsrRevertToSelf();
 
        /* In case of LUID broadcast, do nothing but return to trigger broadcast */
        if (DefineDosDeviceRequest->Flags & DDD_LUID_BROADCAST_DRIVE)
        {
            /* Zero handle in case of a failure */
            if (!NT_SUCCESS(Status))
            {
                LinkHandle = 0;
            }
 
            /* If removal was asked, and no object found: the remval was successful */
            if (RemoveDefinition && Status == STATUS_OBJECT_NAME_NOT_FOUND)
            {
                Status = STATUS_SUCCESS;
            }
 
            /* We're done here, nothing more to do */
            _SEH2_LEAVE;
        }
 
        /* If device was not found */
        if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
        {
            /* No handle */
            LinkHandle = 0;
 
            /* If we were asked to remove... */
            if (RemoveDefinition)
            {
                /*
                 * If caller asked to pop first entry, nothing specific,
                 * then, we can consider this as a success
                 */
                if (DefineDosDeviceRequest->TargetPath.Length == 0)
                {
                    Status = STATUS_SUCCESS;
                }
 
                /* We're done, nothing to change */
                _SEH2_LEAVE;
            }
 
            /* There's no target to handle */
            HandleTarget = FALSE;
 
            /*
             * We'll consider, that's a success
             * Failing to open the device doesn't prevent
             * from creating it later on to create
             * the linking.
             */
            Status = STATUS_SUCCESS;
        }
        else
        {
            /* Unexpected failure, forward to caller */
            if (!NT_SUCCESS(Status))
            {
                _SEH2_LEAVE;
            }
 
            /* If LUID mapping enabled */
            if (BaseStaticServerData->LUIDDeviceMapsEnabled)
            {
                /* Check if that's global link */
                Status = IsGlobalSymbolicLink(LinkHandle, &IsGlobal);
                if (!NT_SUCCESS(Status))
                {
                    _SEH2_LEAVE;
                }
 
                /* If so, change our device name namespace to GLOBAL?? for link creation */
                if (IsGlobal)
                {
                    CchLength = _snwprintf(lpBuffer, 0x1000, L"\\GLOBAL??\\%wZ", &DefineDosDeviceRequest->DeviceName);
                    CchLengthLeft = 0x1000 - 1 - CchLength; /* UNICODE_NULL */
                    CurrentBuffer = lpBuffer + CchLength + 1; /* UNICODE_NULL */
 
                    DeviceName.Length = CchLength * sizeof(WCHAR);
                    DeviceName.MaximumLength = CchLength * sizeof(WCHAR) + sizeof(UNICODE_NULL);
                }
            }
        }
 
        /* If caller provided a target */
        if (DefineDosDeviceRequest->TargetPath.Length != 0)
        {
            /* Make sure it's null terminated */
            DefineDosDeviceRequest->TargetPath.Buffer[DefineDosDeviceRequest->TargetPath.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
            /* Compute its size */
            TargetLength = wcslen(DefineDosDeviceRequest->TargetPath.Buffer);
 
            /* And make sure it fits our buffer */
            if (TargetLength + 1 >= CchLengthLeft)
            {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            /* Copy it to our internal buffer */
            RtlMoveMemory(CurrentBuffer, DefineDosDeviceRequest->TargetPath.Buffer, TargetLength * sizeof(WCHAR) + sizeof(UNICODE_NULL));
            TargetBuffer = CurrentBuffer;
 
            /* Update our buffer status */
            CchLengthLeft -= (TargetLength + 1);
            CurrentBuffer += (TargetLength + 1);
        }
        /* Otherwise, zero everything */
        else
        {
            TargetBuffer = NULL;
            TargetLength = 0;
        }
 
        /* If we opened the device, then, handle its current target */
        if (HandleTarget)
        {
            /* Query it with our internal buffer */
            LinkTarget.Length = 0;
            LinkTarget.MaximumLength = CchLengthLeft * sizeof(WCHAR);
            LinkTarget.Buffer = CurrentBuffer;
 
            Status = NtQuerySymbolicLinkObject(LinkHandle,
                                               &LinkTarget,
                                               &Length);
            /* If we overflow, give up */
            if (Length == LinkTarget.MaximumLength)
            {
                Status = STATUS_BUFFER_OVERFLOW;
            }
            /* In case of a failure, bye bye */
            if (!NT_SUCCESS(Status))
            {
                _SEH2_LEAVE;
            }
 
            /*
             * Properly null it for MULTI_SZ if needed
             * Always update max length with
             * the need size
             * This is needed to hand relatively "small"
             * strings to Ob and avoid killing ourselves
             * on the next query
             */
            CchLength = Length / sizeof(WCHAR);
            if (CchLength < 2 ||
                CurrentBuffer[CchLength - 2] != UNICODE_NULL ||
                CurrentBuffer[CchLength - 1] != UNICODE_NULL)
            {
                CurrentBuffer[CchLength] = UNICODE_NULL;
                LinkTarget.MaximumLength = Length + sizeof(UNICODE_NULL);
            }
            else
            {
                LinkTarget.MaximumLength = Length;
            }
        }
        /* There's no target, and we're asked to remove, so null target */
        else if (RemoveDefinition)
        {
            RtlInitUnicodeString(&LinkTarget, NULL);
        }
        /* There's a target provided - new device, update buffer */
        else
        {
            RtlInitUnicodeString(&LinkTarget, CurrentBuffer - TargetLength - 1);
        }
 
        /*
         * We no longer need old symlink, just drop it, we'll recreate it now
         * with updated target.
         * The benefit of it is that if caller asked us to drop last target, then
         * the device is removed and not dangling
         */
        if (LinkHandle != 0)
        {
            Status = NtMakeTemporaryObject(LinkHandle);
            NtClose(LinkHandle);
            LinkHandle = 0;
        }
 
        /* At this point, we must have no failure */
        if (!NT_SUCCESS(Status))
        {
            _SEH2_LEAVE;
        }
 
        /*
         * If we have to remove definition, let's start to browse our
         * target to actually drop it.
         */
        if (RemoveDefinition)
        {
            /* We'll browse our multi sz string */
            RemoveFound = FALSE;
            CurrentPtr = LinkTarget.Buffer;
            InterPtr = LinkTarget.Buffer;
            while (*CurrentPtr != UNICODE_NULL)
            {
                CchLength = 0;
                OrigPtr = CurrentPtr;
                /* First, find next string */
                while (TRUE)
                {
                    CurrentChar = *CurrentPtr;
                    ++CurrentPtr;
 
                    if (CurrentChar == UNICODE_NULL)
                    {
                        break;
                    }
 
                    ++CchLength;
                }
 
                /* This check is a bit tricky, but dead useful:
                 * If on the previous loop, we found the caller provided target
                 * in our list, then, we'll move current entry over the found one
                 * So that, it gets deleted.
                 * Also, if we don't find caller entry in our entries, then move
                 * current entry in the string if a previous one got deleted
                 */
                if (RemoveFound ||
                    ((!(DefineDosDeviceRequest->Flags & DDD_EXACT_MATCH_ON_REMOVE) ||
                      TargetLength != CchLength || _wcsicmp(OrigPtr, TargetBuffer) != 0) &&
                     ((DefineDosDeviceRequest->Flags & DDD_EXACT_MATCH_ON_REMOVE) ||
                      (TargetLength != 0 && _wcsnicmp(OrigPtr, TargetBuffer, TargetLength) != 0))))
                {
                    if (InterPtr != OrigPtr)
                    {
                        RtlMoveMemory(InterPtr, OrigPtr, sizeof(WCHAR) * CchLength + sizeof(UNICODE_NULL));
                    }
 
                    InterPtr += (CchLength + 1);
                }
                else
                {
                    /* Match case! Remember for next loop turn and to delete it */
                    RemoveFound = TRUE;
                }
            }
 
            /*
             * Drop last entry, as required (pop)
             * If there was a match previously, everything
             * is already moved, so we're just nulling
             * the end of the string
             * If there was no match, this is the pop
             */
            *InterPtr = UNICODE_NULL;
            ++InterPtr;
 
            /* Compute new target length */
            TargetLength = wcslen(LinkTarget.Buffer) * sizeof(WCHAR);
            /*
             * If it's empty, quit
             * Beware, here, we quit with STATUS_SUCCESS, and that's expected!
             * In case we dropped last target entry, then, it's empty
             * and there's no need to recreate the device we deleted previously
             */
            if (TargetLength == 0)
            {
                _SEH2_LEAVE;
            }
 
            /* Update our target string */
            LinkTarget.Length = TargetLength;
            LinkTarget.MaximumLength = (ULONG_PTR)InterPtr - (ULONG_PTR)LinkTarget.Buffer;
        }
        /* If that's not a removal, just update the target to include new target */
        else if (HandleTarget)
        {
            LinkTarget.Buffer = LinkTarget.Buffer - TargetLength - 1;
            LinkTarget.Length = TargetLength * sizeof(WCHAR);
            LinkTarget.MaximumLength += (TargetLength * sizeof(WCHAR) + sizeof(UNICODE_NULL));
            TargetLength *= sizeof(WCHAR);
        }
        /* No changes */
        else
        {
            TargetLength = LinkTarget.Length;
        }
 
        /* Make sure we don't create empty symlink */
        if (TargetLength == 0)
        {
            _SEH2_LEAVE;
        }
 
        /* Initialize our SIDs for symlink ACLs */
        Status = RtlAllocateAndInitializeSid(&WorldAuthority,
                                             1,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             &WorldSid);
        if (!NT_SUCCESS(Status))
        {
            _SEH2_LEAVE;
        }
 
        Status = RtlAllocateAndInitializeSid(&SystemAuthority,
                                             1,
                                             SECURITY_RESTRICTED_CODE_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             SECURITY_NULL_RID,
                                             &SystemSid);
        if (!NT_SUCCESS(Status))
        {
            RtlFreeSid(WorldSid);
            _SEH2_LEAVE;
        }
 
        /* Initialize our SD (on stack) */
        RtlCreateSecurityDescriptor(&SecurityDescriptor,
                                    SECURITY_DESCRIPTOR_REVISION);
 
        /* And our ACL (still on stack) */
        RtlCreateAcl(&Dacl.Dacl, sizeof(Dacl), ACL_REVISION);
 
        /*
         * For access mask, if we have no session ID, or if
         * protection mode is disabled, make them wide open
         */
        if (SessionId == 0 ||
            (ProtectionMode & 3) == 0)
        {
            AccessMask = DELETE | SYMBOLIC_LINK_QUERY;
        }
        else
        {
            AccessMask = SYMBOLIC_LINK_QUERY;
        }
 
        /* Setup the ACL */
        RtlAddAccessAllowedAce(&Dacl.Dacl, ACL_REVISION2, AccessMask, WorldSid);
        RtlAddAccessAllowedAce(&Dacl.Dacl, ACL_REVISION2, AccessMask, SystemSid);
 
        /* Drop SIDs */
        RtlFreeSid(WorldSid);
        RtlFreeSid(SystemSid);
 
        /* Link DACL to the SD */
        RtlSetDaclSecurityDescriptor(&SecurityDescriptor, TRUE, &Dacl.Dacl, TRUE);
 
        /* And set it in the OA used for creation */
        ObjectAttributes.SecurityDescriptor = &SecurityDescriptor;
 
        /*
         * If LUID and not global, we need to impersonate the caller
         * to make it local.
         */
        if (BaseStaticServerData->LUIDDeviceMapsEnabled)
        {
            if (!IsGlobal)
            {
                if (!CsrImpersonateClient(NULL))
                {
                    Status = STATUS_BAD_IMPERSONATION_LEVEL;
                    _SEH2_LEAVE;
                }
            }
        }
        /* The object will be permanent */
        else
        {
            ObjectAttributes.Attributes |= OBJ_PERMANENT;
        }
 
        /* (Re)Create the symbolic link/device */
        Status = NtCreateSymbolicLinkObject(&LinkHandle,
                                            SYMBOLIC_LINK_ALL_ACCESS,
                                            &ObjectAttributes,
                                            &LinkTarget);
 
        /* Revert to self if required */
        if (BaseStaticServerData->LUIDDeviceMapsEnabled && !IsGlobal)
        {
            CsrRevertToSelf();
        }
 
        /* In case of a success, make object permanent for LUID links */
        if (NT_SUCCESS(Status))
        {
            if (BaseStaticServerData->LUIDDeviceMapsEnabled)
            {
                Status = NtMakePermanentObject(LinkHandle);
            }
 
            /* Close the link */
            NtClose(LinkHandle);
 
            /*
             * Specific failure case here:
             * We were asked to remove something
             * but we didn't find the something
             * (we recreated the symlink hence the fail here!)
             * so fail with appropriate status
             */
            if (RemoveDefinition && !RemoveFound)
            {
                Status = STATUS_OBJECT_NAME_NOT_FOUND;
            }
        }
 
        /* We closed link, don't double close */
        LinkHandle = 0;
    }
    _SEH2_FINALLY
    {
        /* If we need to close the link, do it now */
        if (LinkHandle != 0)
        {
             NtClose(LinkHandle);
        }
 
        /* Free our internal buffer */
        RtlFreeHeap(BaseSrvHeap, 0, lpBuffer);
 
        /* Broadcast drive letter creation */
        if (DriveLetter && Status == STATUS_SUCCESS && Broadcast)
        {
            LUID SystemLuid = SYSTEM_LUID;
 
            /* If that's a global drive, broadcast as system */
            if (IsGlobal)
            {
                RtlCopyLuid(&CallerLuid, &SystemLuid);
            }
 
            /* Broadcast the event */
            AddBSMRequest(AbsLetter, RemoveDefinition, &CallerLuid);
 
            /*
             * If we removed drive, and the drive was shadowing a global one
             * broadcast the arrival of the global drive (as system - global)
             */
            if (RemoveDefinition && !RtlEqualLuid(&CallerLuid, &SystemLuid))
            {
                if (CheckForGlobalDriveLetter(AbsLetter))
                {
                    AddBSMRequest(AbsLetter, FALSE, &CallerLuid);
                }
            }
        }
 
        /* Done! */
        RtlLeaveCriticalSection(&BaseDefineDosDeviceCritSec);
    }
    _SEH2_END;
 
    return Status;
}

CSR_API() [8/31]

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() [9/31]

CSR_API

(

BaseSrvExitVDM

)

Definition at line 1164 of file vdm.c.

{
    NTSTATUS Status;
    PBASE_EXIT_VDM ExitVdmRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.ExitVDMRequest;
    PRTL_CRITICAL_SECTION CriticalSection = NULL;
    PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
    PVDM_DOS_RECORD DosRecord;
 
    CriticalSection = (ExitVdmRequest->iWowTask == 0)
                      ? &DosCriticalSection
                      : &WowCriticalSection;
 
    /* Enter the critical section */
    RtlEnterCriticalSection(CriticalSection);
 
    if (ExitVdmRequest->iWowTask == 0)
    {
        /* Get the console record */
        Status = BaseSrvGetConsoleRecord(ExitVdmRequest->ConsoleHandle, &ConsoleRecord);
        if (!NT_SUCCESS(Status)) goto Cleanup;
 
        if (ConsoleRecord->ServerEvent)
            ExitVdmRequest->WaitObjectForVDM = ConsoleRecord->ClientEvent;
 
        // NOTE: The following is the same as in BaseSrvCleanupVDMResources.
 
        if (ConsoleRecord->ServerEvent)
        {
            NtClose(ConsoleRecord->ServerEvent);
            ConsoleRecord->ServerEvent = NULL;
        }
 
        /* Cleanup the DOS records */
        while (!IsListEmpty(&ConsoleRecord->DosListHead))
        {
            DosRecord = CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink,
                                          VDM_DOS_RECORD, Entry);
 
            /* Set the event and close it */
            if (DosRecord->ServerEvent)
            {
                NtSetEvent(DosRecord->ServerEvent, NULL);
                NtClose(DosRecord->ServerEvent);
                DosRecord->ServerEvent = NULL;
            }
 
            /* Remove the DOS entry */
            if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
            RemoveEntryList(&DosRecord->Entry);
            RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
        }
 
        /* Remove the console record */
        RemoveEntryList(&ConsoleRecord->Entry);
        BaseSrvDestroyConsoleRecord(ConsoleRecord);
    }
    else
    {
        // TODO: NOT IMPLEMENTED
        UNIMPLEMENTED;
        Status = STATUS_NOT_IMPLEMENTED;
    }
 
Cleanup:
    /* Leave the critical section */
    RtlLeaveCriticalSection(CriticalSection);
 
    return Status;
}

CSR_API() [10/31]

CSR_API

(

BaseSrvGetNextVDMCommand

)

Definition at line 933 of file vdm.c.

{
    NTSTATUS Status;
    PBASE_GET_NEXT_VDM_COMMAND GetNextVdmCommandRequest =
        &((PBASE_API_MESSAGE)ApiMessage)->Data.GetNextVDMCommandRequest;
    PRTL_CRITICAL_SECTION CriticalSection;
    PLIST_ENTRY i = NULL;
    PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
    PVDM_DOS_RECORD DosRecord = NULL;
 
    /* Validate the message buffers */
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&GetNextVdmCommandRequest->CmdLine,
                                  GetNextVdmCommandRequest->CmdLen,
                                  sizeof(*GetNextVdmCommandRequest->CmdLine))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&GetNextVdmCommandRequest->AppName,
                                     GetNextVdmCommandRequest->AppLen,
                                     sizeof(*GetNextVdmCommandRequest->AppName))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&GetNextVdmCommandRequest->PifFile,
                                     GetNextVdmCommandRequest->PifLen,
                                     sizeof(*GetNextVdmCommandRequest->PifFile))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&GetNextVdmCommandRequest->CurDirectory,
                                     GetNextVdmCommandRequest->CurDirectoryLen,
                                     sizeof(*GetNextVdmCommandRequest->CurDirectory))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&GetNextVdmCommandRequest->Env,
                                     GetNextVdmCommandRequest->EnvLen,
                                     sizeof(*GetNextVdmCommandRequest->Env))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&GetNextVdmCommandRequest->Desktop,
                                     GetNextVdmCommandRequest->DesktopLen,
                                     sizeof(*GetNextVdmCommandRequest->Desktop))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&GetNextVdmCommandRequest->Title,
                                     GetNextVdmCommandRequest->TitleLen,
                                     sizeof(*GetNextVdmCommandRequest->Title))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&GetNextVdmCommandRequest->Reserved,
                                     GetNextVdmCommandRequest->ReservedLen,
                                     sizeof(*GetNextVdmCommandRequest->Reserved))
        || !CsrValidateMessageBuffer(ApiMessage,
                                     (PVOID*)&GetNextVdmCommandRequest->StartupInfo,
                                     1,
                                     sizeof(STARTUPINFOA)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    CriticalSection = (GetNextVdmCommandRequest->VDMState & VDM_FLAG_WOW)
                      ? &WowCriticalSection
                      : &DosCriticalSection;
 
    /* Enter the critical section */
    RtlEnterCriticalSection(CriticalSection);
 
    if (GetNextVdmCommandRequest->VDMState & VDM_FLAG_WOW)
    {
        // TODO: WOW SUPPORT NOT IMPLEMENTED
        UNIMPLEMENTED;
        Status = STATUS_NOT_IMPLEMENTED;
        goto Cleanup;
    }
    // else if (!(GetNextVdmCommandRequest->VDMState & VDM_FLAG_WOW))
    {
        if (GetNextVdmCommandRequest->iTask != 0)
        {
            /* Get the console record using the task ID */
            Status = GetConsoleRecordBySessionId(GetNextVdmCommandRequest->iTask,
                                                 &ConsoleRecord);
        }
        else
        {
            /* Get the console record using the console handle */
            Status = BaseSrvGetConsoleRecord(GetNextVdmCommandRequest->ConsoleHandle,
                                             &ConsoleRecord);
        }
 
        /* Make sure we found the console record */
        if (!NT_SUCCESS(Status)) goto Cleanup;
 
        /* Return the session ID */
        GetNextVdmCommandRequest->iTask = ConsoleRecord->SessionId;
        GetNextVdmCommandRequest->WaitObjectForVDM = NULL;
 
        if (GetNextVdmCommandRequest->VDMState & VDM_GET_FIRST_COMMAND)
        {
            /* Check if the DOS record list is empty */
            if (ConsoleRecord->DosListHead.Flink == &ConsoleRecord->DosListHead)
            {
                Status = STATUS_INVALID_PARAMETER;
                goto Cleanup;
            }
 
            /* Get the first DOS record */
            DosRecord = CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink, VDM_DOS_RECORD, Entry);
 
            /* Make sure its command information is still there */
            if (DosRecord->CommandInfo == NULL)
            {
                Status = STATUS_INVALID_PARAMETER;
                goto Cleanup;
            }
 
            /* Check if the console handle hasn't been set yet */
            if (ConsoleRecord->ConsoleHandle == NULL)
            {
                /* Set it now */
                ConsoleRecord->ConsoleHandle = GetNextVdmCommandRequest->ConsoleHandle;
            }
 
            /* Fill the command information */
            Status = BaseSrvFillCommandInfo(DosRecord->CommandInfo, GetNextVdmCommandRequest);
            goto Cleanup;
        }
 
        /* Check if we should set the state of a running DOS record to ready */
        if (!(GetNextVdmCommandRequest->VDMState
            & (VDM_FLAG_FIRST_TASK | VDM_FLAG_RETRY | VDM_FLAG_NESTED_TASK)))
        {
            /* Search for a DOS record that is currently running */
            for (i = ConsoleRecord->DosListHead.Flink; i != &ConsoleRecord->DosListHead; i = i->Flink)
            {
                DosRecord = CONTAINING_RECORD(i, VDM_DOS_RECORD, Entry);
                if (DosRecord->State == VDM_NOT_READY) break;
            }
 
            /* Check if we found any */
            if (i == &ConsoleRecord->DosListHead)
            {
                Status = STATUS_INVALID_PARAMETER;
                goto Cleanup;
            }
 
            /* Set the exit code */
            DosRecord->ExitCode = GetNextVdmCommandRequest->ExitCode;
 
            /* Update the VDM state */
            DosRecord->State = VDM_READY;
 
            /* Notify all waiting threads that the task is finished */
            NtSetEvent(DosRecord->ServerEvent, NULL);
            NtClose(DosRecord->ServerEvent);
            DosRecord->ServerEvent = NULL;
        }
 
        /* Search for a DOS record that is currently running and has command information */
        for (i = ConsoleRecord->DosListHead.Flink; i != &ConsoleRecord->DosListHead; i = i->Flink)
        {
            DosRecord = CONTAINING_RECORD(i, VDM_DOS_RECORD, Entry);
            if ((DosRecord->State == VDM_NOT_READY) && (DosRecord->CommandInfo != NULL)) break;
        }
 
        /* Check if we found any */
        if (i != &ConsoleRecord->DosListHead)
        {
            ASSERT(DosRecord->CommandInfo != NULL);
 
            /* Check if the caller only wants environment data */
            if (GetNextVdmCommandRequest->VDMState & VDM_GET_ENVIRONMENT)
            {
                if (GetNextVdmCommandRequest->EnvLen < DosRecord->CommandInfo->EnvLen)
                {
                    /* Not enough space was reserved */
                    GetNextVdmCommandRequest->EnvLen = DosRecord->CommandInfo->EnvLen;
                    Status = STATUS_BUFFER_OVERFLOW;
                    goto Cleanup;
                }
 
                /* Copy the environment data */
                RtlMoveMemory(GetNextVdmCommandRequest->Env,
                              DosRecord->CommandInfo->Env,
                              DosRecord->CommandInfo->EnvLen);
 
                /* Return the actual size to the caller */
                GetNextVdmCommandRequest->EnvLen = DosRecord->CommandInfo->EnvLen;
            }
            else
            {
                /* Fill the command information */
                Status = BaseSrvFillCommandInfo(DosRecord->CommandInfo, GetNextVdmCommandRequest);
                if (!NT_SUCCESS(Status)) goto Cleanup;
 
                /* Free the command information, it's no longer needed */
                BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
                DosRecord->CommandInfo = NULL;
 
                /* Update the VDM state */
                DosRecord->State = VDM_NOT_READY;
            }
 
            Status = STATUS_SUCCESS;
            goto Cleanup;
        }
    }
 
    GetNextVdmCommandRequest->WaitObjectForVDM = NULL;
 
    /*
     * There is no command yet. Prepare for waiting if we asked so,
     * and if we were not retrying a request.
     */
    if (!(GetNextVdmCommandRequest->VDMState & VDM_FLAG_DONT_WAIT) ||
        !(GetNextVdmCommandRequest->VDMState & VDM_FLAG_RETRY))
    {
        if (ConsoleRecord->ServerEvent)
        {
            /* Reset the event */
            NtResetEvent(ConsoleRecord->ServerEvent, NULL);
        }
        else
        {
            /* Create a pair of wait handles */
            Status = BaseSrvCreatePairWaitHandles(&ConsoleRecord->ServerEvent,
                                                  &ConsoleRecord->ClientEvent);
            if (!NT_SUCCESS(Status)) goto Cleanup;
        }
 
        /* Return the client event handle */
        GetNextVdmCommandRequest->WaitObjectForVDM = ConsoleRecord->ClientEvent;
    }
 
Cleanup:
    /* Leave the critical section */
    RtlLeaveCriticalSection(CriticalSection);
 
    return Status;
}

CSR_API() [11/31]

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() [12/31]

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() [13/31]

CSR_API

(

BaseSrvGetVDMCurDirs

)

Definition at line 1397 of file vdm.c.

{
    NTSTATUS Status;
    PBASE_GETSET_VDM_CURDIRS VDMCurrentDirsRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.VDMCurrentDirsRequest;
    PVDM_CONSOLE_RECORD ConsoleRecord;
 
    /* Validate the output buffer */
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&VDMCurrentDirsRequest->lpszzCurDirs,
                                  VDMCurrentDirsRequest->cchCurDirs,
                                  sizeof(*VDMCurrentDirsRequest->lpszzCurDirs)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Enter the critical section */
    RtlEnterCriticalSection(&DosCriticalSection);
 
    /* Find the console record */
    Status = BaseSrvGetConsoleRecord(VDMCurrentDirsRequest->ConsoleHandle, &ConsoleRecord);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Return the actual size of the current directory information */
    VDMCurrentDirsRequest->cchCurDirs = ConsoleRecord->CurDirsLength;
 
    /* Check if the buffer is large enough */
    if (VDMCurrentDirsRequest->cchCurDirs < ConsoleRecord->CurDirsLength)
    {
        Status = STATUS_BUFFER_TOO_SMALL;
        goto Cleanup;
    }
 
    /* Copy the data */
    RtlMoveMemory(VDMCurrentDirsRequest->lpszzCurDirs,
                  ConsoleRecord->CurrentDirs,
                  ConsoleRecord->CurDirsLength);
 
Cleanup:
    /* Leave the critical section */
    RtlLeaveCriticalSection(&DosCriticalSection);
 
    return Status;
}

CSR_API() [14/31]

CSR_API

(

BaseSrvGetVDMExitCode

)

Definition at line 1247 of file vdm.c.

{
    NTSTATUS Status;
    PBASE_GET_VDM_EXIT_CODE GetVDMExitCodeRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.GetVDMExitCodeRequest;
    PLIST_ENTRY i = NULL;
    PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
    PVDM_DOS_RECORD DosRecord = NULL;
 
    /* Enter the critical section */
    RtlEnterCriticalSection(&DosCriticalSection);
 
    /* Get the console record */
    Status = BaseSrvGetConsoleRecord(GetVDMExitCodeRequest->ConsoleHandle, &ConsoleRecord);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Search for a DOS record that has the same parent process handle */
    for (i = ConsoleRecord->DosListHead.Flink; i != &ConsoleRecord->DosListHead; i = i->Flink)
    {
        DosRecord = CONTAINING_RECORD(i, VDM_DOS_RECORD, Entry);
        if (DosRecord->ClientEvent == GetVDMExitCodeRequest->hParent) break;
    }
 
    /* Check if no DOS record was found */
    if (i == &ConsoleRecord->DosListHead)
    {
        Status = STATUS_NOT_FOUND;
        goto Cleanup;
    }
 
    /* Check if this task is still running */
    if (DosRecord->State != VDM_READY)
    {
        GetVDMExitCodeRequest->ExitCode = STATUS_PENDING;
        goto Cleanup;
    }
 
    /* Return the exit code */
    GetVDMExitCodeRequest->ExitCode = DosRecord->ExitCode;
 
    // FIXME: We may just change DosRecord->State to VDM_READY in some cases...
 
    /* Since this is a zombie task record, remove it */
    if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
    RemoveEntryList(&DosRecord->Entry);
    RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
 
Cleanup:
    /* Leave the critical section */
    RtlLeaveCriticalSection(&DosCriticalSection);
 
    return Status;
}

CSR_API() [15/31]

CSR_API

(

BaseSrvIsFirstVDM

)

Definition at line 1234 of file vdm.c.

{
    PBASE_IS_FIRST_VDM IsFirstVDMRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.IsFirstVDMRequest;
 
    /* Return the result */
    IsFirstVDMRequest->FirstVDM = FirstVDM;
 
    /* Clear the first VDM flag */
    FirstVDM = FALSE;
 
    return STATUS_SUCCESS;
}

CSR_API() [16/31]

CSR_API

(

BaseSrvNlsCreateSection

)

Definition at line 162 of file nls.c.

{
    NTSTATUS Status;
    HANDLE SectionHandle, ProcessHandle, FileHandle;
    ULONG LocaleId;
    UNICODE_STRING NlsSectionName;
    PWCHAR NlsFileName;
    UCHAR SecurityDescriptor[NLS_SECTION_SECURITY_DESCRIPTOR_SIZE];
    OBJECT_ATTRIBUTES ObjectAttributes;
    WCHAR FileNameBuffer[32];
    WCHAR NlsSectionNameBuffer[32];
    PBASE_NLS_CREATE_SECTION NlsMsg = &((PBASE_API_MESSAGE)ApiMessage)->Data.NlsCreateSection;
 
    /* Load kernel32 first and import the NLS routines */
    Status = BaseSrvDelayLoadKernel32();
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Assume failure */
    NlsMsg->SectionHandle = NULL;
 
    /* Check and validate the locale ID, if one is present */
    LocaleId = NlsMsg->LocaleId;
    DPRINT1("NLS: Create Section with LCID: %lx for Type: %d\n", LocaleId, NlsMsg->Type);
    if (LocaleId)
    {
        if (!pValidateLocale(LocaleId)) return STATUS_INVALID_PARAMETER;
    }
 
    /* Check which NLS section is being created */
    switch (NlsMsg->Type)
    {
        /* For each one, set the correct filename and object name */
        case 1:
            RtlInitUnicodeString(&NlsSectionName, L"\\NLS\\NlsSectionUnicode");
            NlsFileName = L"unicode.nls";
            break;
        case 2:
            RtlInitUnicodeString(&NlsSectionName, L"\\NLS\\NlsSectionLocale");
            NlsFileName =  L"locale.nls";
            break;
        case 3:
            RtlInitUnicodeString(&NlsSectionName, L"\\NLS\\NlsSectionCType");
            NlsFileName = L"ctype.nls";
            break;
        case 4:
            RtlInitUnicodeString(&NlsSectionName, L"\\NLS\\NlsSectionSortkey");
            NlsFileName = L"sortkey.nls";
            break;
        case 5:
            RtlInitUnicodeString(&NlsSectionName, L"\\NLS\\NlsSectionSortTbls");
            NlsFileName = L"sorttbls.nls";
            break;
        case 6:
            RtlInitUnicodeString(&NlsSectionName, L"\\NLS\\NlsSectionCP437");
            NlsFileName = L"c_437.nls";
            break;
        case 7:
            RtlInitUnicodeString(&NlsSectionName, L"\\NLS\\NlsSectionCP1252");
            NlsFileName = L"c_1252.nls";
            break;
        case 8:
            RtlInitUnicodeString(&NlsSectionName, L"\\NLS\\NlsSectionLANG_EXCEPT");
            NlsFileName = L"l_except.nls";
            break;
        case 9:
            DPRINT1("This type not yet supported\n");
            return STATUS_NOT_IMPLEMENTED;
        case 10:
            DPRINT1("This type not yet supported\n");
            return STATUS_NOT_IMPLEMENTED;
        case 11:
            /* Get the filename for this locale */
            if (!pGetCPFileNameFromRegistry(NlsMsg->LocaleId,
                                            FileNameBuffer,
                                            RTL_NUMBER_OF(FileNameBuffer)))
            {
                DPRINT1("File name query failed\n");
                return STATUS_INVALID_PARAMETER;
            }
 
            /* Get the name of the section for this locale */
            DPRINT1("File name: %S\n", FileNameBuffer);
            Status = pGetNlsSectionName(NlsMsg->LocaleId,
                                        10,
                                        0,
                                        L"\\NLS\\NlsSectionCP",
                                        NlsSectionNameBuffer,
                                        RTL_NUMBER_OF(NlsSectionNameBuffer));
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Section name query failed: %lx\n", Status);
                return Status;
            }
 
            /* Setup the name and go open it */
            NlsFileName = FileNameBuffer;
            DPRINT1("Section name: %S\n", NlsSectionNameBuffer);
            RtlInitUnicodeString(&NlsSectionName, NlsSectionNameBuffer);
            break;
        case 12:
            RtlInitUnicodeString(&NlsSectionName, L"\\NLS\\NlsSectionGeo");
            NlsFileName = L"geo.nls";
            break;
        default:
            DPRINT1("NLS: Invalid NLS type!\n");
            return STATUS_INVALID_PARAMETER;
    }
 
    /* Open the specified NLS file */
    Status = pOpenDataFile(&FileHandle, NlsFileName);
    if (Status != STATUS_SUCCESS)
    {
        DPRINT1("NLS: Failed to open file: %lx\n", Status);
        return Status;
    }
 
    /* Create an SD for the section object */
    Status = pCreateNlsSecurityDescriptor(&SecurityDescriptor,
                                          sizeof(SecurityDescriptor),
                                          SECTION_MAP_READ);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NLS: CreateNlsSecurityDescriptor FAILED!: %lx\n", Status);
        NtClose(FileHandle);
        return Status;
    }
 
    /* Create the section object proper */
    InitializeObjectAttributes(&ObjectAttributes,
                               &NlsSectionName,
                               OBJ_CASE_INSENSITIVE | OBJ_PERMANENT | OBJ_OPENIF,
                               NULL,
                               &SecurityDescriptor);
    Status = NtCreateSection(&SectionHandle,
                             SECTION_MAP_READ,
                             &ObjectAttributes,
                             0,
                             PAGE_READONLY,
                             SEC_COMMIT,
                             FileHandle);
    NtClose(FileHandle);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NLS: Failed to create section! %lx\n", Status);
        return Status;
    }
 
    /* Open a handle to the calling process */
    InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
    Status = NtOpenProcess(&ProcessHandle,
                           PROCESS_DUP_HANDLE,
                           &ObjectAttributes,
                           &ApiMessage->Header.ClientId);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NLS: Failed to open process! %lx\n", Status);
        NtClose(SectionHandle);
        return Status;
    }
 
    /* Duplicate the handle to the section object into it */
    Status = NtDuplicateObject(NtCurrentProcess(),
                               SectionHandle,
                               ProcessHandle,
                               &NlsMsg->SectionHandle,
                               0,
                               0,
                               3);
    NtClose(ProcessHandle);
    return Status;
}

CSR_API() [17/31]

CSR_API

(

BaseSrvNlsGetUserInfo

)

Definition at line 340 of file nls.c.

{
    NTSTATUS Status;
    PBASE_NLS_GET_USER_INFO NlsMsg = &((PBASE_API_MESSAGE)ApiMessage)->Data.NlsGetUserInfo;
 
    /* Make sure the buffer is valid and of the right size */
    if ((CsrValidateMessageBuffer(ApiMessage, &NlsMsg->NlsUserInfo, NlsMsg->Size, sizeof(BYTE))) &&
        (NlsMsg->Size == sizeof(NLS_USER_INFO)))
    {
        /* Acquire the lock to prevent updates while we copy */
        Status = RtlEnterCriticalSection(&NlsCacheCriticalSection);
        if (NT_SUCCESS(Status))
        {
            /* Do the copy now, then drop the lock */
            RtlCopyMemory(NlsMsg->NlsUserInfo, pNlsRegUserInfo, NlsMsg->Size);
            DPRINT1("NLS Data copy complete\n");
            RtlLeaveCriticalSection(&NlsCacheCriticalSection);
        }
    }
    else
    {
        /* The data was invalid, bail out */
        DPRINT1("NLS: Size of info is invalid: %lx vs %lx\n", NlsMsg->Size, sizeof(NLS_USER_INFO));
        Status = STATUS_INVALID_PARAMETER;
    }
 
    /* All done */
    return Status;
}

CSR_API() [18/31]

CSR_API

(

BaseSrvNlsSetMultipleUserInfo

)

Definition at line 156 of file nls.c.

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

CSR_API() [19/31]

CSR_API

(

BaseSrvNlsSetUserInfo

)

Definition at line 150 of file nls.c.

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

CSR_API() [20/31]

CSR_API

(

BaseSrvNlsUpdateCacheCount

)

Definition at line 334 of file nls.c.

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

CSR_API() [21/31]

CSR_API

(

BaseSrvRefreshIniFileMapping

)

Definition at line 1453 of file vdm.c.

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

CSR_API() [22/31]

CSR_API

(

BaseSrvRegisterThread

)

Definition at line 30 of file proc.c.

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

CSR_API() [23/31]

CSR_API

(

BaseSrvRegisterWowExec

)

Definition at line 1447 of file vdm.c.

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

CSR_API() [24/31]

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() [25/31]

CSR_API

(

BaseSrvSetReenterCount

)

Definition at line 1300 of file vdm.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PBASE_SET_REENTER_COUNT SetReenterCountRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.SetReenterCountRequest;
    PVDM_CONSOLE_RECORD ConsoleRecord;
 
    /* Enter the critical section */
    RtlEnterCriticalSection(&DosCriticalSection);
 
    /* Get the console record */
    Status = BaseSrvGetConsoleRecord(SetReenterCountRequest->ConsoleHandle, &ConsoleRecord);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    if (SetReenterCountRequest->fIncDec == VDM_INC_REENTER_COUNT)
    {
        ConsoleRecord->ReenterCount++;
    }
    else if (SetReenterCountRequest->fIncDec == VDM_DEC_REENTER_COUNT)
    {
        ConsoleRecord->ReenterCount--;
        if (ConsoleRecord->ServerEvent)
            NtSetEvent(ConsoleRecord->ServerEvent, NULL);
    }
    else
    {
        Status = STATUS_INVALID_PARAMETER;
    }
 
Cleanup:
    /* Leave the critical section */
    RtlLeaveCriticalSection(&DosCriticalSection);
 
    return Status;
}

CSR_API() [26/31]

CSR_API

(

BaseSrvSetTermsrvAppInstallMode

)

Definition at line 42 of file proc.c.

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

CSR_API() [27/31]

CSR_API

(

BaseSrvSetTermsrvClientTimeZone

)

Definition at line 48 of file proc.c.

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

CSR_API() [28/31]

CSR_API

(

BaseSrvSetVDMCurDirs

)

Definition at line 1335 of file vdm.c.

{
    NTSTATUS Status;
    PBASE_GETSET_VDM_CURDIRS VDMCurrentDirsRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.VDMCurrentDirsRequest;
    PVDM_CONSOLE_RECORD ConsoleRecord;
    PCHAR Buffer = NULL;
 
    /* Validate the input buffer */
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&VDMCurrentDirsRequest->lpszzCurDirs,
                                  VDMCurrentDirsRequest->cchCurDirs,
                                  sizeof(*VDMCurrentDirsRequest->lpszzCurDirs)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Enter the critical section */
    RtlEnterCriticalSection(&DosCriticalSection);
 
    /* Find the console record */
    Status = BaseSrvGetConsoleRecord(VDMCurrentDirsRequest->ConsoleHandle, &ConsoleRecord);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    if (ConsoleRecord->CurrentDirs == NULL)
    {
        /* Allocate memory for the current directory information */
        Buffer = RtlAllocateHeap(BaseSrvHeap,
                                 HEAP_ZERO_MEMORY,
                                 VDMCurrentDirsRequest->cchCurDirs);
    }
    else
    {
        /* Resize the amount of allocated memory */
        Buffer = RtlReAllocateHeap(BaseSrvHeap,
                                   HEAP_ZERO_MEMORY,
                                   ConsoleRecord->CurrentDirs,
                                   VDMCurrentDirsRequest->cchCurDirs);
    }
 
    if (Buffer == NULL)
    {
        /* Allocation failed */
        Status = STATUS_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Update the console record */
    ConsoleRecord->CurrentDirs = Buffer;
    ConsoleRecord->CurDirsLength = VDMCurrentDirsRequest->cchCurDirs;
 
    /* Copy the data */
    RtlMoveMemory(ConsoleRecord->CurrentDirs,
                  VDMCurrentDirsRequest->lpszzCurDirs,
                  VDMCurrentDirsRequest->cchCurDirs);
 
Cleanup:
    /* Leave the critical section */
    RtlLeaveCriticalSection(&DosCriticalSection);
 
    return Status;
}

CSR_API() [29/31]

CSR_API

(

BaseSrvSoundSentryNotification

)

Definition at line 61 of file sndsntry.c.

{
    /* Call the API and see if it succeeds */
    return (_UserSoundSentry() ? STATUS_SUCCESS : STATUS_ACCESS_DENIED);
}

CSR_API() [30/31]

CSR_API

(

BaseSrvSxsCreateActivationContext

)

Definition at line 36 of file proc.c.

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

CSR_API() [31/31]

CSR_API

(

BaseSrvUpdateVDMEntry

)

Definition at line 807 of file vdm.c.

{
    NTSTATUS Status;
    PBASE_UPDATE_VDM_ENTRY UpdateVdmEntryRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.UpdateVDMEntryRequest;
    PRTL_CRITICAL_SECTION CriticalSection = NULL;
    PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
    PVDM_DOS_RECORD DosRecord = NULL;
 
    CriticalSection = (UpdateVdmEntryRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
                      ? &DosCriticalSection
                      : &WowCriticalSection;
 
    /* Enter the critical section */
    RtlEnterCriticalSection(CriticalSection);
 
    /* Check if this is a DOS or WOW VDM */
    if (UpdateVdmEntryRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
    {
        if (UpdateVdmEntryRequest->iTask != 0)
        {
            /* Get the console record using the task ID */
            Status = GetConsoleRecordBySessionId(UpdateVdmEntryRequest->iTask,
                                                 &ConsoleRecord);
        }
        else
        {
            /* Get the console record using the console handle */
            Status = BaseSrvGetConsoleRecord(UpdateVdmEntryRequest->ConsoleHandle,
                                             &ConsoleRecord);
        }
 
        if (!NT_SUCCESS(Status)) goto Cleanup;
 
        /* Get the primary DOS record */
        DosRecord = (PVDM_DOS_RECORD)CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink,
                                                       VDM_DOS_RECORD, Entry);
 
        switch (UpdateVdmEntryRequest->EntryIndex)
        {
            case VdmEntryUndo:
            {
                /* Close the server event handle, the client will close the client handle */
                NtClose(DosRecord->ServerEvent);
                DosRecord->ServerEvent = DosRecord->ClientEvent = NULL;
 
                if (UpdateVdmEntryRequest->VDMCreationState & (VDM_UNDO_PARTIAL | VDM_UNDO_FULL))
                {
                    /* Remove the DOS record */
                    if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
                    RemoveEntryList(&DosRecord->Entry);
                    RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
 
                    /*
                     * Since this is an undo, if that was the only DOS record the VDM
                     * won't even start, so the console record should be removed too.
                     */
                    if (ConsoleRecord->DosListHead.Flink == &ConsoleRecord->DosListHead)
                    {
                        RemoveEntryList(&ConsoleRecord->Entry);
                        BaseSrvDestroyConsoleRecord(ConsoleRecord);
                    }
                }
 
                /* It was successful */
                Status = STATUS_SUCCESS;
 
                break;
            }
 
            case VdmEntryUpdateProcess:
            {
                /* Duplicate the VDM process handle */
                Status = NtDuplicateObject(CsrGetClientThread()->Process->ProcessHandle,
                                           UpdateVdmEntryRequest->VDMProcessHandle,
                                           NtCurrentProcess(),
                                           &ConsoleRecord->ProcessHandle,
                                           0,
                                           0,
                                           DUPLICATE_SAME_ATTRIBUTES | DUPLICATE_SAME_ACCESS);
                if (!NT_SUCCESS(Status)) goto Cleanup;
 
                //
                // FIXME! Should we always do the following??
                //
 
                /* Create a pair of handles to one event object */
                Status = BaseSrvCreatePairWaitHandles(&DosRecord->ServerEvent,
                                                      &DosRecord->ClientEvent);
                if (!NT_SUCCESS(Status)) goto Cleanup;
 
                /* Return the client event handle */
                UpdateVdmEntryRequest->WaitObjectForParent = DosRecord->ClientEvent;
 
                break;
            }
 
            case VdmEntryUpdateControlCHandler:
            {
                // TODO: NOT IMPLEMENTED
                DPRINT1("BaseSrvUpdateVDMEntry: VdmEntryUpdateControlCHandler not implemented\n");
                Status = STATUS_NOT_IMPLEMENTED;
 
                break;
            }
 
            default:
            {
                /* Invalid */
                Status = STATUS_INVALID_PARAMETER;
            }
        }
    }
    else
    {
        // TODO: NOT IMPLEMENTED
        UNIMPLEMENTED;
        Status = STATUS_NOT_IMPLEMENTED;
    }
 
Cleanup:
    /* Leave the critical section */
    RtlLeaveCriticalSection(CriticalSection);
 
    return Status;
}