bool InputDesktopSelected()
{
DWORD dummy;
char threadname[256];
char inputname[256];
HDESK threaddesktop = GetThreadDesktop(GetCurrentThreadId());
HDESK inputdesktop = OpenInputDesktop(0, FALSE,
DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW |
DESKTOP_ENUMERATE | DESKTOP_HOOKCONTROL |
DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS |
DESKTOP_SWITCHDESKTOP | GENERIC_WRITE);
if (inputdesktop == NULL) return FALSE;
if (!GetUserObjectInformation(threaddesktop, UOI_NAME, &threadname, 256, &dummy)) {
CloseDesktop(inputdesktop);
return FALSE;
}
if (!GetUserObjectInformation(inputdesktop, UOI_NAME, &inputname, 256, &dummy)) {
CloseDesktop(inputdesktop);
return FALSE;
}
CloseDesktop(inputdesktop);
if (strcmp(threadname, inputname) != 0)
{
//if (strcmp(inputname, "Screen-saver") == 0)
{
return SelectDesktop();
}
return FALSE;
}
return TRUE;
}
void *
SimulateCtrlAltDelThreadFn(void *context)
{
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
HDESK winlogon_desk = 0;
// Switch into the Winlogon desktop
if (!vncService::SelectDesktop("Winlogon", &winlogon_desk))
{
vnclog.Print(LL_INTERR, VNCLOG("failed to select logon desktop\n"));
vncTimedMsgBox::Do(
sz_ID_CADERROR,
sz_ID_ULTRAVNC_WARNING,
MB_ICONINFORMATION | MB_OK
);
return FALSE;
}
// 9 April 2008 jdp
// turn off capslock if on
ClearKeyState(VK_CAPITAL);
vnclog.Print(LL_ALL, VNCLOG("generating ctrl-alt-del\n"));
// Fake a hotkey event to any windows we find there.... :(
// Winlogon uses hotkeys to trap Ctrl-Alt-Del...
PostMessage(HWND_BROADCAST, WM_HOTKEY, 0, MAKELONG(MOD_ALT | MOD_CONTROL, VK_DELETE));
// Switch back to our original desktop
if (old_desktop != NULL)
{
vncService::SelectHDESK(old_desktop);
CloseDesktop(winlogon_desk);
}
return NULL;
}
BOOL
vncService::SelectHDESK(HDESK new_desktop)
{
// Are we running on NT?
if (IsWinNT())
{
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
DWORD dummy;
char new_name[256];
if (!GetUserObjectInformation(new_desktop, UOI_NAME, &new_name, 256, &dummy)) {
vnclog.Print(LL_INTERR, VNCLOG("!GetUserObjectInformation \n"));
return FALSE;
}
vnclog.Print(LL_INTERR, VNCLOG("SelectHDESK to %s (%x) from %x\n"), new_name, new_desktop, old_desktop);
// Switch the desktop
if(!SetThreadDesktop(new_desktop)) {
vnclog.Print(LL_INTERR, VNCLOG("SelectHDESK:!SetThreadDesktop \n"));
return FALSE;
}
return TRUE;
}
return TRUE;
}
BOOL
vncService::SelectHDESK(HDESK new_desktop)
{
// Are we running on NT?
if (IsWinNT())
{
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
DWORD dummy;
char new_name[256];
if (!GetUserObjectInformation(new_desktop, UOI_NAME, &new_name, 256, &dummy)) {
return FALSE;
}
// Switch the desktop
if(!SetThreadDesktop(new_desktop)) {
return FALSE;
}
// Switched successfully - destroy the old desktop
CloseDesktop(old_desktop);
return TRUE;
}
return TRUE;
}
bool SelectDesktop()
{
HDESK desktop;
HDESK old_desktop;
DWORD dummy;
char new_name[256];
desktop = OpenInputDesktop(0, FALSE,
DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW |
DESKTOP_ENUMERATE | DESKTOP_HOOKCONTROL |
DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS |
DESKTOP_SWITCHDESKTOP | GENERIC_WRITE);
if (desktop == NULL) return FALSE;
old_desktop = GetThreadDesktop(GetCurrentThreadId());
if (!GetUserObjectInformation(desktop, UOI_NAME, &new_name, 256, &dummy)) {
CloseDesktop(desktop);
return FALSE;
}
if(!SetThreadDesktop(desktop)) {
CloseDesktop(desktop);
return FALSE;
}
CloseDesktop(old_desktop);
return TRUE;
}
bool SwitchInputDesktop()
{
BOOL bRet = false;
DWORD dwLengthNeeded;
HDESK hOldDesktop, hNewDesktop;
char strCurrentDesktop[256], strInputDesktop[256];
hOldDesktop = GetThreadDesktop(GetCurrentThreadId());
memset(strCurrentDesktop, 0, sizeof(strCurrentDesktop));
GetUserObjectInformation(hOldDesktop, UOI_NAME, &strCurrentDesktop, sizeof(strCurrentDesktop), &dwLengthNeeded);
hNewDesktop = OpenInputDesktop(0, FALSE, MAXIMUM_ALLOWED);
memset(strInputDesktop, 0, sizeof(strInputDesktop));
GetUserObjectInformation(hNewDesktop, UOI_NAME, &strInputDesktop, sizeof(strInputDesktop), &dwLengthNeeded);
if (lstrcmpi(strInputDesktop, strCurrentDesktop) != 0)
{
SetThreadDesktop(hNewDesktop);
bRet = true;
}
CloseDesktop(hOldDesktop);
CloseDesktop(hNewDesktop);
return bRet;
}
void *
SimulateCtrlAltDelThreadFn(void *context)
{
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
// Switch into the Winlogon desktop
if (!vncService::SelectDesktop("Winlogon"))
{
vnclog.Print(LL_INTERR, VNCLOG("failed to select logon desktop\n"));
return FALSE;
}
vnclog.Print(LL_ALL, VNCLOG("generating ctrl-alt-del\n"));
HWND hwndCtrlAltDel = FindWindow("SAS window class", "SAS window");
if (hwndCtrlAltDel == NULL) {
vnclog.Print(LL_INTERR, VNCLOG("\"SAS window\" not found\n"));
hwndCtrlAltDel = HWND_BROADCAST;
}
PostMessage(hwndCtrlAltDel, WM_HOTKEY, 0, MAKELONG(MOD_ALT | MOD_CONTROL, VK_DELETE));
// Switch back to our original desktop
if (old_desktop != NULL)
vncService::SelectHDESK(old_desktop);
return NULL;
}
BOOL
vncService::SelectHDESK(HDESK new_desktop)
{
// Are we running on NT?
if (IsWinNT())
{
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
DWORD dummy;
char new_name[256];
if (!GetUserObjectInformation(new_desktop, UOI_NAME, &new_name, 256, &dummy)) {
vnclog.Print(LL_INTERR, VNCLOG("GetUserObjectInformation() failed\n"));
return FALSE;
}
vnclog.Print(LL_INTINFO, VNCLOG("SelectHDESK() to %s (%x) from %x\n"),
new_name, new_desktop, old_desktop);
// Switch the desktop
if(!SetThreadDesktop(new_desktop)) {
vnclog.Print(LL_INTERR, VNCLOG("unable to SetThreadDesktop(), error=%d\n"), GetLastError());
return FALSE;
}
// Switched successfully - destroy the old desktop
if (!CloseDesktop(old_desktop))
vnclog.Print(LL_INTERR, VNCLOG("SelectHDESK failed to close old desktop %x, error=%d\n"), old_desktop, GetLastError());
return TRUE;
}
return TRUE;
}
void SimulateCtrlAltDelThreadFn()
{
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
// Switch into the Winlogon desktop
if (!vncService::SelectDesktop("Winlogon"))
{
//vnclog.Print(LL_INTERR, VNCLOG("failed to select logon desktop\n"));
Log.WinError(_ERROR_, "failed to select logon desktop");
if (!vncService::SelectDesktop("Default"))
{
Log.WinError(_ERROR_, "failed to select default desktop");
}
}
//vnclog.Print(LL_ALL, VNCLOG("generating ctrl-alt-del\n"));
// Fake a hotkey event to any windows we find there.... :(
// Winlogon uses hotkeys to trap Ctrl-Alt-Del...
PostMessage(HWND_BROADCAST, WM_HOTKEY, 0, MAKELONG(MOD_ALT | MOD_CONTROL, VK_DELETE));
// Switch back to our original desktop
if (old_desktop != NULL)
vncService::SelectHDESK(old_desktop);
}
/*************************************************
* Create a new Desktop and run a Process in it. *
* (Win NT+). *
*************************************************/
int DLL_EXP_IMP WINAPI Process_Desktop(char *szDesktopName, char *szPath)
{
HDESK hOriginalThread;
HDESK hOriginalInput;
HDESK hNewDesktop;
// Save original ...
hOriginalThread = GetThreadDesktop(GetCurrentThreadId());
hOriginalInput = OpenInputDesktop(0, FALSE, DESKTOP_SWITCHDESKTOP);
// Create a new Desktop and switch to it
hNewDesktop = CreateDesktop(szDesktopName, NULL, NULL, 0, GENERIC_ALL, NULL);
SetThreadDesktop(hNewDesktop);
SwitchDesktop(hNewDesktop);
// Execute process in new desktop
StartProcess(szDesktopName, szPath);
// Restore original ...
SwitchDesktop(hOriginalInput);
SetThreadDesktop(hOriginalThread);
// Close the Desktop
CloseDesktop(hNewDesktop);
return 0;
}
void do_InitialDesktop_child(int i)
{
HDESK hdesktop;
HWINSTA hwinsta;
WCHAR buffer[100];
DWORD size;
BOOL ret;
if(TestResults[i].ExpectedWinsta == NULL)
{
trace("Process should have failed to initialize\n");
return;
}
IsGUIThread(TRUE);
hdesktop = GetThreadDesktop(GetCurrentThreadId());
hwinsta = GetProcessWindowStation();
ret = GetUserObjectInformationW( hwinsta, UOI_NAME, buffer, sizeof(buffer), &size );
ok(ret == TRUE, "ret = %d\n", ret);
ok(wcscmp(buffer, TestResults[i].ExpectedWinsta) == 0, "Wrong winsta %S insted of %S\n", buffer, TestResults[i].ExpectedWinsta);
ret = GetUserObjectInformationW( hdesktop, UOI_NAME, buffer, sizeof(buffer), &size );
ok(ret == TRUE, "ret = %d\n", ret);
ok(wcscmp(buffer, TestResults[i].ExpectedDesktp) == 0, "Wrong desktop %S insted of %S\n", buffer, TestResults[i].ExpectedDesktp);
}
int SetUserDesktop( int mode )
{
static HWINSTA hwinstaSave;
static HDESK hdeskSave;
static HWINSTA hwinstaUser;
static HDESK hdeskUser;
if(mode == 1) {
hwinstaSave = GetProcessWindowStation();
hdeskSave = GetThreadDesktop(GetCurrentThreadId());
hwinstaUser = OpenWindowStation("WinSta0", FALSE, MAXIMUM_ALLOWED);
if (hwinstaUser == NULL)
return 0;
SetProcessWindowStation(hwinstaUser);
hdeskUser = OpenDesktop("Default", 0, FALSE, MAXIMUM_ALLOWED);
if (hdeskUser == NULL) {
SetProcessWindowStation(hwinstaSave);
CloseWindowStation(hwinstaUser);
return 0;
}
SetThreadDesktop(hdeskUser);
}
else if(mode == 0) {
SetThreadDesktop(hdeskSave);
SetProcessWindowStation(hwinstaSave);
CloseDesktop(hdeskUser);
CloseWindowStation(hwinstaUser);
}
return 0;
}
/* retrieve the desktop name to use if not specified on the command line */
static const WCHAR *get_default_desktop_name(void)
{
static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};
static const WCHAR defaultW[] = {'D','e','f','a','u','l','t',0};
static const WCHAR explorer_keyW[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
'E','x','p','l','o','r','e','r',0};
static WCHAR buffer[MAX_PATH];
DWORD size = sizeof(buffer);
HDESK desk = GetThreadDesktop( GetCurrentThreadId() );
WCHAR *ret = NULL;
HKEY hkey;
if (desk && GetUserObjectInformationW( desk, UOI_NAME, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
{
if (strcmpiW( buffer, defaultW )) return buffer;
}
/* @@ Wine registry key: HKCU\Software\Wine\Explorer */
if (!RegOpenKeyW( HKEY_CURRENT_USER, explorer_keyW, &hkey ))
{
if (!RegQueryValueExW( hkey, desktopW, 0, NULL, (LPBYTE)buffer, &size )) ret = buffer;
RegCloseKey( hkey );
}
return ret;
}
BOOL
vncService::SelectHDESK(HDESK new_desktop)
{
// Are we running on NT?
if (IsWinNT())
{
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
//You do not need to call the CloseDesktop function to close the returned handle.
DWORD dummy;
char new_name[256];
if (!GetUserObjectInformation(new_desktop, UOI_NAME, &new_name, 256, &dummy)) {
return FALSE;
}
//vnclog.Print(LL_INTERR, VNCLOG("SelectHDESK to %s (%x) from %x\n"), new_name, new_desktop, old_desktop);
// Switch the desktop
if(!SetThreadDesktop(new_desktop))
{
return FALSE;
}
return TRUE;
}
return TRUE;
}
/************************************************
* Create a new Desktop and run a Thread in it. *
* (Win NT+). *
************************************************/
int DLL_EXP_IMP WINAPI Thread_Desktop(LPTHREAD_START_ROUTINE ThreadFunc, THREAD_DATA *td)
{
HDESK hOriginalThread;
HDESK hOriginalInput;
HDESK hNewDesktop;
// Save original ...
hOriginalThread = GetThreadDesktop(GetCurrentThreadId());
hOriginalInput = OpenInputDesktop(0, FALSE, DESKTOP_SWITCHDESKTOP);
// Create a new Desktop and switch to it
hNewDesktop = CreateDesktop(td->szDesktopName, NULL, NULL, 0, GENERIC_ALL, NULL);
SetThreadDesktop(hNewDesktop);
SwitchDesktop(hNewDesktop);
// Execute thread in new desktop
td->hDesk = hNewDesktop;
StartThread(ThreadFunc, td);
// Restore original ...
SwitchDesktop(hOriginalInput);
SetThreadDesktop(hOriginalThread);
// Close the Desktop
CloseDesktop(hNewDesktop);
return 0;
}
void TitleWindow (HWND hWnd)
{
TCHAR *szTitle, *szName;
UINT nBytes = 0;
//
// How long is the desktop name?
//
GetUserObjectInformation (GetThreadDesktop(GetCurrentThreadId()),
UOI_NAME,
(LPVOID)&nBytes, // not used since cbInfo is 0
0,
&nBytes);
szName = (LPTSTR)GlobalAlloc (GPTR, nBytes);
if (!szName)
{
return;
}
//
// Now get the desktop name
//
GetUserObjectInformation (GetThreadDesktop(GetCurrentThreadId()),
UOI_NAME,
(LPVOID)szName,
nBytes,
&nBytes);
//
// Now make the window title
//
szTitle = (LPTSTR)GlobalAlloc (
GPTR,
(lstrlen(szAppName)+lstrlen(TEXT(" - "))) * sizeof(TCHAR) + nBytes);
if (!szTitle)
{
GlobalFree (szName);
return;
}
wsprintf (szTitle, TEXT("%s - %s"), szAppName, szName);
SetWindowText (hWnd, szTitle);
//
// Cleanup
//
GlobalFree (szName);
GlobalFree (szTitle);
}
bool Opc_client_ae_DriverThread::StartProcess(char* pCommandLine, char* pWorkingDir)
{
STARTUPINFO startUpInfo = { sizeof(STARTUPINFO),NULL,"",NULL,0,0,0,0,0,0,0,STARTF_USESHOWWINDOW,0,0,NULL,0,0,0};
nIndex = 1;
if(strlen(pCommandLine) > 4)
{
char pUserInterface[nBufferSize+1];
//printf("%s\n", pCommandLine);
strcpy(pUserInterface, "Y");
BOOL bUserInterface = (pUserInterface[0]=='y'||pUserInterface[0]=='Y'||pUserInterface[0]=='1')?TRUE:FALSE;
char CurrentDesktopName[512];
// set the correct desktop for the process to be started
if(bUserInterface)
{
//startUpInfo.wShowWindow = SW_SHOW;
startUpInfo.wShowWindow = SW_SHOWMINIMIZED;
startUpInfo.lpDesktop = NULL;
}
else
{
HDESK hCurrentDesktop = GetThreadDesktop(GetCurrentThreadId());
DWORD len;
GetUserObjectInformation(hCurrentDesktop,UOI_NAME,CurrentDesktopName,MAX_PATH,&len);
startUpInfo.wShowWindow = SW_HIDE;
startUpInfo.lpDesktop = CurrentDesktopName;
}
// create the process
DWORD dwCreateFlg = 0;
dwCreateFlg |= CREATE_NEW_CONSOLE;
memset(pProcInfo + nIndex, 0, sizeof(PROCESS_INFORMATION));
if(CreateProcess(NULL,pCommandLine,NULL,NULL,TRUE,dwCreateFlg,NULL,strlen(pWorkingDir)==0?NULL:pWorkingDir,&startUpInfo,pProcInfo + nIndex))
{
Sleep(100);
return TRUE;
}
else
{
fprintf(stderr,"Failed to start program '%s', error code = %d\n", pCommandLine, GetLastError());
fflush(stderr);
return FALSE;
}
}
else
{
return FALSE;
}
}
BOOL COpenDesktop::_OpenDesktop(LPCWSTR szName)
{
WCHAR pvInfo[128] = {0};
if(szName != NULL)
{
lstrcpy((LPSTR)pvInfo, (LPCSTR)szName);
}
else
{
HDESK hActiveDesktop;
DWORD dwLen;
hActiveDesktop = OpenInputDesktop(DF_ALLOWOTHERACCOUNTHOOK, FALSE, MAXIMUM_ALLOWED);
GetUserObjectInformation(hActiveDesktop, UOI_NAME, pvInfo, sizeof(pvInfo), &dwLen);
CloseDesktop(hActiveDesktop);
}
m_hwinstaCurrent = GetProcessWindowStation();
CheckPointer(m_hwinstaCurrent,FALSE);
m_hdeskCurrent = GetThreadDesktop(GetCurrentThreadId());
CheckPointer(m_hdeskCurrent,FALSE);
// ´ò¿ªwinsta0
m_hwinsta = OpenWindowStation(_T("winsta0"), FALSE,
WINSTA_ACCESSCLIPBOARD |
WINSTA_ACCESSGLOBALATOMS |
WINSTA_CREATEDESKTOP |
WINSTA_ENUMDESKTOPS |
WINSTA_ENUMERATE |
WINSTA_EXITWINDOWS |
WINSTA_READATTRIBUTES |
WINSTA_READSCREEN |
WINSTA_WRITEATTRIBUTES);
CheckPointer(m_hwinsta,FALSE);
if (!SetProcessWindowStation(m_hwinsta))
{
return FALSE;
}
// ´ò¿ªdesktop
m_hdesk = OpenDesktop((LPSTR)pvInfo, 0, FALSE,
DESKTOP_CREATEMENU |
DESKTOP_CREATEWINDOW |
DESKTOP_ENUMERATE |
DESKTOP_HOOKCONTROL |
DESKTOP_JOURNALPLAYBACK |
DESKTOP_JOURNALRECORD |
DESKTOP_READOBJECTS |
DESKTOP_SWITCHDESKTOP |
DESKTOP_WRITEOBJECTS);
CheckPointer(m_hdesk,FALSE);
SetThreadDesktop(m_hdesk);
return TRUE;
}
int pem_passwd_cb(char *buf, int size, int rwflag, void *userdata) {
int result;
#if 0
DWORD dwThreadId;
HWINSTA hwinstaSave;
HDESK hdeskSave;
HWINSTA hwinstaUser;
HDESK hdeskUser;
buf[0]='\0'; /* empty the buffer */
/* Save the window station and desktop */
hwinstaSave=GetProcessWindowStation();
if(!hwinstaSave)
ioerror("GetProcessWindowStation");
dwThreadId=GetCurrentThreadId();
if(!dwThreadId)
ioerror("GetCurrentThreadId");
hdeskSave=GetThreadDesktop(dwThreadId);
if(!hdeskSave)
ioerror("GetThreadDesktop");
/* Switch to WinSta0/Default */
hwinstaUser=OpenWindowStation("winsta0", FALSE, MAXIMUM_ALLOWED);
if(!hwinstaUser)
ioerror("OpenWindowStation");
if(!SetProcessWindowStation(hwinstaUser))
ioerror("SetProcessWindowStation");
hdeskUser=OpenDesktop("Default", 0, FALSE, MAXIMUM_ALLOWED); /* Winlogon */
if(!hdeskUser)
ioerror("OpenDesktop");
if(!SetThreadDesktop(hdeskUser))
ioerror("SetThreadDesktop");
#endif
/* Display the dialog box */
section=userdata;
result=DialogBox(ghInst, TEXT("PassBox"), hwnd, (DLGPROC)pass_proc);
#if 0
/* Restore window station and desktop */
if(!SetThreadDesktop(hdeskSave))
ioerror("SetThreadDesktop");
if(!SetProcessWindowStation(hwinstaSave))
ioerror("SetProcessWindowStation");
if(!CloseDesktop(hdeskUser))
ioerror("CloseDesktop");
if(!CloseWindowStation(hwinstaUser))
ioerror("CloseWindowStation");
#endif
if(!result)
return 0;
strncpy(buf, passphrase, size);
buf[size - 1] = '\0';
return strlen(buf);
}
static BOOL CALLBACK
check_winsta(wchar_t* winsta_name, LPARAM)
{
debug(L"entering enum_winsta_proc, winsta_name = %s\n", winsta_name);
// open the window station and connect to it
// (TODO: figure out what permissions are really needed here)
//
HWINSTA winsta = OpenWindowStation(winsta_name, FALSE, MAXIMUM_ALLOWED);
if (winsta == NULL) {
debug(L"OpenWindowStation error: %u\n", GetLastError());
return TRUE;
}
HWINSTA old_winsta = GetProcessWindowStation();
if (SetProcessWindowStation(winsta) == FALSE) {
debug(L"SetProcessWindowStation error: %u\n", GetLastError());
if (CloseWindowStation(winsta) == FALSE) {
debug(L"CloseWindowStation error: %u\n", GetLastError());
}
return TRUE;
}
if (CloseWindowStation(old_winsta) == FALSE) {
debug(L"CloseWindowStation error: %u\n", GetLastError());
}
// open the "default" desktop and connect to it (if present)
// (TODO: figure out what permissions are really needed here)
//
HDESK desktop = OpenDesktop(L"default", 0, FALSE, MAXIMUM_ALLOWED);
if (desktop == NULL) {
debug(L"OpenDesktop error: %u\n", GetLastError());
return TRUE;
}
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
if (SetThreadDesktop(desktop) == FALSE) {
debug(L"SetThreadDesktop error: %u\n", GetLastError());
if (CloseDesktop(desktop) == FALSE) {
debug(L"CloseDesktop error: %u\n", GetLastError());
}
return TRUE;
}
if (CloseDesktop(old_desktop) == FALSE) {
debug(L"CloseDesktop error: %u\n", GetLastError());
}
// check_this_winsta() returns TRUE if it found the pid, FALSE if not
//
BOOL found = check_this_winsta();
if (found) {
SetLastError(ERROR_SUCCESS);
}
// return TRUE to keep searching
return ! found;
}
static void KillWallpaper()
{
//only kill wallpaper if desktop is user desktop
HDESK desktop = GetThreadDesktop(GetCurrentThreadId());
DWORD dummy;
char new_name[256];
if (GetUserObjectInformation(desktop, UOI_NAME, &new_name, 256, &dummy))
{
if (strcmp(new_name,"Default")==NULL) HideDesktop();
}
}
void
vncDesktop::StartInitWindowthread()
{
// Check if the input desktop == Default desktop
// Hooking the winlogon is not needed, no clipboard
// see if the threaddesktop== Default
HDESK desktop = GetThreadDesktop(GetCurrentThreadId());
DWORD dummy;
char new_name[256];
can_be_hooked=false;
vnclog.Print(LL_INTINFO, VNCLOG("StartInitWindowthread \n"));
if (GetUserObjectInformation(desktop, UOI_NAME, &new_name, 256, &dummy))
{
if (strcmp(new_name,"Default")==0)
{
vnclog.Print(LL_INTINFO, VNCLOG("StartInitWindowthread default desk\n"));
if (InitWindowThreadh==NULL)
{
ResetEvent(restart_event);
InitWindowThreadh=CreateThread(NULL,0,InitWindowThread,this,0,&pumpID);
DWORD status=WaitForSingleObject(restart_event,10000);
if (status==WAIT_TIMEOUT)
{
vnclog.Print(LL_INTINFO, VNCLOG("ERROR: initwindowthread failed to start \n"));
if (InitWindowThreadh!=NULL)
{
TerminateThread(InitWindowThreadh,0);
CloseHandle(InitWindowThreadh);
m_hwnd=NULL;
InitWindowThreadh=NULL;
}
can_be_hooked=false;
}
else
{
vnclog.Print(LL_INTINFO, VNCLOG("StartInitWindowthread started\n"));
can_be_hooked=true;
}
}
else
{
// initwindowthread is still running
// make it back active
vnclog.Print(LL_INTINFO, VNCLOG("StartInitWindowthread reactivate\n"));
can_be_hooked=true;
}
}
else
{
vnclog.Print(LL_INTINFO, VNCLOG("StartInitWindowthread no default desk\n"));
}
}
}
static DWORD CALLBACK thread( LPVOID arg )
{
HDESK d1, d2;
HWND hwnd = CreateWindowExA(0,"WinStationClass","test",WS_POPUP,0,0,100,100,GetDesktopWindow(),0,0,0);
ok( hwnd != 0, "CreateWindow failed\n" );
d1 = GetThreadDesktop(GetCurrentThreadId());
trace( "thread %p desktop: %p\n", arg, d1 );
ok( d1 == initial_desktop, "thread %p doesn't use initial desktop\n", arg );
SetLastError( 0xdeadbeef );
ok( !CloseHandle( d1 ), "CloseHandle succeeded\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
SetLastError( 0xdeadbeef );
ok( !CloseDesktop( d1 ), "CloseDesktop succeeded\n" );
ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
print_object( d1 );
d2 = CreateDesktop( "foobar2", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
trace( "created desktop %p\n", d2 );
ok( d2 != 0, "CreateDesktop failed\n" );
SetLastError( 0xdeadbeef );
ok( !SetThreadDesktop( d2 ), "set thread desktop succeeded with existing window\n" );
ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
DestroyWindow( hwnd );
ok( SetThreadDesktop( d2 ), "set thread desktop failed\n" );
d1 = GetThreadDesktop(GetCurrentThreadId());
ok( d1 == d2, "GetThreadDesktop did not return set desktop %p/%p\n", d1, d2 );
print_object( d2 );
if (arg < (LPVOID)5)
{
HANDLE hthread = CreateThread( NULL, 0, thread, (char *)arg + 1, 0, NULL );
Sleep(1000);
WaitForSingleObject( hthread, INFINITE );
CloseHandle( hthread );
}
return 0;
}
BOOL shutdown_all_desktops( BOOL force )
{
BOOL ret;
HDESK prev_desktop;
prev_desktop = GetThreadDesktop(GetCurrentThreadId());
ret = EnumDesktopsW( NULL, shutdown_one_desktop, (LPARAM)force );
SetThreadDesktop(prev_desktop);
return ret;
}
void Test_DesktopAccess()
{
HDESK hDesk, hDeskInitial;
POINT curPoint, initialPoint;
BOOL ret;
hDeskInitial = GetThreadDesktop(GetCurrentThreadId());
ok(hDeskInitial != NULL, "Failed to retrieve the initial desktop\n");
ret = GetCursorPos(&initialPoint);
ok(ret == TRUE, "GetCursorPos should succed\n");
hDesk = CreateDesktopW(L"testDesktop", NULL, NULL, 0, 0x01ff, NULL);
ok(hDesk != 0, "Failed to create a new desktop\n");
SetThreadDesktop(hDesk);
ok(GetThreadDesktop(GetCurrentThreadId()) == hDesk, "SetThreadDesktop had no effect\n");
SetLastError(0xdeadbeef);
ret = GetCursorPos(&curPoint);
ok(ret == FALSE, "GetCursorPos should fail\n");
ok(GetLastError() == ERROR_ACCESS_DENIED, "Expected ERROR_ACCESS_DENIED got 0x%lu\n", GetLastError());
SetLastError(0xdeadbeef);
ret = SetCursorPos(2,2);
ok(ret == FALSE, "SetCursorPos should fail\n");
ok(GetLastError() == 0xdeadbeef, "Wrong last error, got 0x%lu\n", GetLastError());
ret = GetCursorPos(&curPoint);
ok(ret == FALSE, "GetCursorPos should fail\n");
SetThreadDesktop(hDeskInitial);
ret = GetCursorPos(&curPoint);
ok(ret == TRUE, "GetCursorPos should succed\n");
ok(curPoint.x == initialPoint.x && curPoint.y == initialPoint.y, "Mouse position changed\n");
}
void Test_OpenInputDesktop()
{
HDESK hDeskInput ,hDeskInput2;
HDESK hDeskInitial;
BOOL ret;
HWINSTA hwinsta = NULL, hwinstaInitial;
DWORD err;
hDeskInput = OpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
ok(hDeskInput != NULL, "OpenInputDesktop failed\n");
hDeskInitial = GetThreadDesktop( GetCurrentThreadId() );
ok(hDeskInitial != NULL, "GetThreadDesktop failed\n");
ok(hDeskInput != hDeskInitial, "OpenInputDesktop returned thread desktop\n");
hDeskInput2 = OpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
ok(hDeskInput2 != NULL, "Second call to OpenInputDesktop failed\n");
ok(hDeskInput2 != hDeskInput, "Second call to OpenInputDesktop returned same handle\n");
ok(CloseDesktop(hDeskInput2) != 0, "CloseDesktop failed\n");
ret = SetThreadDesktop(hDeskInput);
ok(ret == TRUE, "SetThreadDesktop for input desktop failed\n");
ret = SetThreadDesktop(hDeskInitial);
ok(ret == TRUE, "SetThreadDesktop for initial desktop failed\n");
ok(CloseDesktop(hDeskInput) != 0, "CloseDesktop failed\n");
/* Try calling OpenInputDesktop after switching to a new winsta */
hwinstaInitial = GetProcessWindowStation();
ok(hwinstaInitial != 0, "GetProcessWindowStation failed\n");
hwinsta = CreateWindowStationW(L"TestWinsta", 0, WINSTA_ALL_ACCESS, NULL);
ok(hwinsta != 0, "CreateWindowStationW failed\n");
ret = SetProcessWindowStation(hwinsta);
ok(ret != 0, "SetProcessWindowStation failed\n");
hDeskInput = OpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
ok(hDeskInput == 0, "OpenInputDesktop should fail\n");
err = GetLastError();
ok(err == ERROR_INVALID_FUNCTION, "Got last error: %lu\n", err);
ret = SetProcessWindowStation(hwinstaInitial);
ok(ret != 0, "SetProcessWindowStation failed\n");
ret = CloseWindowStation(hwinsta);
ok(ret != 0, "CloseWindowStation failed\n");
}
// get the current input desktop name and compare with
// the desktop the call thread attached ,if not equal,
// then switch to the input desktop
BOOL SwitchInputDesktop()
{
HDESK threaddesk = GetThreadDesktop(GetCurrentThreadId());
HDESK inputdesk = OpenInputDesktop(0, DF_ALLOWOTHERACCOUNTHOOK,GENERIC_ALL);
if (inputdesk == NULL)
{
DebugOutF(filelog::log_error,("OpenInputDesktop failed with %d"),GetLastError());
return FALSE;
}
DWORD len=0;
TCHAR szThread[MAX_PATH];
TCHAR szInput[MAX_PATH];
szThread[0] = _T('\0');
szInput[0] = _T('\0');
BOOL res = FALSE;
try
{
// get desktop name
if(!GetUserObjectInformation(threaddesk, UOI_NAME, szThread, MAX_PATH, &len)){
DebugOutF(filelog::log_error,("GetUserObjectInformation failed with %d"),GetLastError());
throw FALSE;
}
if (!GetUserObjectInformation(inputdesk, UOI_NAME, szInput, MAX_PATH, &len)) {
DebugOutF(filelog::log_error,("GetUserObjectInformation failed with %d"),GetLastError());
throw FALSE;
}
//compare,if not equal,then switch to the input desktop
if (_tcsicmp(szThread, szInput) != 0)
{
if(!SetThreadDesktop(inputdesk)){
DebugOutF(filelog::log_error,("SetThreadDesktop %s failed with %d"),szInput,GetLastError());
throw FALSE;
}
DebugOutF(filelog::log_info,("switch input desktop %s"),szInput);
res = TRUE;
}
}
catch(BOOL b1)
{
res = b1;
}
if(threaddesk)CloseDesktop(threaddesk);
if(inputdesk)CloseDesktop(inputdesk);
return res;
}
EnterDesktop(HDESK hdesk) : old(0) {
old = GetThreadDesktop(GetCurrentThreadId());
if (hdesk == old)
{
// obvious case where thread is already on the requisite desktop - nothing to do
old = 0;
}
else if (!SetThreadDesktop(hdesk))
{
// something bad happened, don't try to restore the desktop
old = 0;
LCF1(L"SetThreadDesktop failed: %d", GetLastError());
}
}
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
try {
wchar_t* desktop = L"NewDesktop";
HDESK hThreadDT = GetThreadDesktop(GetCurrentThreadId());
HDESK hInputDT = OpenInputDesktop(0, FALSE, DESKTOP_SWITCHDESKTOP);
HDESK hNewDT = CreateDesktop(desktop, NULL, NULL, 0, GENERIC_ALL, NULL);
SetThreadDesktop(hNewDT);
SwitchDesktop(hNewDT);
PROCESS_INFORMATION pi;
STARTUPINFO si;
memset(&pi, 0, sizeof(pi));
memset(&si, 0, sizeof(si));
si.cb = sizeof(si);
si.lpDesktop = desktop;
wchar_t cmdline[MAX_PATH];
wsprintf(cmdline, L"%s %s", L"NAMCredentialWizard.exe", L"/u");
if (CreateProcess(L"NAMCredentialWizard.exe", cmdline,
NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
WaitForSingleObject(pi.hProcess, INFINITE);
}
else {
wchar_t msg[1000];
wsprintf(msg,L"CreateProcess failed (%d)",GetLastError());
MessageBox(NULL,msg,NULL,MB_OK);
}
SwitchDesktop(hInputDT);
SetThreadDesktop(hThreadDT);
CloseDesktop(hNewDT);
return 0;
} catch(...)
{ MessageBox(NULL,L"Caught Exception",NULL,MB_OK);
}
}
DWORD WINAPI BlackWindow(LPVOID lpParam)
{
// TODO: Place code here.
HDESK desktop;
desktop = OpenInputDesktop(0, FALSE,
DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW |
DESKTOP_ENUMERATE | DESKTOP_HOOKCONTROL |
DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS |
DESKTOP_SWITCHDESKTOP | GENERIC_WRITE
);
if (desktop == NULL)
vnclog.Print(LL_INTERR, VNCLOG("OpenInputdesktop Error \n"));
else
vnclog.Print(LL_INTERR, VNCLOG("OpenInputdesktop OK\n"));
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
DWORD dummy;
char new_name[256];
if (desktop)
{
if (!GetUserObjectInformation(desktop, UOI_NAME, &new_name, 256, &dummy))
{
vnclog.Print(LL_INTERR, VNCLOG("!GetUserObjectInformation \n"));
}
vnclog.Print(LL_INTERR, VNCLOG("SelectHDESK to %s (%x) from %x\n"), new_name, desktop, old_desktop);
if (!SetThreadDesktop(desktop))
{
vnclog.Print(LL_INTERR, VNCLOG("SelectHDESK:!SetThreadDesktop \n"));
}
}
create_window();
MSG msg;
while (GetMessage(&msg,0,0,0) != 0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
vnclog.Print(LL_INTERR, VNCLOG("end BlackWindow \n"));
SetThreadDesktop(old_desktop);
if (desktop) CloseDesktop(desktop);
return 0;
}
