dllmain.c File Reference

#include <user32.h>
#include <ndk/cmfuncs.h>
#include <strsafe.h>
#include "u32cb.h"

Include dependency graph for dllmain.c:

Go to the source code of this file.

Classes
struct	_UMPDPKTHEAD

Macros
#define	MAX_USER_MODE_DRV_BUFFER   526
#define	KEY_LENGTH   1024
#define	DEFINE_USER32_CALLBACK(id, value, fn)   fn,
#define	WIN_OBJ_DIR   L"\\Windows"
#define	SESSION_DIR   L"\\Sessions"

Typedefs
typedef struct _UMPDPKTHEAD	UMPDPKTHEAD
typedef struct _UMPDPKTHEAD *	PUMPDPKTHEAD

Functions
INT WINAPI	GdiPrinterThunk (PUMPDPKTHEAD, PVOID, INT)
	WINE_DEFAULT_DEBUG_CHANNEL (user32)
BOOL	GetDllList (VOID)
VOID	LoadAppInitDlls (VOID)
VOID	UnloadAppInitDlls (VOID)
VOID WINAPI	GdiProcessSetup (VOID)
BOOL WINAPI	ClientThreadSetupHelper (BOOL IsCallback)
BOOL WINAPI	ClientThreadSetup (VOID)
BOOL	Init (PUSERCONNECT UserCon)
VOID	Cleanup (VOID)
BOOL WINAPI	DllMain (_In_ HANDLE hDll, _In_ ULONG dwReason, _In_opt_ PVOID pReserved)
NTSTATUS WINAPI	User32CallClientThreadSetupFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallGetCharsetInfo (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallSetWndIconsFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32DeliverUserAPC (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallOBMFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallLPKFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallUMPDFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallImmProcessKeyFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallImmLoadLayoutFromKernel (PVOID Arguments, ULONG ArgumentLength)

Variables
static ULONG	User32TlsIndex
HINSTANCE	User32Instance
PPROCESSINFO	g_ppi = NULL
SHAREDINFO	gSharedInfo = {0}
PSERVERINFO	gpsi = NULL
PUSER_HANDLE_TABLE	gHandleTable = NULL
PUSER_HANDLE_ENTRY	gHandleEntries = NULL
BOOLEAN	gfLogonProcess = FALSE
BOOLEAN	gfServerProcess = FALSE
BOOLEAN	gfFirstThread = TRUE
HICON	hIconSmWindows = NULL
HICON	hIconWindows = NULL
WCHAR	szAppInit [KEY_LENGTH]
PVOID	apfnDispatch [USER32_CALLBACK_COUNT]

Macro Definition Documentation

DEFINE_USER32_CALLBACK

#define DEFINE_USER32_CALLBACK	(		id,
			value,
			fn
	)		fn,

Definition at line 206 of file dllmain.c.

KEY_LENGTH

#define KEY_LENGTH   1024

Definition at line 24 of file dllmain.c.

MAX_USER_MODE_DRV_BUFFER

#define MAX_USER_MODE_DRV_BUFFER   526

Definition at line 5 of file dllmain.c.

SESSION_DIR

#define SESSION_DIR   L"\\Sessions"

WIN_OBJ_DIR

#define WIN_OBJ_DIR   L"\\Windows"

Typedef Documentation

PUMPDPKTHEAD

typedef struct _UMPDPKTHEAD * PUMPDPKTHEAD

UMPDPKTHEAD

typedef struct _UMPDPKTHEAD UMPDPKTHEAD

Function Documentation

Cleanup()

VOID Cleanup

(

VOID

)

Definition at line 443 of file dllmain.c.

{
    UnloadAppInitDlls();
    DeleteCriticalSection(&U32AccelCacheLock);
    MenuCleanup();
    MessageCleanup();
    TlsFree(User32TlsIndex);
    DeleteFrameBrushes();
}

ClientThreadSetup()

BOOL WINAPI ClientThreadSetup

(

VOID

)

Definition at line 330 of file dllmain.c.

{
    //
    // This routine, in Windows, does a lot of what Init does, but in a radically
    // different way.
    //
    // In Windows, because CSRSS's threads have TIF_CSRSSTHREAD set (we have this
    // flag in ROS but not sure if we use it), the xxxClientThreadSetup callback
    // isn't made when CSRSS first loads WINSRV.DLL (which loads USER32.DLL).
    //
    // However, all the other calls are made as normal, and WINSRV.DLL loads
    // USER32.dll, the DllMain runs, and eventually the first NtUser system call is
    // made which initializes Win32k (and initializes the thread, but as mentioned
    // above, the thread is marked as TIF_CSRSSTHREAD).
    //
    // In the DllMain of User32, there is also a CsrClientConnectToServer call to
    // server 2 (winsrv). When this is done from CSRSS, the "InServer" flag is set,
    // so user32 will remember that it's running inside of CSRSS. Also, another
    // flag, called "FirstThread" is manually set by DllMain.
    //
    // Then, WINSRV finishes loading, and CSRSRV starts the API thread/loop. This
    // code then calls CsrConnectToUser, which calls... ClientThreadStartup. Now
    // this routine detects that it's in the server process, which means it's CSRSS
    // and that the callback never happened. It does some first-time-Win32k connection
    // initialization and caches a bunch of things -- if it's the first thread. It also
    // acquires a critical section to initialize GDI -- and then resets the first thread
    // flag.
    //
    // For now, we'll do none of this, but to support Windows' CSRSRV.DLL which calls
    // CsrConnectToUser, we'll pretend we "did something" here. Then the rest will
    // continue as normal.
    //
 
    // FIXME: Disabling this call is a HACK!! See also User32CallClientThreadSetupFromKernel...
    // return ClientThreadSetupHelper(FALSE);
    TRACE("ClientThreadSetup is not implemented\n");
    return TRUE;
}

ClientThreadSetupHelper()

BOOL WINAPI ClientThreadSetupHelper

(

BOOL

IsCallback

)

Definition at line 221 of file dllmain.c.

{
    /*
     * Normally we are called by win32k so the win32 thread pointers
     * should be valid as they are set in win32k::InitThreadCallback.
     */
    PCLIENTINFO ClientInfo = GetWin32ClientInfo();
    BOOLEAN IsFirstThread = _InterlockedExchange8((PCHAR)&gfFirstThread, FALSE);
 
    TRACE("In ClientThreadSetup(IsCallback == %s, gfServerProcess = %s, IsFirstThread = %s)\n",
          IsCallback ? "TRUE" : "FALSE", gfServerProcess ? "TRUE" : "FALSE", IsFirstThread ? "TRUE" : "FALSE");
 
    if (IsFirstThread)
        GdiProcessSetup();
 
    /* Check for already initialized thread, and bail out if so */
    if (ClientInfo->CI_flags & CI_INITTHREAD)
    {
        ERR("ClientThreadSetup: Thread already initialized.\n");
        return FALSE;
    }
 
    /*
     * CSRSS couldn't use user32::DllMain CSR server-to-server call to connect
     * to win32k. So it is delayed to a manually-call to ClientThreadSetup.
     * Also this needs to be done only for the first thread (since the connection
     * is per-process).
     */
    if (gfServerProcess && IsFirstThread)
    {
        NTSTATUS Status;
        USERCONNECT UserCon;
 
        RtlZeroMemory(&UserCon, sizeof(UserCon));
 
        /* Minimal setup of the connect info structure */
        UserCon.ulVersion = USER_VERSION;
        // UserCon.dwDispatchCount;
 
        /* Connect to win32k */
        Status = NtUserProcessConnect(NtCurrentProcess(),
                                      &UserCon,
                                      sizeof(UserCon));
        if (!NT_SUCCESS(Status)) return FALSE;
 
        /* Retrieve data */
        g_ppi = ClientInfo->ppi; // Snapshot PI, used as pointer only!
        gSharedInfo = UserCon.siClient;
        gpsi = gSharedInfo.psi;
        gHandleTable = gSharedInfo.aheList;
        /* ReactOS-Specific! */ gHandleEntries = SharedPtrToUser(gHandleTable->handles);
 
        // ERR("1 SI 0x%x : HT 0x%x : D 0x%x\n",
        //     gSharedInfo.psi, gSharedInfo.aheList, gSharedInfo.ulSharedDelta);
    }
 
    TRACE("Checkpoint (register PFN)\n");
    if (!RegisterClientPFN())
    {
        ERR("RegisterClientPFN failed\n");
        return FALSE;
    }
 
    /* Mark this thread as initialized */
    ClientInfo->CI_flags |= CI_INITTHREAD;
 
    /* Initialization that should be done once per process */
    if (IsFirstThread)
    {
        TRACE("Checkpoint (Allocating TLS)\n");
 
        /* Allocate an index for user32 thread local data */
        User32TlsIndex = TlsAlloc();
        if (User32TlsIndex == TLS_OUT_OF_INDEXES)
            return FALSE;
 
        // HAAAAAAAAAACK!!!!!!
        // ASSERT(gpsi);
        if (!gpsi) ERR("AAAAAAAAAAAHHHHHHHHHHHHHH!!!!!!!! gpsi == NULL !!!!\n");
        if (gpsi)
        {
        TRACE("Checkpoint (MessageInit)\n");
 
        if (MessageInit())
        {
            TRACE("Checkpoint (MenuInit)\n");
            if (MenuInit())
            {
                TRACE("Checkpoint initialization done OK\n");
                InitializeCriticalSection(&U32AccelCacheLock);
                LoadAppInitDlls();
                return TRUE;
            }
            MessageCleanup();
        }
 
        TlsFree(User32TlsIndex);
        return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by Init().

DllMain()

BOOL WINAPI DllMain	(	_In_ HANDLE	hDll,
		_In_ ULONG	dwReason,
		_In_opt_ PVOID	pReserved
	)

Definition at line 456 of file dllmain.c.

{
    switch (dwReason)
    {
        case DLL_PROCESS_ATTACH:
        {
 
#define WIN_OBJ_DIR L"\\Windows"
#define SESSION_DIR L"\\Sessions"
 
            USERSRV_API_CONNECTINFO ConnectInfo; // USERCONNECT
 
#if 0 // Disabling this code is a BIG HACK!!
 
            NTSTATUS Status;
            ULONG ConnectInfoSize = sizeof(ConnectInfo);
            WCHAR SessionDir[256];
 
            /* Cache the PEB and Session ID */
            PPEB Peb = NtCurrentPeb();
            ULONG SessionId = Peb->SessionId; // gSessionId
 
            TRACE("user32::DllMain\n");
 
            /* Don't bother us for each thread */
            DisableThreadLibraryCalls(hDll);
 
            RtlZeroMemory(&ConnectInfo, sizeof(ConnectInfo));
 
            /* Minimal setup of the connect info structure */
            ConnectInfo.ulVersion = USER_VERSION;
 
            /* Setup the Object Directory path */
            if (!SessionId)
            {
                /* Use the raw path */
                wcscpy(SessionDir, WIN_OBJ_DIR);
            }
            else
            {
                /* Use the session path */
                swprintf(SessionDir,
                         L"%ws\\%ld%ws",
                         SESSION_DIR,
                         SessionId,
                         WIN_OBJ_DIR);
            }
 
            TRACE("Checkpoint (call CSR)\n");
 
            /* Connect to the USER Server */
            Status = CsrClientConnectToServer(SessionDir,
                                              USERSRV_SERVERDLL_INDEX,
                                              &ConnectInfo,
                                              &ConnectInfoSize,
                                              &gfServerProcess);
            if (!NT_SUCCESS(Status))
            {
                ERR("Failed to connect to CSR (Status %lx)\n", Status);
                return FALSE;
            }
 
            TRACE("Checkpoint (CSR called)\n");
 
#endif
 
            User32Instance = hDll;
 
            /* Finish initialization */
            TRACE("Checkpoint (call Init)\n");
            if (!Init(&ConnectInfo))
                return FALSE;
 
            if (!gfServerProcess)
            {
                HINSTANCE hImm32 = NULL;
 
                if (gpsi && (gpsi->dwSRVIFlags & SRVINFO_IMM32))
                {
                    WCHAR szImmFile[MAX_PATH];
                    InitializeImmEntryTable();
                    User32GetImmFileName(szImmFile, _countof(szImmFile));
                    hImm32 = GetModuleHandleW(szImmFile);
                }
 
                if (!IMM_FN(ImmRegisterClient)(&gSharedInfo, hImm32))
                    return FALSE;
            }
            break;
        }
 
        case DLL_PROCESS_DETACH:
        {
            if (ghImm32)
                FreeLibrary(ghImm32);
 
            Cleanup();
            break;
        }
    }
 
    /* Finally, initialize GDI */
    return GdiDllInitialize(hDll, dwReason, pReserved);
}

GdiPrinterThunk()

INT WINAPI GdiPrinterThunk	(	PUMPDPKTHEAD	,
		PVOID	,
		INT
	)

Referenced by User32CallUMPDFromKernel().

GdiProcessSetup()

VOID WINAPI GdiProcessSetup

(

VOID

)

Definition at line 45 of file dllmain.c.

{
    if (!gbInitialized)
    {
        gbInitialized = TRUE;
        hProcessHeap = GetProcessHeap();
 
        /* map the gdi handle table to user space */
        GdiHandleTable = NtCurrentTeb()->ProcessEnvironmentBlock->GdiSharedHandleTable;
        GdiSharedHandleTable = NtCurrentTeb()->ProcessEnvironmentBlock->GdiSharedHandleTable;
        GdiDevCaps = &GdiSharedHandleTable->DevCaps;
        CurrentProcessId = NtCurrentTeb()->ClientId.UniqueProcess;
        GDI_BatchLimit = (DWORD) NtCurrentTeb()->ProcessEnvironmentBlock->GdiDCAttributeList;
        GdiHandleCache = (PGDIHANDLECACHE)NtCurrentTeb()->ProcessEnvironmentBlock->GdiHandleBuffer;
        RtlInitializeCriticalSection(&semLocal);
        InitializeCriticalSection(&gcsClientObjLinks);
        GdiInitializeLanguagePack(0);
    }
}

Referenced by ClientThreadSetupHelper(), and GdiDllInitialize().

GetDllList()

BOOL GetDllList

(

VOID

)

Definition at line 42 of file dllmain.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES Attributes;
    BOOL bRet = FALSE;
    BOOL bLoad;
    HANDLE hKey = NULL;
    DWORD dwSize;
    PKEY_VALUE_PARTIAL_INFORMATION kvpInfo = NULL;
 
    UNICODE_STRING szKeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows");
    UNICODE_STRING szLoadName = RTL_CONSTANT_STRING(L"LoadAppInit_DLLs");
    UNICODE_STRING szDllsName = RTL_CONSTANT_STRING(L"AppInit_DLLs");
 
    InitializeObjectAttributes(&Attributes, &szKeyName, OBJ_CASE_INSENSITIVE, NULL, NULL);
    Status = NtOpenKey(&hKey, KEY_READ, &Attributes);
    if (NT_SUCCESS(Status))
    {
        dwSize = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(DWORD);
        kvpInfo = HeapAlloc(GetProcessHeap(), 0, dwSize);
        if (!kvpInfo)
            goto end;
 
        Status = NtQueryValueKey(hKey,
                                 &szLoadName,
                                 KeyValuePartialInformation,
                                 kvpInfo,
                                 dwSize,
                                 &dwSize);
        if (!NT_SUCCESS(Status))
            goto end;
 
        RtlMoveMemory(&bLoad,
                      kvpInfo->Data,
                      kvpInfo->DataLength);
 
        HeapFree(GetProcessHeap(), 0, kvpInfo);
        kvpInfo = NULL;
 
        if (bLoad)
        {
            Status = NtQueryValueKey(hKey,
                                     &szDllsName,
                                     KeyValuePartialInformation,
                                     NULL,
                                     0,
                                     &dwSize);
            if (Status != STATUS_BUFFER_TOO_SMALL)
                goto end;
 
            kvpInfo = HeapAlloc(GetProcessHeap(), 0, dwSize);
            if (!kvpInfo)
                goto end;
 
            Status = NtQueryValueKey(hKey,
                                     &szDllsName,
                                     KeyValuePartialInformation,
                                     kvpInfo,
                                     dwSize,
                                     &dwSize);
            if (NT_SUCCESS(Status))
            {
                LPWSTR lpBuffer = (LPWSTR)kvpInfo->Data;
                if (*lpBuffer != UNICODE_NULL)
                {
                    INT bytesToCopy, nullPos;
 
                    bytesToCopy = min(kvpInfo->DataLength, KEY_LENGTH * sizeof(WCHAR));
 
                    if (bytesToCopy != 0)
                    {
                        RtlMoveMemory(szAppInit,
                                      kvpInfo->Data,
                                      bytesToCopy);
 
                        nullPos = (bytesToCopy / sizeof(WCHAR)) - 1;
 
                        /* ensure string is terminated */
                        szAppInit[nullPos] = UNICODE_NULL;
 
                        bRet = TRUE;
                    }
                }
            }
        }
    }
 
end:
    if (hKey)
        NtClose(hKey);
 
    if (kvpInfo)
        HeapFree(GetProcessHeap(), 0, kvpInfo);
 
    return bRet;
}

Referenced by LoadAppInitDlls().

Init()

BOOL Init

(

PUSERCONNECT

UserCon

)

Definition at line 370 of file dllmain.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    TRACE("user32::Init(0x%p) -->\n", UserCon);
 
    RtlInitializeCriticalSection(&gcsUserApiHook);
 
    /* Initialize callback table in PEB data */
    NtCurrentPeb()->KernelCallbackTable = apfnDispatch;
    NtCurrentPeb()->PostProcessInitRoutine = NULL;
 
    // This is a HACK!! //
    gfServerProcess = FALSE;
    gfFirstThread   = TRUE;
 
    /*
     * Retrieve data from the connect info structure if the initializing
     * process is not CSRSS. In case it is, this will be done from inside
     * ClientThreadSetup.
     */
    if (!gfServerProcess)
    {
        // FIXME: HACK!! We should fixup for the NtUserProcessConnect fixups
        // because it was made in the context of CSRSS process and not ours!!
        // So... as long as we don't fix that, we need to redo again a call
        // to NtUserProcessConnect... How perverse is that?!
        //
        // HACK(2): This call is necessary since we disabled
        // the CSR call in DllMain...
        {
            RtlZeroMemory(UserCon, sizeof(*UserCon));
 
            /* Minimal setup of the connect info structure */
            UserCon->ulVersion = USER_VERSION;
            // UserCon->dwDispatchCount;
 
            TRACE("HACK: Hackish NtUserProcessConnect call!!\n");
            /* Connect to win32k */
            Status = NtUserProcessConnect(NtCurrentProcess(),
                                          UserCon,
                                          sizeof(*UserCon));
            if (!NT_SUCCESS(Status)) return FALSE;
        }
 
        //
        // We continue as we should do normally...
        //
 
        /* Retrieve data */
        g_ppi = GetWin32ClientInfo()->ppi; // Snapshot PI, used as pointer only!
        gSharedInfo = UserCon->siClient;
        gpsi = gSharedInfo.psi;
        gHandleTable = gSharedInfo.aheList;
        /* ReactOS-Specific! */ gHandleEntries = SharedPtrToUser(gHandleTable->handles);
    }
 
    // FIXME: Yet another hack... This call should normally not be done here, but
    // instead in ClientThreadSetup, and in User32CallClientThreadSetupFromKernel as well.
    TRACE("HACK: Using Init-ClientThreadSetupHelper hack!!\n");
    if (!ClientThreadSetupHelper(FALSE))
    {
        TRACE("Init-ClientThreadSetupHelper hack failed!\n");
        return FALSE;
    }
 
    TRACE("<-- user32::Init()\n");
 
    return NT_SUCCESS(Status);
}

LoadAppInitDlls()

VOID LoadAppInitDlls

(

VOID

)

Definition at line 141 of file dllmain.c.

{
    szAppInit[0] = UNICODE_NULL;
 
    if (GetDllList())
    {
        WCHAR buffer[KEY_LENGTH];
        LPWSTR ptr;
        size_t i;
 
        RtlCopyMemory(buffer, szAppInit, KEY_LENGTH * sizeof(WCHAR) );
 
        for (i = 0; i < KEY_LENGTH; ++ i)
        {
            if(buffer[i] == L' ' || buffer[i] == L',')
                buffer[i] = 0;
        }
 
        for (i = 0; i < KEY_LENGTH; )
        {
            if(buffer[i] == 0)
                ++ i;
            else
            {
                ptr = buffer + i;
                i += wcslen(ptr);
                LoadLibraryW(ptr);
            }
        }
    }
}

Referenced by ClientThreadSetupHelper().

UnloadAppInitDlls()

VOID UnloadAppInitDlls

(

VOID

)

Definition at line 174 of file dllmain.c.

{
    if (szAppInit[0] != UNICODE_NULL)
    {
        WCHAR buffer[KEY_LENGTH];
        HMODULE hModule;
        LPWSTR ptr;
        size_t i;
 
        RtlCopyMemory(buffer, szAppInit, KEY_LENGTH * sizeof(WCHAR));
 
        for (i = 0; i < KEY_LENGTH; ++ i)
        {
            if(buffer[i] == L' ' || buffer[i] == L',')
                buffer[i] = 0;
        }
 
        for (i = 0; i < KEY_LENGTH; )
        {
            if(buffer[i] == 0)
                ++ i;
            else
            {
                ptr = buffer + i;
                i += wcslen(ptr);
                hModule = GetModuleHandleW(ptr);
                FreeLibrary(hModule);
            }
        }
    }
}

Referenced by Cleanup().

User32CallClientThreadSetupFromKernel()

NTSTATUS WINAPI User32CallClientThreadSetupFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 566 of file dllmain.c.

{
  TRACE("User32CallClientThreadSetupFromKernel -->\n");
  // FIXME: Disabling this call is a HACK!! See also ClientThreadSetup...
  // ClientThreadSetupHelper(TRUE);
  TRACE("<-- User32CallClientThreadSetupFromKernel\n");
  return ZwCallbackReturn(NULL, 0, STATUS_SUCCESS);
}

User32CallGetCharsetInfo()

NTSTATUS WINAPI User32CallGetCharsetInfo	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 577 of file dllmain.c.

{
  BOOL Ret;
  PGET_CHARSET_INFO pgci = (PGET_CHARSET_INFO)Arguments;
 
  TRACE("GetCharsetInfo\n");
 
  Ret = TranslateCharsetInfo((DWORD *)(ULONG_PTR)pgci->Locale, &pgci->Cs, TCI_SRCLOCALE);
 
  return ZwCallbackReturn(Arguments, ArgumentLength, Ret ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}

User32CallImmLoadLayoutFromKernel()

NTSTATUS WINAPI User32CallImmLoadLayoutFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 717 of file dllmain.c.

{
    PIMMLOADLAYOUT_CALLBACK_ARGUMENTS Common = Arguments;
    IMMLOADLAYOUT_CALLBACK_OUTPUT Result;
    Result.ret = IMM_FN(ImmLoadLayout)(Common->hKL, &Result.iiex);
    return ZwCallbackReturn(&Result, sizeof(Result), STATUS_SUCCESS);
}

User32CallImmProcessKeyFromKernel()

NTSTATUS WINAPI User32CallImmProcessKeyFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 704 of file dllmain.c.

{
    PIMMPROCESSKEY_CALLBACK_ARGUMENTS Common = Arguments;
    DWORD Result = IMM_FN(ImmProcessKey)(Common->hWnd,
                                         Common->hKL,
                                         Common->vKey,
                                         Common->lParam,
                                         Common->dwHotKeyID);
 
    return ZwCallbackReturn(&Result, sizeof(DWORD), STATUS_SUCCESS);
}

User32CallLPKFromKernel()

NTSTATUS WINAPI User32CallLPKFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 652 of file dllmain.c.

{
    BOOL bResult;
    PLPK_CALLBACK_ARGUMENTS Argument;
 
    Argument = (PLPK_CALLBACK_ARGUMENTS)Arguments;
 
    Argument->lpString = (LPWSTR)((ULONG_PTR)Argument->lpString + (ULONG_PTR)Argument);
 
    bResult = ExtTextOutW(Argument->hdc,
                          Argument->x,
                          Argument->y,
                          Argument->flags,
                          (Argument->bRect) ? &Argument->rect : NULL,
                          Argument->lpString,
                          Argument->count,
                          NULL);
 
    return ZwCallbackReturn(&bResult, sizeof(BOOL), STATUS_SUCCESS);
}

User32CallOBMFromKernel()

NTSTATUS WINAPI User32CallOBMFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 620 of file dllmain.c.

{
  BITMAP bmp;
  PSETOBM_CALLBACK_ARGUMENTS Common = Arguments;
 
  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_CLOSE].cx = bmp.bmWidth;
  Common->oembmi[OBI_CLOSE].cy = bmp.bmHeight;
 
  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_MNARROW)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_MNARROW].cx = bmp.bmWidth;
  Common->oembmi[OBI_MNARROW].cy = bmp.bmHeight;
 
  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_DNARROW)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_DNARROW].cx = bmp.bmWidth;
  Common->oembmi[OBI_DNARROW].cy = bmp.bmHeight;
 
  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_DNARROWI)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_DNARROWI].cx = bmp.bmWidth;
  Common->oembmi[OBI_DNARROWI].cy = bmp.bmHeight;
 
  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_UPARROW)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_UPARROW].cx = bmp.bmWidth;
  Common->oembmi[OBI_UPARROW].cy = bmp.bmHeight;
 
  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_UPARROWI)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_UPARROWI].cx = bmp.bmWidth;
  Common->oembmi[OBI_UPARROWI].cy = bmp.bmHeight;
 
  return ZwCallbackReturn(Arguments, ArgumentLength, STATUS_SUCCESS);
}

User32CallSetWndIconsFromKernel()

NTSTATUS WINAPI User32CallSetWndIconsFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 591 of file dllmain.c.

{
  PSETWNDICONS_CALLBACK_ARGUMENTS Common = Arguments;
 
  if (!gpsi->hIconSmWindows)
  {
      Common->hIconSample    = LoadImageW(0, IDI_APPLICATION, IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconHand      = LoadImageW(0, IDI_HAND,        IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconQuestion  = LoadImageW(0, IDI_QUESTION,    IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconBang      = LoadImageW(0, IDI_EXCLAMATION, IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconNote      = LoadImageW(0, IDI_ASTERISK,    IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconWindows   = LoadImageW(0, IDI_WINLOGO,     IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconSmWindows = LoadImageW(0, IDI_WINLOGO, IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), 0);
      hIconWindows   = Common->hIconWindows;
      hIconSmWindows = Common->hIconSmWindows;
  }
  ERR("hIconSmWindows %p hIconWindows %p \n",hIconSmWindows,hIconWindows);
  return ZwCallbackReturn(Arguments, ArgumentLength, STATUS_SUCCESS);
}

User32CallUMPDFromKernel()

NTSTATUS WINAPI User32CallUMPDFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 673 of file dllmain.c.

{
    DWORD Buffer[MAX_USER_MODE_DRV_BUFFER];
    INT cbSize = 0;
    NTSTATUS Status = STATUS_SUCCESS;
    PUMPDPKTHEAD pkt, pktOut = NULL;
 
    pkt = (PUMPDPKTHEAD)Arguments;
 
    if ( pkt->RetSize <= sizeof(Buffer) )
    {
        pktOut = (PUMPDPKTHEAD)Buffer;
 
        if ( (GdiPrinterThunk( pkt, pktOut, pkt->RetSize ) == GDI_ERROR) )
        {
            pktOut = NULL;
            Status = STATUS_UNSUCCESSFUL;
        }
        else
        {
            cbSize = pkt->RetSize;
        }
    }
    else
    {
       Status = STATUS_NO_MEMORY;   
    }
    return ZwCallbackReturn( pktOut, cbSize, Status );
}

User32DeliverUserAPC()

NTSTATUS WINAPI User32DeliverUserAPC	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 613 of file dllmain.c.

{
  return ZwCallbackReturn(0, 0, STATUS_SUCCESS);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

user32

)

Variable Documentation

apfnDispatch

PVOID apfnDispatch[USER32_CALLBACK_COUNT]

Initial value:

=
{
 
}

Definition at line 208 of file dllmain.c.

Referenced by Init().

g_ppi

PPROCESSINFO g_ppi = NULL

Definition at line 29 of file dllmain.c.

Referenced by ClientThreadSetupHelper(), Init(), and ValidateCallProc().

gfFirstThread

BOOLEAN gfFirstThread = TRUE

Definition at line 36 of file dllmain.c.

Referenced by ClientThreadSetupHelper(), and Init().

gfLogonProcess

BOOLEAN gfLogonProcess = FALSE

Definition at line 34 of file dllmain.c.

Referenced by RegisterLogonProcess().

gfServerProcess

BOOLEAN gfServerProcess = FALSE

Definition at line 35 of file dllmain.c.

Referenced by ClientThreadSetupHelper(), DllMain(), Init(), and LoadUserApiHook().

gHandleEntries

PUSER_HANDLE_ENTRY gHandleEntries = NULL

Definition at line 33 of file dllmain.c.

Referenced by ClientThreadSetupHelper(), GetUser32Handle(), and Init().

gHandleTable

PUSER_HANDLE_TABLE gHandleTable = NULL

Definition at line 32 of file dllmain.c.

Referenced by ClientThreadSetupHelper(), and Init().

gpsi

PSERVERINFO gpsi = NULL

Definition at line 31 of file dllmain.c.

Referenced by ClientThreadSetupHelper(), DllMain(), Init(), and User32CallSetWndIconsFromKernel().

gSharedInfo

SHAREDINFO gSharedInfo = {0}

Definition at line 30 of file dllmain.c.

Referenced by ClientThreadSetupHelper(), DllMain(), and Init().

hIconSmWindows

HICON hIconSmWindows = NULL

Definition at line 37 of file dllmain.c.

Referenced by User32CallSetWndIconsFromKernel().

hIconWindows

HICON hIconWindows = NULL

Definition at line 37 of file dllmain.c.

Referenced by User32CallSetWndIconsFromKernel().

szAppInit

WCHAR szAppInit[KEY_LENGTH]

Definition at line 39 of file dllmain.c.

Referenced by GetDllList(), LoadAppInitDlls(), and UnloadAppInitDlls().

User32Instance

HINSTANCE User32Instance

Definition at line 27 of file dllmain.c.

Referenced by BITMAP_LoadImageW(), CURSORICON_LoadImageW(), DllMain(), GetClassInfoExA(), GetClassInfoExW(), Ghost_OnClose(), Ghost_OnCreate(), MB_GetString(), MDI_MoreWindowsDialog(), MDI_RefreshMenu(), MessageBoxTimeoutIndirectW(), ProcessHotKey(), RegisterClassExWOWW(), and RegisterClientPFN().

User32TlsIndex

ULONG User32TlsIndex

static

Definition at line 26 of file dllmain.c.

Referenced by Cleanup(), and ClientThreadSetupHelper().