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; }