#include <stdio.h>
#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <wingdi.h>
#include <winreg.h>
#include <regstr.h>
#include <winnls.h>
#include <winuser.h>
#include <undocuser.h>
#include <strsafe.h>
#include <ndk/exfuncs.h>
#include <wine/debug.h>
#include "resource.h"

Include dependency graph for userinit.h:

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

Go to the source code of this file.

Classes
struct	_IMGINFO

struct	STATE

Macros
#define	WIN32_NO_STATUS

#define	_INC_WINDOWS

#define	COM_NO_WINDOWS_H

Typedefs
typedef struct _IMGINFO	IMGINFO

typedef struct _IMGINFO *	PIMGINFO

typedef struct STATE *	PSTATE

Enumerations
enum	PAGESTATE { LOCALEPAGE , STARTPAGE , DONE }

enum	RUN { SHELL , INSTALLER , REBOOT }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (userinit)

LONG	ReadRegSzKey (IN HKEY hKey, IN LPCWSTR pszKey, OUT LPWSTR *pValue)

BOOL	ExpandInstallerPath (IN LPCWSTR lpInstallerName, OUT LPWSTR lpInstallerPath, IN SIZE_T PathSize)

BOOL	IsLiveCD (VOID)

VOID	RunLiveCD (PSTATE State)

Variables
HINSTANCE	hInstance

Macro Definition Documentation

◆ _INC_WINDOWS

#define _INC_WINDOWS

Definition at line 12 of file userinit.h.

◆ COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 13 of file userinit.h.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 11 of file userinit.h.

Typedef Documentation

◆ IMGINFO

typedef struct _IMGINFO IMGINFO

◆ PIMGINFO

typedef struct _IMGINFO * PIMGINFO

◆ PSTATE

typedef struct STATE * PSTATE

Enumeration Type Documentation

◆ PAGESTATE

enum PAGESTATE

Enumerator
LOCALEPAGE
STARTPAGE
DONE

Definition at line 33 of file userinit.h.

{
    LOCALEPAGE,
    STARTPAGE,
    DONE
} PAGESTATE;

◆ RUN

enum RUN

Enumerator
SHELL
INSTALLER
REBOOT

Definition at line 40 of file userinit.h.

{
    SHELL,
    INSTALLER,
    REBOOT
} RUN;

Function Documentation

◆ ExpandInstallerPath()

BOOL ExpandInstallerPath	(	IN LPCWSTR	lpInstallerName,
		OUT LPWSTR	lpInstallerPath,
		IN SIZE_T	PathSize
	)

Definition at line 488 of file userinit.c.

{
    SYSTEM_INFO SystemInfo;
    SIZE_T cchInstallerNameLen;
    PWSTR ptr;
    DWORD dwAttribs;
 
    cchInstallerNameLen = wcslen(lpInstallerName);
    if (PathSize < cchInstallerNameLen)
    {
        /* The buffer is not large enough to contain the installer file name */
        *lpInstallerPath = UNICODE_NULL;
        return FALSE;
    }
 
    /*
     * First, try to find the installer using the default drive, under
     * the directory whose name corresponds to the currently-running
     * CPU architecture.
     */
    GetSystemInfo(&SystemInfo);
 
    *lpInstallerPath = UNICODE_NULL;
    /* Alternatively one can use SharedUserData->NtSystemRoot */
    GetSystemWindowsDirectoryW(lpInstallerPath, PathSize - cchInstallerNameLen - 1);
    ptr = wcschr(lpInstallerPath, L'\\');
    if (ptr)
        *++ptr = UNICODE_NULL;
    else
        *lpInstallerPath = UNICODE_NULL;
 
    /* Append the corresponding CPU architecture */
    switch (SystemInfo.wProcessorArchitecture)
    {
        case PROCESSOR_ARCHITECTURE_INTEL:
            StringCchCatW(lpInstallerPath, PathSize, L"I386");
            break;
 
        case PROCESSOR_ARCHITECTURE_MIPS:
            StringCchCatW(lpInstallerPath, PathSize, L"MIPS");
            break;
 
        case PROCESSOR_ARCHITECTURE_ALPHA:
            StringCchCatW(lpInstallerPath, PathSize, L"ALPHA");
            break;
 
        case PROCESSOR_ARCHITECTURE_PPC:
            StringCchCatW(lpInstallerPath, PathSize, L"PPC");
            break;
 
        case PROCESSOR_ARCHITECTURE_SHX:
            StringCchCatW(lpInstallerPath, PathSize, L"SHX");
            break;
 
        case PROCESSOR_ARCHITECTURE_ARM:
            StringCchCatW(lpInstallerPath, PathSize, L"ARM");
            break;
 
        case PROCESSOR_ARCHITECTURE_IA64:
            StringCchCatW(lpInstallerPath, PathSize, L"IA64");
            break;
 
        case PROCESSOR_ARCHITECTURE_ALPHA64:
            StringCchCatW(lpInstallerPath, PathSize, L"ALPHA64");
            break;
 
        case PROCESSOR_ARCHITECTURE_AMD64:
            StringCchCatW(lpInstallerPath, PathSize, L"AMD64");
            break;
 
        // case PROCESSOR_ARCHITECTURE_MSIL: /* .NET CPU-independent code */
        case PROCESSOR_ARCHITECTURE_UNKNOWN:
        default:
            WARN("Unknown processor architecture %lu\n", SystemInfo.wProcessorArchitecture);
            SystemInfo.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_UNKNOWN;
            break;
    }
 
    if (SystemInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_UNKNOWN)
        StringCchCatW(lpInstallerPath, PathSize, L"\\");
    StringCchCatW(lpInstallerPath, PathSize, lpInstallerName);
 
    dwAttribs = GetFileAttributesW(lpInstallerPath);
    if ((dwAttribs != INVALID_FILE_ATTRIBUTES) &&
        !(dwAttribs & FILE_ATTRIBUTE_DIRECTORY))
    {
        /* We have found the installer */
        return TRUE;
    }
 
    WARN("Couldn't find the installer '%s', trying alternative.\n", debugstr_w(lpInstallerPath));
 
    /*
     * We failed. Try to find the installer from either the current
     * ReactOS installation directory, or from our current directory.
     */
    *lpInstallerPath = UNICODE_NULL;
    /* Alternatively one can use SharedUserData->NtSystemRoot */
    if (GetSystemWindowsDirectoryW(lpInstallerPath, PathSize - cchInstallerNameLen - 1))
        StringCchCatW(lpInstallerPath, PathSize, L"\\");
    StringCchCatW(lpInstallerPath, PathSize, lpInstallerName);
 
    dwAttribs = GetFileAttributesW(lpInstallerPath);
    if ((dwAttribs != INVALID_FILE_ATTRIBUTES) &&
        !(dwAttribs & FILE_ATTRIBUTE_DIRECTORY))
    {
        /* We have found the installer */
        return TRUE;
    }
 
    /* Installer not found */
    ERR("Couldn't find the installer '%s'.\n", debugstr_w(lpInstallerPath));
    *lpInstallerPath = UNICODE_NULL;
    return FALSE;
}

Referenced by StartInstaller().

◆ IsLiveCD()

BOOL IsLiveCD ( VOID )

Definition at line 106 of file livecd.c.

{
    HKEY ControlKey = NULL;
    LPWSTR SystemStartOptions = NULL;
    LPWSTR CurrentOption, NextOption; /* Pointers into SystemStartOptions */
    LONG rc;
    BOOL ret = FALSE;
 
    rc = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                       REGSTR_PATH_CURRENT_CONTROL_SET,
                       0,
                       KEY_QUERY_VALUE,
                       &ControlKey);
    if (rc != ERROR_SUCCESS)
    {
        WARN("RegOpenKeyEx() failed with error %lu\n", rc);
        goto cleanup;
    }
 
    rc = ReadRegSzKey(ControlKey, L"SystemStartOptions", &SystemStartOptions);
    if (rc != ERROR_SUCCESS)
    {
        WARN("ReadRegSzKey() failed with error %lu\n", rc);
        goto cleanup;
    }
 
    /* Check for CONSOLE switch in SystemStartOptions */
    CurrentOption = SystemStartOptions;
    while (CurrentOption)
    {
        NextOption = wcschr(CurrentOption, L' ');
        if (NextOption)
            *NextOption = L'\0';
        if (_wcsicmp(CurrentOption, L"MININT") == 0)
        {
            TRACE("Found 'MININT' boot option\n");
            ret = TRUE;
            goto cleanup;
        }
        CurrentOption = NextOption ? NextOption + 1 : NULL;
    }
 
cleanup:
    if (ControlKey != NULL)
        RegCloseKey(ControlKey);
    HeapFree(GetProcessHeap(), 0, SystemStartOptions);
 
    TRACE("IsLiveCD() returning %u\n", ret);
    return ret;
}

Referenced by wWinMain().

◆ ReadRegSzKey()

LONG ReadRegSzKey	(	IN HKEY	hKey,
		IN LPCWSTR	pszKey,
		OUT LPWSTR *	pValue
	)

Definition at line 38 of file userinit.c.

{
    LONG rc;
    DWORD dwType;
    DWORD cbData = 0;
    LPWSTR Value;
 
    rc = RegQueryValueExW(hKey, pszKey, NULL, &dwType, NULL, &cbData);
    if (rc != ERROR_SUCCESS)
    {
        WARN("RegQueryValueEx(%s) failed with error %lu\n", debugstr_w(pszKey), rc);
        return rc;
    }
    if (dwType != REG_SZ)
    {
        WARN("Wrong registry data type (%u vs %u)\n", dwType, REG_SZ);
        return ERROR_FILE_NOT_FOUND;
    }
    Value = (WCHAR*) HeapAlloc(GetProcessHeap(), 0, cbData + sizeof(WCHAR));
    if (!Value)
    {
        WARN("No memory\n");
        return ERROR_NOT_ENOUGH_MEMORY;
    }
    rc = RegQueryValueExW(hKey, pszKey, NULL, NULL, (LPBYTE)Value, &cbData);
    if (rc != ERROR_SUCCESS)
    {
        WARN("RegQueryValueEx(%s) failed with error %lu\n", debugstr_w(pszKey), rc);
        HeapFree(GetProcessHeap(), 0, Value);
        return rc;
    }
    /* NULL-terminate the string */
    Value[cbData / sizeof(WCHAR)] = L'\0';
 
    *pValue = Value;
    return ERROR_SUCCESS;
}

Referenced by IsConsoleShell().

◆ RunLiveCD()

VOID RunLiveCD ( PSTATE State )

Definition at line 892 of file livecd.c.

{
    LIVECD_UNATTEND Unattend = {0};
    WCHAR UnattendInf[MAX_PATH];
 
    InitLogo(&pState->ImageInfo, NULL);
 
    GetWindowsDirectoryW(UnattendInf, _countof(UnattendInf));
    wcscat(UnattendInf, L"\\unattend.inf");
    ParseUnattend(UnattendInf, &Unattend);
    pState->Unattend = &Unattend;
 
    while (pState->NextPage != DONE)
    {
        switch (pState->NextPage)
        {
            case LOCALEPAGE:
                DialogBoxParamW(hInstance,
                                MAKEINTRESOURCEW(IDD_LOCALEPAGE),
                                NULL,
                                LocaleDlgProc,
                                (LPARAM)pState);
                break;
 
            case STARTPAGE:
                DialogBoxParamW(hInstance,
                                MAKEINTRESOURCEW(IDD_STARTPAGE),
                                NULL,
                                StartDlgProc,
                                (LPARAM)pState);
                break;
 
            default:
                break;
        }
    }
 
    DeleteObject(pState->ImageInfo.hBitmap);
}

Referenced by wWinMain().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( userinit )

Variable Documentation

◆ hInstance

HINSTANCE hInstance

extern

Definition at line 19 of file charmap.c.

Classes

Macros

Typedefs

Enumerations

Functions

Variables