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

Functions
BOOL NTAPI	_UserSoundSentry (VOID)

	CSR_API (SrvCreateSystemThreads)

	CSR_API (SrvActivateDebugger)

	CSR_API (SrvGetThreadConsoleDesktop)

	CSR_API (SrvDeviceEvent)

VOID NTAPI	UserServerHardError (IN PCSR_THREAD ThreadData, IN PHARDERROR_MSG Message)

	CSR_API (SrvRegisterServicesProcess)

	CSR_API (SrvRegisterLogonProcess)

ULONG NTAPI	UserClientShutdown (IN PCSR_PROCESS CsrProcess, IN ULONG Flags, IN BOOLEAN FirstPhase)

	CSR_API (SrvExitWindowsEx)

	CSR_API (SrvEndTask)

	CSR_API (SrvLogon)

	CSR_API (SrvRecordShutdownReason)

Function Documentation

◆ _UserSoundSentry()

BOOL NTAPI _UserSoundSentry ( VOID )

Definition at line 107 of file init.c.

{
    // TODO: Do something.
    return TRUE;
}

◆ CSR_API() [1/10]

CSR_API ( SrvActivateDebugger )

Definition at line 135 of file init.c.

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

◆ CSR_API() [2/10]

CSR_API ( SrvCreateSystemThreads )

Definition at line 123 of file init.c.

{
    NTSTATUS Status = CsrExecServerThread(CreateSystemThreads, 0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Cannot start system thread!\n");
    }
 
    return Status;
}

◆ CSR_API() [3/10]

CSR_API ( SrvDeviceEvent )

Definition at line 160 of file init.c.

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

◆ CSR_API() [4/10]

CSR_API ( SrvEndTask )

Definition at line 827 of file shutdown.c.

{
    PUSER_END_TASK EndTaskRequest = &((PUSER_API_MESSAGE)ApiMessage)->Data.EndTaskRequest;
    NTSTATUS Status;
 
    // FIXME: This is HACK-plemented!!
    DPRINT1("SrvEndTask is HACKPLEMENTED!!\n");
 
    Status = NtUserSetInformationThread(NtCurrentThread(),
                                        UserThreadUseActiveDesktop,
                                        NULL,
                                        0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to set thread desktop!\n");
        return Status;
    }
 
    SendMessageW(EndTaskRequest->WndHandle, WM_CLOSE, 0, 0);
    // PostMessageW(EndTaskRequest->WndHandle, WM_CLOSE, 0, 0);
 
    if (IsWindow(EndTaskRequest->WndHandle))
    {
        if (EndTaskRequest->Force)
        {
            EndTaskRequest->Success   = DestroyWindow(EndTaskRequest->WndHandle);
            EndTaskRequest->LastError = GetLastError();
        }
        else
        {
            EndTaskRequest->Success = FALSE;
        }
    }
    else
    {
        EndTaskRequest->Success   = TRUE;
        EndTaskRequest->LastError = ERROR_SUCCESS;
    }
 
    NtUserSetInformationThread(NtCurrentThread(), UserThreadRestoreDesktop, NULL, 0);
 
    return STATUS_SUCCESS;
}

◆ CSR_API() [5/10]

CSR_API ( SrvExitWindowsEx )

Definition at line 802 of file shutdown.c.

{
    NTSTATUS Status;
    PUSER_EXIT_REACTOS ExitReactOSRequest = &((PUSER_API_MESSAGE)ApiMessage)->Data.ExitReactOSRequest;
 
    Status = NtUserSetInformationThread(NtCurrentThread(),
                                        UserThreadUseActiveDesktop,
                                        NULL,
                                        0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to set thread desktop!\n");
        return Status;
    }
 
    Status = UserExitReactOS(CsrGetClientThread(), ExitReactOSRequest->Flags);
    ExitReactOSRequest->Success   = NT_SUCCESS(Status);
    ExitReactOSRequest->LastError = GetLastError();
 
    NtUserSetInformationThread(NtCurrentThread(), UserThreadRestoreDesktop, NULL, 0);
 
    return Status;
}

◆ CSR_API() [6/10]

CSR_API ( SrvGetThreadConsoleDesktop )

Definition at line 142 of file init.c.

{
    NTSTATUS Status;
    PUSER_GET_THREAD_CONSOLE_DESKTOP GetThreadConsoleDesktopRequest = &((PUSER_API_MESSAGE)ApiMessage)->Data.GetThreadConsoleDesktopRequest;
 
    Status = GetThreadConsoleDesktop(GetThreadConsoleDesktopRequest->ThreadId,
                                     &GetThreadConsoleDesktopRequest->ConsoleDesktop);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("GetThreadConsoleDesktop(%lu) failed with Status 0x%08x\n",
                GetThreadConsoleDesktopRequest->ThreadId, Status);
    }
 
    /* Windows-compatibility: Always return success since User32 relies on this! */
    return STATUS_SUCCESS;
}

◆ CSR_API() [7/10]

CSR_API ( SrvLogon )

Definition at line 167 of file init.c.

{
    PUSER_LOGON LogonRequest = &((PUSER_API_MESSAGE)ApiMessage)->Data.LogonRequest;
 
    DPRINT1("We are logged %s\n", LogonRequest->IsLogon ? "on" : "off");
 
    /* Impersonate the caller in order to retrieve settings in its context */
    if (!CsrImpersonateClient(NULL))
        return STATUS_UNSUCCESSFUL;
 
    GetTimeouts(&ShutdownSettings);
 
    /* We are done */
    CsrRevertToSelf();
    return STATUS_SUCCESS;
}

◆ CSR_API() [8/10]

CSR_API ( SrvRecordShutdownReason )

Definition at line 872 of file shutdown.c.

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

◆ CSR_API() [9/10]

CSR_API ( SrvRegisterLogonProcess )

Definition at line 30 of file register.c.

{
    PUSER_REGISTER_LOGON_PROCESS RegisterLogonProcessRequest = &((PUSER_API_MESSAGE)ApiMessage)->Data.RegisterLogonProcessRequest;
 
    if (RegisterLogonProcessRequest->Register)
    {
        if (LogonProcessId != 0)
            return STATUS_LOGON_SESSION_EXISTS;
 
        LogonProcessId = RegisterLogonProcessRequest->ProcessId;
    }
    else
    {
        if (ApiMessage->Header.ClientId.UniqueProcess != UlongToHandle(LogonProcessId))
        {
            DPRINT1("Current logon process 0x%x, can't deregister from process 0x%x\n",
                    LogonProcessId, ApiMessage->Header.ClientId.UniqueProcess);
            return STATUS_NOT_LOGON_PROCESS;
        }
 
        LogonProcessId = 0;
    }
 
#if 1 //HAAAACK. This should be done in UserClientConnect which is never called!
 
    /* Check if we don't have an API port yet */
    if (CsrApiPort == NULL)
    {
        NTSTATUS Status;
 
        /* Query the API port and save it globally */
        CsrApiPort = CsrQueryApiPort();
 
        DPRINT("Giving win32k our api port\n");
 
        /* Inform win32k about the API port */
        Status = NtUserSetInformationThread(NtCurrentThread(),
                                            UserThreadCsrApiPort,
                                            &CsrApiPort,
                                            sizeof(CsrApiPort));
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
#endif
 
    return STATUS_SUCCESS;
}

◆ CSR_API() [10/10]

CSR_API ( SrvRegisterServicesProcess )

Definition at line 81 of file register.c.

{
    PUSER_REGISTER_SERVICES_PROCESS RegisterServicesProcessRequest = &((PUSER_API_MESSAGE)ApiMessage)->Data.RegisterServicesProcessRequest;
 
    if (ServicesProcessIdValid)
    {
        /* Only accept a single call */
        return STATUS_INVALID_PARAMETER;
    }
    else
    {
        ServicesProcessId = RegisterServicesProcessRequest->ProcessId;
        ServicesProcessIdValid = TRUE;
        return STATUS_SUCCESS;
    }
}

◆ UserClientShutdown()

ULONG NTAPI UserClientShutdown	(	IN PCSR_PROCESS	CsrProcess,
		IN ULONG	Flags,
		IN BOOLEAN	FirstPhase
	)

Definition at line 732 of file shutdown.c.

{
    ULONG result;
 
    DPRINT("UserClientShutdown(0x%p, 0x%x, %s) - [0x%x, 0x%x], ShutdownFlags: %lu\n",
            CsrProcess, Flags, FirstPhase ? "FirstPhase" : "LastPhase",
            CsrProcess->ClientId.UniqueProcess, CsrProcess->ClientId.UniqueThread,
            CsrProcess->ShutdownFlags);
 
    /*
     * Check for process validity
     */
 
    /* Do not kill system processes when a user is logging off */
    if ((Flags & EWX_SHUTDOWN) == EWX_LOGOFF &&
        (CsrProcess->ShutdownFlags & (SHUTDOWN_OTHERCONTEXT | SHUTDOWN_SYSTEMCONTEXT)))
    {
        DPRINT("Do not kill a system process in a logoff request!\n");
        return CsrShutdownNonCsrProcess;
    }
 
    /* Do not kill Winlogon */
    if (CsrProcess->ClientId.UniqueProcess == UlongToHandle(LogonProcessId))
    {
        DPRINT("Not killing Winlogon; CsrProcess->ShutdownFlags = %lu\n",
               CsrProcess->ShutdownFlags);
 
        /* Returning CsrShutdownCsrProcess means that we handled this process by doing nothing */
        /* This will mark winlogon as processed so consrv won't be notified again for it */
        CsrDereferenceProcess(CsrProcess);
        return CsrShutdownCsrProcess;
    }
 
    /* Notify the process for shutdown if needed */
    result = NotifyUserProcessForShutdown(CsrProcess, &ShutdownSettings, Flags);
    if (result == CsrShutdownCancelled || result == CsrShutdownNonCsrProcess)
    {
        if (result == CsrShutdownCancelled)
            DPRINT1("Process 0x%x aborted shutdown\n", CsrProcess->ClientId.UniqueProcess);
        return result;
    }
 
    /* Terminate this process */
#if DBG
    {
        WCHAR buffer[MAX_PATH];
        if (!GetProcessImageFileNameW(CsrProcess->ProcessHandle, buffer, ARRAYSIZE(buffer)))
        {
            DPRINT1("Terminating process %x\n", CsrProcess->ClientId.UniqueProcess);
        }
        else
        {
            DPRINT1("Terminating process %x (%S)\n", CsrProcess->ClientId.UniqueProcess, buffer);
        }
    }
#endif
    NtTerminateProcess(CsrProcess->ProcessHandle, 0);
    WaitForSingleObject(CsrProcess->ProcessHandle, ShutdownSettings.ProcessTerminateTimeout);
 
    /* We are done */
    CsrDereferenceProcess(CsrProcess);
    return CsrShutdownCsrProcess;
}

Referenced by CSR_SERVER_DLL_INIT().

◆ UserServerHardError()

VOID NTAPI UserServerHardError	(	IN PCSR_THREAD	ThreadData,
		IN PHARDERROR_MSG	Message
	)

Definition at line 1082 of file harderror.c.

{
    ULONG ErrorMode;
    UINT  dwType = 0;
    ULONG Timeout = INFINITE;
    UNICODE_STRING TextU, CaptionU;
    WCHAR LocalTextBuffer[256];
    WCHAR LocalCaptionBuffer[256];
    NTSTATUS Status;
 
    ASSERT(ThreadData->Process != NULL);
 
    /* Default to not handled */
    Message->Response = ResponseNotHandled;
 
    /* Make sure we don't have too many parameters */
    if (Message->NumberOfParameters > MAXIMUM_HARDERROR_PARAMETERS)
    {
        // NOTE: Windows just fails (STATUS_INVALID_PARAMETER) & returns ResponseNotHandled.
        DPRINT1("Invalid NumberOfParameters = %d\n", Message->NumberOfParameters);
        Message->NumberOfParameters = MAXIMUM_HARDERROR_PARAMETERS;
    }
    if (Message->ValidResponseOptions > OptionCancelTryContinue)
    {
        DPRINT1("Unknown ValidResponseOptions = %d\n", Message->ValidResponseOptions);
        return; // STATUS_INVALID_PARAMETER;
    }
    if (Message->Status == STATUS_SERVICE_NOTIFICATION)
    {
        if (Message->NumberOfParameters < 3)
        {
            DPRINT1("Invalid NumberOfParameters = %d for STATUS_SERVICE_NOTIFICATION\n",
                    Message->NumberOfParameters);
            return; // STATUS_INVALID_PARAMETER;
        }
        // (Message->UnicodeStringParameterMask & 0x3)
    }
 
    Status = NtUserSetInformationThread(NtCurrentThread(),
                                        UserThreadUseActiveDesktop,
                                        NULL,
                                        0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to set thread desktop!\n");
        return;
    }
 
    /* Re-initialize the hard errors cache */
    UserInitHardErrorsCache();
 
    /* Format the message caption and text */
    RtlInitEmptyUnicodeString(&TextU, LocalTextBuffer, sizeof(LocalTextBuffer));
    RtlInitEmptyUnicodeString(&CaptionU, LocalCaptionBuffer, sizeof(LocalCaptionBuffer));
    UserpFormatMessages(&TextU, &CaptionU, &dwType, &Timeout, Message);
 
    /* Log the hard error message */
    UserpLogHardError(&TextU, &CaptionU);
 
    /* Display a hard error popup depending on the current ErrorMode */
 
    /* Query the error mode value */
    ErrorMode = GetRegInt(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Windows",
                          L"ErrorMode", 0);
 
    if (Message->Status != STATUS_SERVICE_NOTIFICATION && ErrorMode != 0)
    {
        /* Returns OK for the hard error */
        Message->Response = ResponseOk;
        goto Quit;
    }
 
    if (Message->ValidResponseOptions == OptionOkNoWait)
    {
        /* Display the balloon */
        Message->Response = ResponseOk;
        if (UserpShowInformationBalloon(&TextU,
                                        &CaptionU,
                                        dwType,
                                        Message))
        {
            Message->Response = ResponseOk;
            goto Quit;
        }
    }
 
    /* Display the message box */
    Message->Response = UserpMessageBox(&TextU,
                                        &CaptionU,
                                        dwType,
                                        Timeout);
 
Quit:
    /* Free the strings if they have been reallocated */
    if (TextU.Buffer != LocalTextBuffer)
        RtlFreeUnicodeString(&TextU);
    if (CaptionU.Buffer != LocalCaptionBuffer)
        RtlFreeUnicodeString(&CaptionU);
 
    NtUserSetInformationThread(NtCurrentThread(), UserThreadRestoreDesktop, NULL, 0);
 
    return;
}