vncEncodeZlib::vncEncodeZlib()
{
m_buffer = NULL;
m_buffer2 = NULL;
m_Queuebuffer = NULL;
m_QueueCompressedbuffer = NULL;
m_bufflen = 0;
m_Queuelen = 0;
m_Maskbuffer =NULL;
m_MaskbufferSize =0;
compStreamInited = false;
MaxQueuebufflen=128*1024;
m_Queuebuffer = new BYTE [MaxQueuebufflen+1];
if (m_Queuebuffer == NULL)
{
vnclog.Print(LL_INTINFO, VNCLOG("Memory error"));
}
m_QueueCompressedbuffer = new BYTE [MaxQueuebufflen+(MaxQueuebufflen/100)+8];
if (m_Queuebuffer == NULL)
{
vnclog.Print(LL_INTINFO, VNCLOG("Memory error"));
}
}
// sf@2007 - For now we use a mmtimer to test the shutdown event periodically
// Maybe there's a less rude method...
void CALLBACK fpTimer(UINT uID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
{
if (hShutdownEvent)
{
// vnclog.Print(LL_INTERR, VNCLOG("****************** SDTimer tic\n"));
DWORD result=WaitForSingleObject(hShutdownEvent, 0);
if (WAIT_OBJECT_0==result)
{
ResetEvent(hShutdownEvent);
fShutdownOrdered = true;
vnclog.Print(LL_INTERR, VNCLOG("****************** WaitForSingleObject - Shutdown server\n"));
}
}
}
void setConsoleSession(DWORD sessionId) {
#ifdef RFB_HAVE_WINSTATION_CONNECT
if (!_WinStationConnect.isValid()) {
vnclog.Print(LL_INTERR, VNCLOG("WinSta APIs missing"));
return;
}
if (sessionId == -1)
sessionId = mySessionId.id;
// Try to reconnect our session to the console
ConsoleSessionId console;
vnclog.Print(LL_INTINFO, VNCLOG("Console session is %d"), console.id);
if (!(*_WinStationConnect)(0, sessionId, console.id, L"", 0)) {
vnclog.Print(LL_INTERR, VNCLOG("Unable to connect session to Console (error %d)"), GetLastError());
return;
}
// Lock the newly connected session, for security
if (_LockWorkStation.isValid())
(*_LockWorkStation)();
#else
vnclog.Print(LL_INTERR, VNCLOG("setConsoleSession not implemented"));
#endif
}
BOOL
vncBuffer::GetRemotePalette(RGBQUAD *quadlist, UINT ncolours)
{
// Try to get the RGBQUAD data from the encoder
// This will only work if the remote client is palette-based,
// in which case the encoder will be storing RGBQUAD data
if (m_encoder == NULL)
{
vnclog.Print(LL_INTWARN, VNCLOG("GetRemotePalette called but no encoder set\n"));
return FALSE;
}
// Now get the palette data
return m_encoder->GetRemotePalette(quadlist, ncolours);
}
HKEY vncVideoDriver::CreateDeviceKey(LPCTSTR szMpName)
{
HKEY hKeyProfileMirror = (HKEY)0;
if (RegCreateKey(
HKEY_LOCAL_MACHINE,
(MINIPORT_REGISTRY_PATH),
&hKeyProfileMirror) != ERROR_SUCCESS)
{
vnclog.Print(LL_INTERR, VNCLOG("Can't access registry.\n"));
return FALSE;
}
HKEY hKeyProfileMp = (HKEY)0;
LONG cr = RegCreateKey(
hKeyProfileMirror,
szMpName,
&hKeyProfileMp);
RegCloseKey(hKeyProfileMirror);
if (cr != ERROR_SUCCESS)
{
vnclog.Print(
LL_INTERR,
VNCLOG("Can't access \"%s\" hardware profiles key.\n"),
szMpName);
return FALSE;
}
HKEY hKeyDevice = (HKEY)0;
if (RegCreateKey(
hKeyProfileMp,
("DEVICE0"),
&hKeyDevice) != ERROR_SUCCESS)
{
vnclog.Print(LL_INTERR, VNCLOG("Can't access DEVICE0 hardware profiles key.\n"));
}
RegCloseKey(hKeyProfileMp);
return hKeyDevice;
}
// Internal methods
BOOL
vncClient::SendRFBMsg(CARD8 type, BYTE *buffer, int buflen)
{
// Set the message type
((rfbServerToClientMsg *)buffer)->type = type;
// Send the message
if (!m_socket->SendExact((char *) buffer, buflen))
{
vnclog.Print(LL_CONNERR, VNCLOG("failed to send RFB message to client\n"));
Kill();
return FALSE;
}
return TRUE;
}
VSocket::VSocket()
{
// Clear out the internal socket fields
sock = -1;
vnclog.Print(LL_SOCKINFO, VNCLOG("VSocket() m_pDSMPlugin = NULL \n"));
m_pDSMPlugin = NULL;
//adzm 2009-06-20
m_pPluginInterface = NULL;
m_fUsePlugin = false;
m_pNetRectBuf = NULL;
m_nNetRectBufSize = 0;
m_fWriteToNetRectBuf = false;
m_nNetRectBufOffset = 0;
queuebuffersize=0;
}
HINSTANCE LoadNImport(LPCTSTR szDllName, LPCTSTR szFName, TpFn &pfn)
{
HINSTANCE hDll = LoadLibrary(szDllName);
if (hDll)
{
pfn = (TpFn)GetProcAddress(hDll, szFName);
if (pfn)
return hDll;
FreeLibrary(hDll);
}
vnclog.Print(
LL_INTERR,
VNCLOG("Can not import '%s' from '%s'.\n"),
szFName, szDllName);
return NULL;
}
vncMenu::~vncMenu()
{
vnclog.Print(LL_INTERR, VNCLOG("vncmenu killed\n"));
// adzm 2009-07-05 - Tray icon balloon tips
if (m_BalloonInfo) {
free(m_BalloonInfo);
m_BalloonInfo = NULL;
}
if (m_BalloonTitle) {
free(m_BalloonTitle);
m_BalloonTitle = NULL;
}
if (hWTSDll)
{
WTSUNREGISTERSESSIONNOTIFICATION FunctionWTSUnRegisterSessionNotification;
FunctionWTSUnRegisterSessionNotification = (WTSUNREGISTERSESSIONNOTIFICATION)GetProcAddress((HINSTANCE)hWTSDll,"WTSUnRegisterSessionNotification" );
if (FunctionWTSUnRegisterSessionNotification)
FunctionWTSUnRegisterSessionNotification( m_hwnd );
FreeLibrary( hWTSDll );
hWTSDll = NULL;
}
if (m_winvnc_icon)
DestroyIcon(m_winvnc_icon);
if (m_flash_icon)
DestroyIcon(m_flash_icon);
// Remove the tray icon
DelTrayIcon();
// Destroy the loaded menu
if (m_hmenu != NULL)
DestroyMenu(m_hmenu);
// Tell the server to stop notifying us!
if (m_server != NULL)
m_server->RemNotify(m_hwnd);
if (m_server->RemoveWallpaperEnabled())
RestoreWallpaper();
if (m_server->RemoveAeroEnabled())
ResetAero();
}
BOOL
vncClientUpdateThread::Init(vncClient *client)
{
vnclog.Print(LL_INTINFO, VNCLOG("init update thread\n"));
m_client = client;
omni_mutex_lock l(m_client->GetUpdateLock());
m_signal = new omni_condition(&m_client->GetUpdateLock());
m_sync_sig = new omni_condition(&m_client->GetUpdateLock());
m_active = TRUE;
m_enable = m_client->m_disable_protocol == 0;
if (m_signal && m_sync_sig) {
start_undetached();
return TRUE;
}
return FALSE;
}
// Modef rdv@202
void
vncServer::SetNewSWSize(long w,long h,BOOL desktop)
{
vncClientList::iterator i;
omni_mutex_lock l(m_clientsLock);
// Post this screen size update to all the connected clients
for (i = m_authClients.begin(); i != m_authClients.end(); i++)
{
// Post the update
if (!GetClient(*i)->SetNewSWSize(w,h,desktop)) {
vnclog.Print(LL_INTINFO, VNCLOG("Unable to set new desktop size\n"));
KillClient(*i);
}
}
}
BOOL vncServer::SetShareMonitorFromPoint(POINT pt)
{
HINSTANCE hInstUser32 = LoadLibrary("User32.DLL");
if (!hInstUser32) return FALSE;
pMonitorFromPoint pMFP = (pMonitorFromPoint)GetProcAddress(hInstUser32, "MonitorFromPoint");
pGetMonitorInfo pGMI = (pGetMonitorInfo)GetProcAddress(hInstUser32, "GetMonitorInfoA");
if (!pMFP || !pGMI)
{
vnclog.Print(
LL_INTERR,
VNCLOG("Can not import '%s' and '%s' from '%s'.\n"),
"MonitorFromPoint",
"GetMonitorInfoA",
"User32.DLL");
FreeLibrary(hInstUser32);
return FALSE;
}
HMONITOR hm = pMFP(pt, MONITOR_DEFAULTTONEAREST);
if (!hm)
{
FreeLibrary(hInstUser32);
return FALSE;
}
MONITORINFO moninfo;
moninfo.cbSize = sizeof(moninfo);
if (!pGMI(hm, &moninfo))
{
FreeLibrary(hInstUser32);
return FALSE;
}
FullScreen(FALSE);
WindowShared(FALSE);
ScreenAreaShared(TRUE);
PrimaryDisplayOnlyShared(FALSE);
SetMatchSizeFields(
moninfo.rcMonitor.left,
moninfo.rcMonitor.top,
moninfo.rcMonitor.right,
moninfo.rcMonitor.bottom);
FreeLibrary(hInstUser32);
return TRUE;
}
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"));
}
}
}
VBool
VSocket::Close()
{
if (sock >= 0)
{
vnclog.Print(LL_SOCKINFO, VNCLOG("closing socket\n"));
shutdown(sock, SD_BOTH);
#ifdef __WIN32__
closesocket(sock);
#else
close(sock);
#endif
sock = -1;
}
return VSocketBase::Close();
}
void
vncProperties::SaveUserPrefs(HKEY appkey)
{
// SAVE THE PER USER PREFS
vnclog.Print(LL_INTINFO, VNCLOG("saving current settings to registry\n"));
// Connection prefs
SaveInt(appkey, "SocketConnect", m_server->SockConnected());
SaveInt(appkey, "HTTPConnect", m_server->HTTPConnectEnabled());
SaveInt(appkey, "AutoPortSelect", m_server->AutoPortSelect());
if (!m_server->AutoPortSelect())
SaveInt(appkey, "PortNumber", m_server->GetPort());
SaveInt(appkey, "InputsEnabled", m_server->RemoteInputsEnabled());
SaveInt(appkey, "LocalInputsDisabled", m_server->LocalInputsDisabled());
SaveInt(appkey, "IdleTimeout", m_server->AutoIdleDisconnectTimeout());
// Connection querying settings
SaveInt(appkey, "QuerySetting", m_server->QuerySetting());
SaveInt(appkey, "QueryTimeout", m_server->QueryTimeout());
// Lock settings
SaveInt(appkey, "LockSetting", m_server->LockSettings());
// Wallpaper removal
SaveInt(appkey, "RemoveWallpaper", m_server->RemoveWallpaperEnabled());
// Save the password
char passwd[MAXPWLEN];
m_server->GetPassword(passwd);
SavePassword(appkey, passwd);
#if(defined(_CORBA))
// Don't save the CORBA enabled flag if CORBA is not compiled in!
SaveInt(appkey, "CORBAConnect", m_server->CORBAConnected());
#endif
// Polling prefs
SaveInt(appkey, "PollUnderCursor", m_server->PollUnderCursor());
SaveInt(appkey, "PollForeground", m_server->PollForeground());
SaveInt(appkey, "PollFullScreen", m_server->PollFullScreen());
SaveInt(appkey, "OnlyPollConsole", m_server->PollConsoleOnly());
SaveInt(appkey, "OnlyPollOnEvent", m_server->PollOnEventOnly());
}
BOOL
vncBuffer::SetClientFormat(rfbPixelFormat &format)
{
vnclog.Print(LL_INTINFO, VNCLOG("SetClientFormat called\n"));
// Save the desired format
m_clientfmtset = TRUE;
m_clientformat = format;
// Tell the encoder of the new format
if (m_encoder != NULL)
m_encoder->SetRemoteFormat(format);
// Check that the output buffer is sufficient
if (!CheckBuffer())
return FALSE;
return TRUE;
}
BOOL
vncService::PostAddNewClientInit(unsigned long ipaddress, unsigned short port)
{
// Post to the WinVNC menu window
if (!PostToWinVNC(MENU_ADD_CLIENT_MSG_INIT, (WPARAM)port, (LPARAM)ipaddress))
{
//MessageBoxSecure(NULL, sz_ID_NO_EXIST_INST, szAppName, MB_ICONEXCLAMATION | MB_OK);
//Little hack, seems postmessage fail in some cases on some os.
//permission proble
//use G_var + WM_time to reconnect
vnclog.Print(LL_INTERR, VNCLOG("PostAddNewClient failed\n"));
if (port==1111 && ipaddress==1111) G_1111=true;
return FALSE;
}
return TRUE;
}
void
vncDesktop::ShutdownInitWindowthread()
{
// we keep the sink window running
// but ignore info
can_be_hooked=false;
vnclog.Print(LL_INTINFO, VNCLOG("ShutdownInitWindowthread \n"));
if (startw8)
{
#ifdef _DEBUG
char szText[256];
sprintf(szText,"StartStophookdll(0) \n");
OutputDebugString(szText);
#endif
StartStophookdll(0);
Hookdll_Changed = true;
}
}
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;
}
extern "C" DLLEXPORT /*export without name mangling*/
int WinVNCDll_DestroyServer()
{
if (!m_server) { return -1; };
if (!m_WinVNCDll_Initialized) { return -1; };
fShutdownOrdered = true;
m_server->ShutdownServer();
if (threadHandle)
{
WaitForSingleObject( threadHandle, INFINITE );
CloseHandle(threadHandle);
}
vnclog.Print(LL_STATE, VNCLOG("################## Closing Imp Thread\n"));
delete m_server;
m_server = 0;
return 0; //OK
}
void
vncEncodeUltra::AddToQueu2(BYTE *source,int sizerect,VSocket *outConn,int updatetype)
{
BYTE *databegin=m_QueueCompressedbuffer+sz_rfbFramebufferUpdateRectHeader+sz_rfbZlibHeader;
rfbFramebufferUpdateRectHeader *CacheRectsHeader=(rfbFramebufferUpdateRectHeader*)m_QueueCompressedbuffer;
rfbZlibHeader *CacheZipHeader=(rfbZlibHeader*)m_QueueCompressedbuffer+sz_rfbFramebufferUpdateRectHeader;
const lzo_uint rawDataSize = (sizerect);
lzo1x_1_compress(source,rawDataSize,databegin,&out_len,wrkmem);
if (out_len>rawDataSize)
{
outConn->SendExactQueue( (char *)source, sizerect); // 1 Small update
encodedSize += sizerect-sz_rfbFramebufferUpdateRectHeader;
rectangleOverhead += sz_rfbFramebufferUpdateRectHeader;
return;
}
int rawDataSize1=rawDataSize/65535;
int rawDataSize2=rawDataSize%65535;
CacheRectsHeader->r.x = (CARD16)(1);
CacheRectsHeader->r.y = (CARD16)(rawDataSize2);
CacheRectsHeader->r.w = (CARD16)(rawDataSize1);
CacheRectsHeader->r.x = Swap16IfLE(CacheRectsHeader->r.x);
CacheRectsHeader->r.y = Swap16IfLE(CacheRectsHeader->r.y);
CacheRectsHeader->r.w = Swap16IfLE(CacheRectsHeader->r.w);
CacheRectsHeader->r.h = 0;
CacheRectsHeader->encoding = Swap32IfLE(rfbEncodingUltraZip);
// Format the UltraHeader
CacheZipHeader->nBytes = Swap32IfLE(out_len);
vnclog.Print(LL_INTINFO, VNCLOG("********QUEUEQUEUE********** %d %d %d\r\n"),out_len,rawDataSize,1);
outConn->SendExactQueue((char *)m_QueueCompressedbuffer, out_len+sz_rfbFramebufferUpdateRectHeader+sz_rfbZlibHeader);
// Update statistics
encodedSize += sz_rfbZlibHeader + out_len;
rectangleOverhead += sz_rfbFramebufferUpdateRectHeader;
transmittedSize += out_len+sz_rfbFramebufferUpdateRectHeader+sz_rfbZlibHeader;
}
VBool
VSocket::Close()
{
if (sock >= 0)
{
vnclog.Print(LL_SOCKINFO, VNCLOG("closing socket\n"));
shutdown(sock, SD_BOTH);
#ifdef __WIN32__
closesocket(sock);
#else
close(sock);
#endif
sock = -1;
}
//adzm 2009-06-20
if (m_pPluginInterface) {
delete m_pPluginInterface;
m_pPluginInterface=NULL;
}
return VTrue;
}
VInt VSocket::Send(const char *buff, const VCard bufflen)
{
errno = 0;
VInt bytes = send(sock, buff, bufflen, 0);
if (bytes < 0)
{
int wsa_error = WSAGetLastError();
vnclog.Print(
LL_SOCKERR,
VNCLOG("send(0x%x, 0x%x, %d, 0): wsa_error = %d\n"),
sock,
buff,
bufflen,
wsa_error);
#ifdef __WIN32__
if (wsa_error == WSAEWOULDBLOCK)
errno = EWOULDBLOCK;
#endif
}
return bytes;
}
void
vncServer::GetScreenInfo(int &width, int &height, int &depth)
{
rfbServerInitMsg scrinfo;
omni_mutex_lock l(m_desktopLock);
vnclog.Print(LL_INTINFO, VNCLOG("GetScreenInfo called\n"));
// Is a desktop object currently active?
if (m_desktop == NULL)
{
vncDesktop desktop;
// No, so create a dummy desktop and interrogate it
if (!desktop.Init(this))
{
scrinfo.framebufferWidth = 0;
scrinfo.framebufferHeight = 0;
scrinfo.format.bitsPerPixel = 0;
}
else
{
desktop.FillDisplayInfo(&scrinfo);
}
}
else
{
m_desktop->FillDisplayInfo(&scrinfo);
}
// Get the info from the scrinfo structure
width = scrinfo.framebufferWidth;
height = scrinfo.framebufferHeight;
depth = scrinfo.format.bitsPerPixel;
}
// Process window messages
LRESULT CALLBACK vncMenu::WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
// This is a static method, so we don't know which instantiation we're
// dealing with. We use Allen Hadden's ([email protected]) suggestion
// from a newsgroup to get the pseudo-this.
vncMenu *_this = (vncMenu *) GetWindowLong(hwnd, GWL_USERDATA);
// Beep(100,10);
// vnclog.Print(LL_INTINFO, VNCLOG("iMsg 0x%x \n"),iMsg);
switch (iMsg)
{
// Every five seconds, a timer message causes the icon to update
case WM_TIMER:
// *** HACK for running servicified
if (vncService::RunningAsService()) {
// Attempt to add the icon if it's not already there
_this->AddTrayIcon();
// Trigger a check of the current user
PostMessage(hwnd, WM_USERCHANGED, 0, 0);
}
if (nport!=0)
{
PostMessage(hwnd, RETRY_MESSAGE, 0, 0);
}
// Update the icon
_this->FlashTrayIcon(_this->m_server->AuthClientCount() != 0);
break;
// DEAL WITH NOTIFICATIONS FROM THE SERVER:
case WM_SRV_CLIENT_AUTHENTICATED:
case WM_SRV_CLIENT_DISCONNECT:
// Adjust the icon accordingly
_this->FlashTrayIcon(_this->m_server->AuthClientCount() != 0);
if (_this->m_server->AuthClientCount() != 0) {
if (_this->m_server->RemoveWallpaperEnabled())
KillWallpaper();
} else {
if (_this->m_server->RemoveWallpaperEnabled())
RestoreWallpaper();
}
return 0;
// STANDARD MESSAGE HANDLING
case WM_CREATE:
return 0;
case WM_COMMAND:
// User has clicked an item on the tray menu
switch (LOWORD(wParam))
{
case ID_DEFAULT_PROPERTIES:
/* // Show the default properties dialog, unless it is already displayed
vnclog.Print(LL_INTINFO, VNCLOG("show default properties requested\n"));
_this->m_properties.ShowAdmin(TRUE, FALSE);
_this->FlashTrayIcon(_this->m_server->AuthClientCount() != 0);*/
break;
case ID_PROPERTIES:
// Show the properties dialog, unless it is already displayed
vnclog.Print(LL_INTINFO, VNCLOG("show user properties requested\n"));
_this->m_propertiesPoll.Show(TRUE, TRUE);
_this->FlashTrayIcon(_this->m_server->AuthClientCount() != 0);
break;
case ID_ABOUT:
// Show the About box
_this->m_about.Show(TRUE);
break;
case ID_CLOSE:
// User selected Close from the tray menu
_this->m_server->KillAuthClients();
PostMessage(hwnd, WM_CLOSE, 0, 0);
break;
}
return 0;
case WM_TRAYNOTIFY:
// User has clicked on the tray icon or the menu
{
// Get the submenu to use as a pop-up menu
HMENU submenu = GetSubMenu(_this->m_hmenu, 0);
// What event are we responding to, RMB click?
if (lParam==WM_RBUTTONUP)
{
if (submenu == NULL)
{
vnclog.Print(LL_INTERR, VNCLOG("no submenu available\n"));
return 0;
}
// Make the first menu item the default (bold font)
SetMenuDefaultItem(submenu, 0, TRUE);
// Get the current cursor position, to display the menu at
POINT mouse;
GetCursorPos(&mouse);
// There's a "bug"
// (Microsoft calls it a feature) in Windows 95 that requires calling
// SetForegroundWindow. To find out more, search for Q135788 in MSDN.
//
SetForegroundWindow(_this->m_nid.hWnd);
// Display the menu at the desired position
TrackPopupMenu(submenu,
0, mouse.x, mouse.y, 0,
_this->m_nid.hWnd, NULL);
return 0;
}
// Or was there a LMB double click?
if (lParam==WM_LBUTTONDBLCLK)
{
// double click: execute first menu item
SendMessage(_this->m_nid.hWnd,
WM_COMMAND,
GetMenuItemID(submenu, 0),
0);
}
return 0;
}
case WM_CLOSE:
// Only accept WM_CLOSE if the logged on user has AllowShutdown set
if (!_this->m_properties.AllowShutdown())
{
return 0;
}
// tnatsni Wallpaper fix
RestoreWallpaper();
break;
case WM_DESTROY:
// The user wants WinVNC to quit cleanly...
vnclog.Print(LL_INTINFO, VNCLOG("quitting from WM_DESTROY\n"));
PostQuitMessage(0);
return 0;
case WM_QUERYENDSESSION:
vnclog.Print(LL_INTERR, VNCLOG("WM_QUERYENDSESSION\n"));
break;
case WM_ENDSESSION:
vnclog.Print(LL_INTERR, VNCLOG("WM_ENDSESSION\n"));
break;
case WM_USERCHANGED:
// The current user may have changed.
{
char newuser[UNLEN+1];
if (vncService::CurrentUser((char *) &newuser, sizeof(newuser)))
{
vnclog.Print(LL_INTINFO,
// VNCLOG("usernames : old=\"%s\", new=\"%s\"\n"),
_this->m_username, newuser);
// Check whether the user name has changed!
if (strcmp(newuser, _this->m_username) != 0)
{
vnclog.Print(LL_INTINFO,
VNCLOG("user name has changed\n"));
// User has changed!
strcpy(_this->m_username, newuser);
// Redraw the tray icon and set it's state
_this->DelTrayIcon();
_this->AddTrayIcon();
_this->FlashTrayIcon(_this->m_server->AuthClientCount() != 0);
}
}
}
return 0;
default:
if (iMsg == MENU_DEFAULT_PROPERTIES_SHOW)
{
// External request to show our Properties dialog
PostMessage(hwnd, WM_COMMAND, MAKELONG(ID_DEFAULT_PROPERTIES, 0), 0);
return 0;
}
if (iMsg == MENU_ABOUTBOX_SHOW)
{
// External request to show our About dialog
PostMessage(hwnd, WM_COMMAND, MAKELONG(ID_ABOUT, 0), 0);
return 0;
}
if (iMsg == MENU_SERVICEHELPER_MSG)
{
// External ServiceHelper message.
// This message holds a process id which we can use to
// impersonate a specific user. In doing so, we can load their
// preferences correctly
// vncService::ProcessUserHelperMessage(wParam, lParam);
// Modif Jeremy C.
vncService::ProcessUserHelperMessage((WPARAM)&_this->m_server->m_impersonationtoken, lParam);
// - Trigger a check of the current user
PostMessage(hwnd, WM_USERCHANGED, 0, 0);
return 0;
}
if (iMsg == RETRY_MESSAGE)
{
connect_counter++;
if (connect_counter%5==0)
{
// Attempt to create a new socket
// Beep(1000,100);
VSocket *tmpsock;
tmpsock = new VSocket;
if (tmpsock) {
// Connect out to the specified host on the VNCviewer listen port
tmpsock->Create();
if (tmpsock->Connect(szAdrName, nport)) {
// Add the new client to this server
if (strcmp(g_idcode,"")==NULL) g_id=false;
else g_id=true;
char sendID[_MAX_PATH];
strcpy(sendID,"ID:");
strcat(sendID,g_idcode);
if (g_id)
tmpsock->Send(sendID,250);
_this->m_server->AddClient(tmpsock, TRUE, TRUE);
nport=0;
connected=1;
_this->FlashTrayIcon(_this->m_server->AuthClientCount() != 0);
return 0;
} else {
delete tmpsock;
connect_counter++;
if (connect_counter>25)
// Sleep(5000);
PostMessage(hwnd, WM_CLOSE, 0, 0);
}
}
}
return 0;
}
if (iMsg == MENU_ADD_CLIENT_MSG)
{
// sf@2003 - Autoreconnect
// Dirty trick to avoid to add a new MSG... no time
if (lParam == 999)
{
_this->m_server->AutoReconnect(true);
return 0;
}
/*
// sf@2005 - FTNoUserImpersonation
// Dirty trick to avoid to add a new MSG... no time
if (lParam == 998)
{
_this->m_server->FTUserImpersonation(false);
return 0;
}
*/
// Add Client message. This message includes an IP address
// of a listening client, to which we should connect.
char *nameDup = 0;
// sf@2003 - Values are already converted
if (_this->m_server->AutoReconnect() && strlen(_this->m_server->AutoReconnectAdr()) > 0)
{
nport = _this->m_server->AutoReconnectPort();
strcpy(szAdrName, _this->m_server->AutoReconnectAdr());
}
else
{
// Get the IP address stringified
struct in_addr address;
address.S_un.S_addr = lParam;
char *name = inet_ntoa(address);
if (name == 0)
return 0;
nameDup = strdup(name);
if (nameDup == 0)
return 0;
strcpy(szAdrName, nameDup);
// Free the duplicate name
if (nameDup != 0) free(nameDup);
// Get the port number
nport = (unsigned short)wParam;
if (nport == 0)
nport = INCOMING_PORT_OFFSET;
}
// sf@2003
// Stores the client adr/ports the first time we try to connect
// This way we can call this message again later to reconnect with the same values
if (_this->m_server->AutoReconnect() && strlen(_this->m_server->AutoReconnectAdr()) == 0)
{
_this->m_server->AutoReconnectAdr(szAdrName);
_this->m_server->AutoReconnectPort(nport);
}
// Attempt to create a new socket
_this->FlashTrayIcon(_this->m_server->AuthClientCount() != 0);
VSocket *tmpsock;
tmpsock = new VSocket;
if (tmpsock) {
// Connect out to the specified host on the VNCviewer listen port
tmpsock->Create();
if (tmpsock->Connect(szAdrName, nport)) {
// Add the new client to this server
if (strcmp(g_idcode,"")==NULL) g_id=false;
else g_id=true;
char sendID[_MAX_PATH];
strcpy(sendID,"ID:");
strcat(sendID,g_idcode);
if (g_id)
tmpsock->Send(sendID,250);
_this->m_server->AddClient(tmpsock, TRUE, TRUE);
nport=0;
connected=1;
_this->FlashTrayIcon(_this->m_server->AuthClientCount() != 0);
return 0;
} else {
delete tmpsock;
// Sleep(5000);
// PostMessage(hwnd, WM_CLOSE, 0, 0);
}
}
return 0;
}
// Process FileTransfer asynchronous Send Packet Message
if (iMsg == FileTransferSendPacketMessage)
{
vncClient* pClient = (vncClient*) wParam;
if (_this->m_server->IsClient(pClient)) pClient->SendFileChunk();
}
}
// Message not recognised
return DefWindowProc(hwnd, iMsg, wParam, lParam);
}
BOOL
vncDesktop::InitWindow()
{
vnclog.Print(LL_INTERR, VNCLOG("InitWindow called\n"));
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("InitWindow:OpenInputdesktop Error \n"));
else
vnclog.Print(LL_INTERR, VNCLOG("InitWindow:OpenInputdesktop OK\n"));
HDESK old_desktop = GetThreadDesktop(GetCurrentThreadId());
DWORD dummy;
char new_name[256];
if (!GetUserObjectInformation(desktop, UOI_NAME, &new_name, 256, &dummy))
{
vnclog.Print(LL_INTERR, VNCLOG("InitWindow:!GetUserObjectInformation \n"));
}
vnclog.Print(LL_INTERR, VNCLOG("InitWindow:SelectHDESK to %s (%x) from %x\n"), new_name, desktop, old_desktop);
if (!SetThreadDesktop(desktop))
{
vnclog.Print(LL_INTERR, VNCLOG("InitWindow:SelectHDESK:!SetThreadDesktop \n"));
}
HMODULE hUser32 = LoadLibrary("user32.dll");
CHANGEWINDOWMESSAGEFILTER pfnFilter = NULL;
pfnFilter =(CHANGEWINDOWMESSAGEFILTER)GetProcAddress(hUser32,"ChangeWindowMessageFilter");
if (pfnFilter) pfnFilter(RFB_SCREEN_UPDATE, MSGFLT_ADD);
if (pfnFilter) pfnFilter(RFB_COPYRECT_UPDATE, MSGFLT_ADD);
if (pfnFilter) pfnFilter(RFB_MOUSE_UPDATE, MSGFLT_ADD);
if (pfnFilter) pfnFilter(WM_QUIT, MSGFLT_ADD);
if (pfnFilter) pfnFilter(WM_SHUTDOWN, MSGFLT_ADD);
if (m_wndClass == 0) {
// Create the window class
WNDCLASSEX wndclass;
wndclass.cbSize = sizeof(wndclass);
wndclass.style = 0;
wndclass.lpfnWndProc = &DesktopWndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = hAppInstance;
wndclass.hIcon = NULL;
wndclass.hCursor = NULL;
wndclass.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wndclass.lpszMenuName = (const char *) NULL;
wndclass.lpszClassName = szDesktopSink;
wndclass.hIconSm = NULL;
// Register it
m_wndClass = RegisterClassEx(&wndclass);
if (!m_wndClass) {
vnclog.Print(LL_INTERR, VNCLOG("failed to register window class\n"));
SetEvent(restart_event);
return FALSE;
}
}
// And create a window
m_hwnd = CreateWindow(szDesktopSink,
"WinVNC",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
400, 200,
NULL,
NULL,
hAppInstance,
NULL);
if (m_hwnd == NULL) {
vnclog.Print(LL_INTERR, VNCLOG("failed to create hook window\n"));
SetEvent(restart_event);
return FALSE;
}
SetTimer(m_hwnd,1001,1000,NULL);
// Set the "this" pointer for the window
helper::SafeSetWindowUserData(m_hwnd, (LONG_PTR)this);
// Enable clipboard hooking
// adzm - 2010-07 - Fix clipboard hangs
m_settingClipboardViewer = true;
m_hnextviewer = SetClipboardViewer(m_hwnd);
m_settingClipboardViewer = false;
StopDriverWatches=false;
DrvWatch mywatch;
mywatch.stop=&StopDriverWatches;
mywatch.hwnd=m_hwnd;
if (VideoBuffer())
{
DWORD myword;
HANDLE T1=NULL;
T1=CreateThread(NULL,0,Driverwatch,m_hwnd,0,&myword);
if (T1) CloseHandle(T1);
}
vnclog.Print(LL_INTERR, VNCLOG("OOOOOOOOOOOO load hookdll's\n"));
////////////////////////
hModule=NULL;
char szCurrentDir[MAX_PATH];
if (GetModuleFileName(NULL, szCurrentDir, MAX_PATH))
{
char* p = strrchr(szCurrentDir, '\\');
if (p == NULL) return 0;
*p = '\0';
strcat (szCurrentDir,"\\vnchooks.dll");
}
hSCModule=NULL;
char szCurrentDirSC[MAX_PATH];
if (GetModuleFileName(NULL, szCurrentDirSC, MAX_PATH))
{
char* p = strrchr(szCurrentDirSC, '\\');
if (p == NULL) return 0;
*p = '\0';
#ifdef _X64
strcat (szCurrentDirSC,"\\schook64.dll");
#else
strcat (szCurrentDirSC,"\\schook.dll");
#endif
}
hW8Module=NULL;
char szCurrentDirW8[MAX_PATH];
if (WIN8)
{
if (GetModuleFileName(NULL, szCurrentDirW8, MAX_PATH))
{
char* p = strrchr(szCurrentDirW8, '\\');
if (p == NULL) return 0;
*p = '\0';
#ifdef _X64
strcat (szCurrentDirW8,"\\w8hook64.dll");
#else
strcat (szCurrentDirW8,"\\w8hook.dll");
#endif
}
}
UnSetHooks=NULL;
SetMouseFilterHook=NULL;
SetKeyboardFilterHook=NULL;
SetMouseFilterHooks=NULL;
SetKeyboardFilterHooks=NULL;
SetHooks=NULL;
UnSetHook=NULL;
SetHook=NULL;
hModule = LoadLibrary(szCurrentDir);
hSCModule = LoadLibrary(szCurrentDirSC);//TOFIX resource leak
if (WIN8) hW8Module = LoadLibrary(szCurrentDirW8);
if (hModule)
{
strcpy_s(g_hookstring,"vnchook");
UnSetHooks = (UnSetHooksFn) GetProcAddress( hModule, "UnSetHooks" );
SetMouseFilterHook = (SetMouseFilterHookFn) GetProcAddress( hModule, "SetMouseFilterHook" );
SetKeyboardFilterHook = (SetKeyboardFilterHookFn) GetProcAddress( hModule, "SetKeyboardFilterHook" );
SetHooks = (SetHooksFn) GetProcAddress( hModule, "SetHooks" );
}
if (hSCModule)
{
UnSetHook = (UnSetHookFn) GetProcAddress( hSCModule, "UnSetHook" );
SetHook = (SetHookFn) GetProcAddress( hSCModule, "SetHook" );
SetMouseFilterHooks = (SetMouseFilterHookFn) GetProcAddress( hSCModule, "SetMouseFilterHook" );
SetKeyboardFilterHooks = (SetKeyboardFilterHookFn) GetProcAddress( hSCModule, "SetKeyboardFilterHook" );
}
startw8=NULL;
stopw8=NULL;
capturew8=NULL;
if (hW8Module)
{
startw8=(StartW8)GetProcAddress(hW8Module,"StartW8");
stopw8=(StopW8)GetProcAddress(hW8Module,"StopW8");
capturew8=(CaptureW8)GetProcAddress(hW8Module,"CaptureW8");
}
///////////////////////////////////////////////
vnclog.Print(LL_INTERR, VNCLOG("OOOOOOOOOOOO start dispatch\n"));
MSG msg;
SetEvent(restart_event);
while (TRUE)
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
vnclog.Print(LL_INTERR, VNCLOG("OOOOOOOOOOOO %i %i\n"),msg.message,msg.hwnd);
if (msg.message==WM_TIMER)
{
if(msg.wParam==1001) keepalive();
}
if (msg.message==WM_QUIT || fShutdownOrdered)
{
vnclog.Print(LL_INTERR, VNCLOG("OOOOOOOOOOOO called wm_quit\n"));
DestroyWindow(m_hwnd);
SetEvent(trigger_events[5]);
break;
}
else if (msg.message==WM_SHUTDOWN)
{
vnclog.Print(LL_INTERR, VNCLOG("OOOOOOOOOOOO called wm_user+4\n"));
DestroyWindow(m_hwnd);
break;
}
else if (msg.message==RFB_SCREEN_UPDATE)
{
if (can_be_hooked)
{
vnclog.Print(LL_INTERR, VNCLOG("RFB_SCREEN_UPDATE \n"));
rfb::Rect rect;
rect.tl = rfb::Point((SHORT)LOWORD(msg.wParam), (SHORT)HIWORD(msg.wParam));
rect.br = rfb::Point((SHORT)LOWORD(msg.lParam), (SHORT)HIWORD(msg.lParam));
//Buffer coordinates
rect.tl.x-=m_ScreenOffsetx;
rect.br.x-=m_ScreenOffsetx;
rect.tl.y-=m_ScreenOffsety;
rect.br.y-=m_ScreenOffsety;
vnclog.Print(LL_INTERR, VNCLOG("REct3 %i %i %i %i \n"),rect.tl.x,rect.br.x,rect.tl.y,rect.br.y);
rect = rect.intersect(m_Cliprect);
if (!rect.is_empty())
{
while (lock_region_add) Sleep(5);
rgnpump.assign_union(rect);
SetEvent(trigger_events[1]);
}
}
}
else if (msg.message==RFB_MOUSE_UPDATE)
{
if (can_be_hooked)
{
vnclog.Print(LL_INTERR, VNCLOG("RFB_MOUSE_UPDATE \n"));
SetCursor((HCURSOR) msg.wParam);
SetEvent(trigger_events[2]);
}
}
else
{
if (msg.message==WM_USER+3 )vnclog.Print(LL_INTERR, VNCLOG("OOOOOOOOOOOO called wm_user+3\n"));
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else WaitMessage();
}
KillTimer(m_hwnd,1001);
if (hModule)FreeLibrary(hModule);
if (hSCModule)FreeLibrary(hSCModule);
if (hW8Module)FreeLibrary(hW8Module);
SetThreadDesktop(old_desktop);
CloseDesktop(desktop);
///////////////////////
vnclog.Print(LL_INTERR, VNCLOG("OOOOOOOOOOOO end dispatch\n"));
m_hwnd = NULL;
return TRUE;
}
////////////////////////////////////////////////////////////////////////////////
// Window procedure for the Desktop window
LRESULT CALLBACK
DesktopWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
#ifndef _X64
vncDesktop *_this = (vncDesktop*)GetWindowLong(hwnd, GWL_USERDATA);
#else
vncDesktop *_this = (vncDesktop*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
#endif
/*#ifdef _DEBUG
char szText[256];
sprintf(szText,"Message %i\n",iMsg );
OutputDebugString(szText);
//vnclog.Print(LL_INTERR, VNCLOG("%i \n"),iMsg);
#endif*/
switch (iMsg)
{
case WM_CREATE:
vnclog.Print(LL_INTERR, VNCLOG("wmcreate \n"));
break;
case WM_TIMER:
if (_this->can_be_hooked)
{
if (wParam==100)
{
KillTimer(hwnd, 100);
if (_this->startw8)
{
_this->startw8(!_this->multi_monitor);
vnclog.Print(LL_INTERR, VNCLOG("set W8 hooks OK\n"));
_this->m_hookinited = TRUE;
}
else if (_this->SetHook)
{
_this->SetHook(hwnd);
vnclog.Print(LL_INTERR, VNCLOG("set SC hooks OK\n"));
_this->m_hookinited = TRUE;
if (_this->SetKeyboardFilterHooks) _this->SetKeyboardFilterHooks( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
if (_this->SetMouseFilterHooks) _this->SetMouseFilterHooks( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
}
else if (_this->SetHooks)
{
if (!_this->SetHooks(
GetCurrentThreadId(),
RFB_SCREEN_UPDATE,
RFB_COPYRECT_UPDATE,
RFB_MOUSE_UPDATE, 0
))
{
vnclog.Print(LL_INTERR, VNCLOG("failed to set system hooks\n"));
// Switch on full screen polling, so they can see something, at least...
_this->m_server->PollFullScreen(TRUE);
_this->m_hookinited = FALSE;
}
else
{
vnclog.Print(LL_INTERR, VNCLOG("set hooks OK\n"));
_this->m_hookinited = TRUE;
// Start up the keyboard and mouse filters
if (_this->SetKeyboardFilterHook) _this->SetKeyboardFilterHook(_this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
if (_this->SetMouseFilterHook) _this->SetMouseFilterHook(_this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
}
}
}
else SetEvent(_this->trigger_events[0]);
}
break;
case WM_MOUSESHAPE:
if (_this->can_be_hooked)
{
SetEvent(_this->trigger_events[3]);
}
break;
case WM_HOOKCHANGE:
if (wParam==1)
{
if (_this->m_hookinited==FALSE)
SetTimer(hwnd,100,1000,NULL);
}
else if (wParam==2)
{
if (_this->m_hookinited)
{
if (_this->SetHook)
{
if (_this->SetKeyboardFilterHooks) _this->SetKeyboardFilterHooks( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
if (_this->SetMouseFilterHooks) _this->SetMouseFilterHooks( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
}
else if (_this->SetHooks)
{
if (_this->SetKeyboardFilterHook) _this->SetKeyboardFilterHook( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
if (_this->SetMouseFilterHook) _this->SetMouseFilterHook( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
}
}
}
else if (_this->m_hookinited)
{
_this->m_hookinited=FALSE;
if (_this->stopw8)
{
vnclog.Print(LL_INTERR, VNCLOG("unset W8 hooks OK\n"));
_this->stopw8();
}
if (_this->UnSetHook)
{
vnclog.Print(LL_INTERR, VNCLOG("unset SC hooks OK\n"));
_this->UnSetHook(hwnd);
}
else if (_this->UnSetHooks)
{
if(!_this->UnSetHooks(GetCurrentThreadId()) )
vnclog.Print(LL_INTERR, VNCLOG("Unsethooks Failed\n"));
else vnclog.Print(LL_INTERR, VNCLOG("Unsethooks OK\n"));
}
}
return true;
case WM_QUERYENDSESSION:
/*if (OSversion()==2)
{
if (_this->m_hnextviewer!=NULL) ChangeClipboardChain(hwnd, _this->m_hnextviewer);
_this->m_hnextviewer=NULL;
if (_this->m_hookinited)
{
_this->m_hookinited=FALSE;
if (_this->UnSetHook)
{
vnclog.Print(LL_INTERR, VNCLOG("unset SC hooks OK\n"));
_this->UnSetHook(hwnd);
}
else if (_this->UnSetHooks)
{
if(!_this->UnSetHooks(GetCurrentThreadId()) )
vnclog.Print(LL_INTERR, VNCLOG("Unsethooks Failed\n"));
else vnclog.Print(LL_INTERR, VNCLOG("Unsethooks OK\n"));
}
}
vnclog.Print(LL_INTERR, VNCLOG("WM_QUERYENDSESSION\n"));
PostQuitMessage(0);
SetEvent(_this->trigger_events[5]);
}*/
return DefWindowProc(hwnd, iMsg, wParam, lParam);
case WM_CLOSE:
if (_this->m_hnextviewer!=NULL) ChangeClipboardChain(hwnd, _this->m_hnextviewer);
_this->m_hnextviewer=NULL;
DestroyWindow(hwnd);
break;
case WM_DESTROY:
KillTimer(hwnd, 100);
if (_this->m_hnextviewer!=NULL) ChangeClipboardChain(hwnd, _this->m_hnextviewer);
_this->m_hnextviewer=NULL;
if (_this->m_hookinited)
{
if (_this->stopw8)
{
vnclog.Print(LL_INTERR, VNCLOG("unset W8 hooks OK\n"));
_this->stopw8();
}
if (_this->UnSetHook)
{
vnclog.Print(LL_INTERR, VNCLOG("unset SC hooks OK\n"));
_this->UnSetHook(hwnd);
}
else if (_this->UnSetHooks)
{
if(!_this->UnSetHooks(GetCurrentThreadId()) )
vnclog.Print(LL_INTERR, VNCLOG("Unsethooks Failed\n"));
else vnclog.Print(LL_INTERR, VNCLOG("Unsethooks OK\n"));
}
_this->m_hookinited=FALSE;
}
vnclog.Print(LL_INTERR, VNCLOG("WM_DESTROY\n"));
break;
///ddihook
case WM_SYSCOMMAND:
// User has clicked an item on the tray menu
switch (wParam)
{
case SC_MONITORPOWER:
vnclog.Print(LL_INTINFO, VNCLOG("Monitor22 %i\n"),lParam);
}
vnclog.Print(LL_INTINFO, VNCLOG("Monitor3 %i %i\n"),wParam,lParam);
return DefWindowProc(hwnd, iMsg, wParam, lParam);
case WM_POWER:
case WM_POWERBROADCAST:
// User has clicked an item on the tray menu
switch (wParam)
{
case SC_MONITORPOWER:
vnclog.Print(LL_INTINFO, VNCLOG("Monitor222 %i\n"),lParam);
}
vnclog.Print(LL_INTINFO, VNCLOG("Power3 %i %i\n"),wParam,lParam);
return DefWindowProc(hwnd, iMsg, wParam, lParam);
case WM_COPYDATA:
{
PCOPYDATASTRUCT pMyCDS = (PCOPYDATASTRUCT) lParam;
if (pMyCDS->dwData==112233)
{
DWORD mysize=pMyCDS->cbData;
char mytext[1024];
char *myptr;
char split[4][6];
strcpy(mytext,(LPCSTR)pMyCDS->lpData);
myptr=mytext;
for (DWORD j =0; j<(mysize/20);j++)
{
for (int i=0;i<4;i++)
{
strcpy(split[i]," ");
strncpy(split[i],myptr,4);
myptr=myptr+5;
}
_this->QueueRect(rfb::Rect(atoi(split[0]), atoi(split[1]), atoi(split[2]), atoi(split[3])));
}
}
//vnclog.Print(LL_INTINFO, VNCLOG("copydata\n"));
}
return 0;
// GENERAL
case WM_DISPLAYCHANGE:
// The display resolution is changing
// We must kick off any clients since their screen size will be wrong
// WE change the clients screensize, if they support it.
vnclog.Print(LL_INTERR, VNCLOG("WM_DISPLAYCHANGE\n"));
// We First check if the Resolution changed is caused by a temp resolution switch
// For a temp resolution we don't use the driver, to fix the mirror driver
// to the new change, a resolution switch is needed, preventing screensaver locking.
if (_this->m_videodriver != NULL) //Video driver active
{
if (!_this->m_videodriver->blocked)
{
_this->m_displaychanged = TRUE;
_this->m_hookdriver=true;
_this->m_videodriver->blocked=true;
vnclog.Print(LL_INTERR, VNCLOG("Resolution switch detected, driver active\n"));
}
else
{
//Remove display change, cause by driver activation
_this->m_videodriver->blocked=false;
vnclog.Print(LL_INTERR, VNCLOG("Resolution switch by driver activation removed\n"));
}
}
else
{
_this->m_displaychanged = TRUE;
_this->m_hookdriver=true;
vnclog.Print(LL_INTERR, VNCLOG("Resolution switch detected, driver NOT active\n"));
}
return 0;
case WM_SYSCOLORCHANGE:
case WM_PALETTECHANGED:
if (!_this->m_displaychanged)
{
// The palette colours have changed, so tell the server
// Get the system palette
// better to use the wrong colors than close the connection
_this->SetPalette();
// Update any palette-based clients, too
//set to flase to avoid deadlock
_this->m_server->UpdatePalette(false);
}
return 0;
// CLIPBOARD MESSAGES
case WM_CHANGECBCHAIN:
// The clipboard chain has changed - check our nextviewer handle
if ((HWND)wParam == _this->m_hnextviewer)
_this->m_hnextviewer = (HWND)lParam;
else
if (_this->m_hnextviewer != NULL) {
// adzm - 2010-07 - Fix clipboard hangs
// use SendNotifyMessage instead of SendMessage so misbehaving or hung applications
// won't cause our thread to hang.
SendNotifyMessage(_this->m_hnextviewer,
WM_CHANGECBCHAIN,
wParam, lParam);
}
return 0;
case WM_DRAWCLIPBOARD:
// adzm - 2010-07 - Fix clipboard hangs
if (_this->can_be_hooked && !_this->m_settingClipboardViewer)
{
// The clipboard contents have changed
if((GetClipboardOwner() != _this->Window()) &&
//_this->m_initialClipBoardSeen &&
_this->m_clipboard_active && !_this->m_server->IsThereFileTransBusy())
{
// adzm - 2010-07 - Extended clipboard
{
// only need a window when setting clipboard data
omni_mutex_lock l(_this->m_update_lock);
_this->m_server->UpdateClipTextEx(NULL);
}
/*
LPSTR cliptext = NULL;
// Open the clipboard
if (OpenClipboard(_this->Window()))
{
// Get the clipboard data
HGLOBAL cliphandle = GetClipboardData(CF_TEXT);
if (cliphandle != NULL)
{
LPSTR clipdata = (LPSTR) GlobalLock(cliphandle);
// Copy it into a new buffer
if (clipdata == NULL)
cliptext = NULL;
else
cliptext = _strdup(clipdata);
// Release the buffer and close the clipboard
GlobalUnlock(cliphandle);
}
CloseClipboard();
}
if (cliptext != NULL)
{
int cliplen = strlen(cliptext);
LPSTR unixtext = (char *)malloc(cliplen+1);
// Replace CR-LF with LF - never send CR-LF on the wire,
// since Unix won't like it
int unixpos=0;
for (int x=0; x<cliplen; x++)
{
if (cliptext[x] != '\x0d')
{
unixtext[unixpos] = cliptext[x];
unixpos++;
}
}
unixtext[unixpos] = 0;
// Free the clip text
free(cliptext);
cliptext = NULL;
// Now send the unix text to the server
omni_mutex_lock l(_this->m_update_lock);
_this->m_server->UpdateClipText(unixtext);
free(unixtext);
}
*/
}
//_this->m_initialClipBoardSeen = TRUE;
}
if (_this->m_hnextviewer != NULL)
{
// adzm - 2010-07 - Fix clipboard hangs
// Pass the message to the next window in clipboard viewer chain.
// use SendNotifyMessage instead of SendMessage so misbehaving or hung applications
// won't cause our thread to hang.
return SendNotifyMessage(_this->m_hnextviewer, WM_DRAWCLIPBOARD, wParam, lParam);
}
return 0;
default:
return DefWindowProc(hwnd, iMsg, wParam, lParam);
}
return 0;
}
// WinMain parses the command line and either calls the main App
// routine or, under NT, the main service routine.
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
if (VNCOS.OS_NOTSUPPORTED==true)
{
MessageBoxSecure(NULL, "Error OS not supported","Unsupported OS", MB_ICONERROR);
return true;
}
// make vnc last service to stop
SetProcessShutdownParameters(0x100,false);
// handle dpi on aero
/*HMODULE hUser32 = LoadLibrary(_T("user32.dll"));
typedef BOOL (*SetProcessDPIAwareFunc)();
SetProcessDPIAwareFunc setDPIAware=NULL;
if (hUser32) setDPIAware = (SetProcessDPIAwareFunc)GetProcAddress(hUser32, "SetProcessDPIAware");
if (setDPIAware) setDPIAware();
if (hUser32) FreeLibrary(hUser32);*/
#ifdef IPP
InitIpp();
#endif
#ifdef CRASHRPT
CR_INSTALL_INFO info;
memset(&info, 0, sizeof(CR_INSTALL_INFO));
info.cb = sizeof(CR_INSTALL_INFO);
info.pszAppName = _T("UVNC");
info.pszAppVersion = _T("1.2.0.9");
info.pszEmailSubject = _T("UVNC server 1.2.0.9 Error Report");
info.pszEmailTo = _T("*****@*****.**");
info.uPriorities[CR_SMAPI] = 1; // Third try send report over Simple MAPI
// Install all available exception handlers
info.dwFlags |= CR_INST_ALL_POSSIBLE_HANDLERS;
// Restart the app on crash
info.dwFlags |= CR_INST_APP_RESTART;
info.dwFlags |= CR_INST_SEND_QUEUED_REPORTS;
info.dwFlags |= CR_INST_AUTO_THREAD_HANDLERS;
info.pszRestartCmdLine = _T("/restart");
// Define the Privacy Policy URL
// Install crash reporting
int nResult = crInstall(&info);
if (nResult != 0)
{
// Something goes wrong. Get error message.
TCHAR szErrorMsg[512] = _T("");
crGetLastErrorMsg(szErrorMsg, 512);
_tprintf_s(_T("%s\n"), szErrorMsg);
return 1;
}
#endif
bool Injected_autoreconnect=false;
SPECIAL_SC_EXIT=false;
SPECIAL_SC_PROMPT=false;
setbuf(stderr, 0);
// [v1.0.2-jp1 fix] Load resouce from dll
hInstResDLL = NULL;
//limit the vnclang.dll searchpath to avoid
char szCurrentDir[MAX_PATH];
char szCurrentDir_vnclangdll[MAX_PATH];
if (GetModuleFileName(NULL, szCurrentDir, MAX_PATH))
{
char* p = strrchr(szCurrentDir, '\\');
*p = '\0';
}
strcpy (szCurrentDir_vnclangdll,szCurrentDir);
strcat (szCurrentDir_vnclangdll,"\\");
strcat (szCurrentDir_vnclangdll,"vnclang_server.dll");
hInstResDLL = LoadLibrary(szCurrentDir_vnclangdll);
if (hInstResDLL == NULL)
{
hInstResDLL = hInstance;
}
// RegisterLinkLabel(hInstResDLL);
//Load all messages from ressource file
Load_Localization(hInstResDLL) ;
char WORKDIR[MAX_PATH];
if (GetModuleFileName(NULL, WORKDIR, MAX_PATH))
{
char* p = strrchr(WORKDIR, '\\');
if (p == NULL) return 0;
*p = '\0';
}
char progname[MAX_PATH];
strncpy(progname, WORKDIR, sizeof progname);
progname[MAX_PATH - 1] = 0;
//strcat(WORKDIR,"\\");
//strcat(WORKDIR,"WinVNC.log");
vnclog.SetFile();
//vnclog.SetMode(4);
//vnclog.SetLevel(10);
#ifdef _DEBUG
{
// Get current flag
int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );
// Turn on leak-checking bit
tmpFlag |= _CRTDBG_LEAK_CHECK_DF;
// Set flag to the new value
_CrtSetDbgFlag( tmpFlag );
}
#endif
// Save the application instance and main thread id
hAppInstance = hInstance;
mainthreadId = GetCurrentThreadId();
// Initialise the VSocket system
VSocketSystem socksys;
if (!socksys.Initialised())
{
MessageBoxSecure(NULL, sz_ID_FAILED_INIT, szAppName, MB_OK);
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
// look up the current service name in the registry.
GetServiceName(progname, service_name);
// Make the command-line lowercase and parse it
size_t i;
for (i = 0; i < strlen(szCmdLine); i++)
{
szCmdLine[i] = tolower(szCmdLine[i]);
}
BOOL argfound = FALSE;
for (i = 0; i < strlen(szCmdLine); i++)
{
if (szCmdLine[i] <= ' ')
continue;
argfound = TRUE;
if (strncmp(&szCmdLine[i], winvncSettingshelper, strlen(winvncSettingshelper)) == 0)
{
Sleep(3000);
char mycommand[MAX_PATH];
i+=strlen(winvncSettingshelper);
strcpy( mycommand, &(szCmdLine[i+1]));
Set_settings_as_admin(mycommand);
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncStopserviceHelper, strlen(winvncStopserviceHelper)) == 0)
{
Sleep(3000);
Set_stop_service_as_admin();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncKill, strlen(winvncKill)) == 0)
{
static HANDLE hShutdownEventTmp;
hShutdownEventTmp = OpenEvent(EVENT_ALL_ACCESS, FALSE, "Global\\SessionEventUltra");
SetEvent(hShutdownEventTmp);
CloseHandle(hShutdownEventTmp);
//adzm 2010-02-10 - Finds the appropriate VNC window for any process. Sends this message to all of them!
// do removed, loops forever with cpu 100
HWND hservwnd = NULL;
hservwnd = FindWinVNCWindow(false);
if (hservwnd!=NULL)
{
PostMessage(hservwnd, WM_COMMAND, 40002, 0);
PostMessage(hservwnd, WM_CLOSE, 0, 0);
}
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncopenhomepage, strlen(winvncopenhomepage)) == 0)
{
Open_homepage();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncopenforum, strlen(winvncopenforum)) == 0)
{
Open_forum();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncStartserviceHelper, strlen(winvncStartserviceHelper)) == 0)
{
Sleep(3000);
Set_start_service_as_admin();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncInstallServiceHelper, strlen(winvncInstallServiceHelper)) == 0)
{
//Sleeps are realy needed, else runas fails...
Sleep(3000);
Set_install_service_as_admin();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncUnInstallServiceHelper, strlen(winvncUnInstallServiceHelper)) == 0)
{
Sleep(3000);
Set_uninstall_service_as_admin();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncSoftwarecadHelper, strlen(winvncSoftwarecadHelper)) == 0)
{
Sleep(3000);
Enable_softwareCAD_elevated();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncdelSoftwarecadHelper, strlen(winvncdelSoftwarecadHelper)) == 0)
{
Sleep(3000);
delete_softwareCAD_elevated();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncRebootSafeHelper, strlen(winvncRebootSafeHelper)) == 0)
{
Sleep(3000);
Reboot_in_safemode_elevated();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncRebootForceHelper, strlen(winvncRebootForceHelper)) == 0)
{
Sleep(3000);
Reboot_with_force_reboot_elevated();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncSecurityEditorHelper, strlen(winvncSecurityEditorHelper)) == 0)
{
Sleep(3000);
winvncSecurityEditorHelper_as_admin();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncSecurityEditor, strlen(winvncSecurityEditor)) == 0)
{
typedef void (*vncEditSecurityFn) (HWND hwnd, HINSTANCE hInstance);
vncEditSecurityFn vncEditSecurity = 0;
char szCurrentDirl[MAX_PATH];
if (GetModuleFileName(NULL, szCurrentDirl, MAX_PATH)) {
char* p = strrchr(szCurrentDirl, '\\');
*p = '\0';
strcat (szCurrentDirl,"\\authSSP.dll");
}
HMODULE hModule = LoadLibrary(szCurrentDirl);
if (hModule) {
vncEditSecurity = (vncEditSecurityFn) GetProcAddress(hModule, "vncEditSecurity");
HRESULT hr = CoInitialize(NULL);
vncEditSecurity(NULL, hAppInstance);
CoUninitialize();
FreeLibrary(hModule);
}
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncSettings, strlen(winvncSettings)) == 0)
{
char mycommand[MAX_PATH];
i+=strlen(winvncSettings);
strcpy( mycommand, &(szCmdLine[i+1]));
Real_settings(mycommand);
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], dsmpluginhelper, strlen(dsmpluginhelper)) == 0)
{
char mycommand[MAX_PATH];
i += strlen(dsmpluginhelper);
strcpy(mycommand, &(szCmdLine[i + 1]));
Secure_Plugin_elevated(mycommand);
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], dsmplugininstance, strlen(dsmplugininstance)) == 0)
{
char mycommand[MAX_PATH];
i += strlen(dsmplugininstance);
strcpy(mycommand, &(szCmdLine[i + 1]));
Secure_Plugin(mycommand);
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncSoftwarecad, strlen(winvncSoftwarecad)) == 0)
{
Enable_softwareCAD();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncdelSoftwarecad, strlen(winvncdelSoftwarecad)) == 0)
{
delete_softwareCAD();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncRebootSafe, strlen(winvncRebootSafe)) == 0)
{
Reboot_in_safemode();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncRebootForce, strlen(winvncRebootForce)) == 0)
{
Reboot_with_force_reboot();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncStopservice, strlen(winvncStopservice)) == 0)
{
Real_stop_service();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncStartservice, strlen(winvncStartservice)) == 0)
{
Real_start_service();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncInstallService, strlen(winvncInstallService)) == 0)
{
// rest of command line service name, if provided.
char *pServiceName = &szCmdLine[i];
// skip over command switch, find next whitepace
while (*pServiceName && !isspace(*(unsigned char*)pServiceName))
++pServiceName;
// skip past whitespace to service name
while (*pServiceName && isspace(*(unsigned char*)pServiceName))
++pServiceName;
// strip off any quotes
if (*pServiceName && *pServiceName == '\"')
++pServiceName;
if (*pServiceName)
{
// look for trailing quote, if found, terminate the string there.
char *pQuote = pServiceName;
pQuote = strrchr(pServiceName, '\"');
if (pQuote)
*pQuote = 0;
}
// if a service name is supplied, and it differs except in case from
// the default, use the supplied service name instead
if (*pServiceName && (_strcmpi(pServiceName, service_name) != 0))
{
strncpy(service_name, pServiceName, 256);
service_name[255] = 0;
}
install_service();
Sleep(2000);
char command[MAX_PATH + 32]; // 29 January 2008 jdp
_snprintf(command, sizeof command, "net start \"%s\"", service_name);
WinExec(command,SW_HIDE);
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncUnInstallService, strlen(winvncUnInstallService)) == 0)
{
char command[MAX_PATH + 32]; // 29 January 2008 jdp
// rest of command line service name, if provided.
char *pServiceName = &szCmdLine[i];
// skip over command switch, find next whitepace
while (*pServiceName && !isspace(*(unsigned char*)pServiceName))
++pServiceName;
// skip past whitespace to service name
while (*pServiceName && isspace(*(unsigned char*)pServiceName))
++pServiceName;
// strip off any quotes
if (*pServiceName && *pServiceName == '\"')
++pServiceName;
if (*pServiceName)
{
// look for trailing quote, if found, terminate the string there.
char *pQuote = pServiceName;
pQuote = strrchr(pServiceName, '\"');
if (pQuote)
*pQuote = 0;
}
if (*pServiceName && (_strcmpi(pServiceName, service_name) != 0))
{
strncpy(service_name, pServiceName, 256);
service_name[255] = 0;
}
_snprintf(command, sizeof command, "net stop \"%s\"", service_name);
WinExec(command,SW_HIDE);
uninstall_service();
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncRunService, strlen(winvncRunService)) == 0)
{
//Run as service
if (!Myinit(hInstance)) return 0;
fRunningFromExternalService = true;
vncService::RunningFromExternalService(true);
int returnvalue = WinVNCAppMain();
#ifdef CRASHRPT
crUninstall();
#endif
return returnvalue;
}
if (strncmp(&szCmdLine[i], winvncStartService, strlen(winvncStartService)) == 0)
{
start_service(szCmdLine);
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
if (strncmp(&szCmdLine[i], winvncRunAsUserApp, strlen(winvncRunAsUserApp)) == 0)
{
// WinVNC is being run as a user-level program
if (!Myinit(hInstance)) return 0;
int returnvalue = WinVNCAppMain();
#ifdef CRASHRPT
crUninstall();
#endif
return returnvalue;
}
if (strncmp(&szCmdLine[i], winvncSCexit, strlen(winvncSCexit)) == 0)
{
SPECIAL_SC_EXIT=true;
i+=strlen(winvncSCexit);
continue;
}
if (strncmp(&szCmdLine[i], winvncSCprompt, strlen(winvncSCprompt)) == 0)
{
SPECIAL_SC_PROMPT=true;
i+=strlen(winvncSCprompt);
continue;
}
if (strncmp(&szCmdLine[i], winvncmulti, strlen(winvncmulti)) == 0)
{
multi=true;
i+=strlen(winvncmulti);
continue;
}
if (strncmp(&szCmdLine[i], winvnchttp, strlen(winvnchttp)) == 0)
{
G_HTTP=true;
i+=strlen(winvnchttp);
continue;
}
if (strncmp(&szCmdLine[i], winvncStopReconnect, strlen(winvncStopReconnect)) == 0)
{
i+=strlen(winvncStopReconnect);
vncService::PostAddStopConnectClientAll();
continue;
}
if (strncmp(&szCmdLine[i], winvncAutoReconnect, strlen(winvncAutoReconnect)) == 0)
{
// Note that this "autoreconnect" param MUST be BEFORE the "connect" one
// on the command line !
// wa@2005 -- added support for the AutoReconnectId
i+=strlen(winvncAutoReconnect);
Injected_autoreconnect=true;
int start, end;
char* pszId = NULL;
start = i;
// skip any spaces and grab the parameter
while (szCmdLine[start] <= ' ' && szCmdLine[start] != 0) start++;
if ( strncmp( &szCmdLine[start], winvncAutoReconnectId, strlen(winvncAutoReconnectId) ) == 0 )
{
end = start;
while (szCmdLine[end] > ' ') end++;
if (end - start > 0)
{
pszId = new char[end - start + 1];
strncpy(pszId, &(szCmdLine[start]), end - start);
pszId[end - start] = 0;
pszId = _strupr(pszId);
}
//multiple spaces between autoreconnect and id
i = end;
}// end of condition we found the ID: parameter
// NOTE: id must be NULL or the ID:???? (pointer will get deleted when message is processed)
// We can not contact a runnning service, permissions, so we must store the settings
// and process until the vncmenu has been started
if (!vncService::PostAddAutoConnectClient( pszId ))
{
PostAddAutoConnectClient_bool=true;
if (pszId==NULL)
{
PostAddAutoConnectClient_bool_null=true;
PostAddAutoConnectClient_bool=false;
}
else
{
strcpy(pszId_char,pszId);
//memory leak fix
delete[] pszId; pszId = NULL;
}
}
if (pszId != NULL) delete[] pszId; pszId = NULL;
continue;
}
if ( strncmp( &szCmdLine[i], winvncReconnectId, strlen(winvncReconnectId) ) == 0 )
{
i+=strlen("-");
int start, end;
char* pszId = NULL;
start = i;
end = start;
while (szCmdLine[end] > ' ') end++;
if (end - start > 0)
{
pszId = new char[end - start + 1];
if (pszId != 0)
{
strncpy(pszId, &(szCmdLine[start]), end - start);
pszId[end - start] = 0;
pszId = _strupr(pszId);
}
}
i = end;
if (!vncService::PostAddConnectClient( pszId ))
{
PostAddConnectClient_bool=true;
if (pszId==NULL)
{
PostAddConnectClient_bool_null=true;
PostAddConnectClient_bool=false;
}
else
{
strcpy(pszId_char,pszId);
//memory leak fix
delete[] pszId; pszId = NULL;
}
}
if (pszId != NULL) delete[] pszId; pszId = NULL;
continue;
}
if (strncmp(&szCmdLine[i], winvncConnect, strlen(winvncConnect)) == 0)
{
if (!Injected_autoreconnect)
{
vncService::PostAddStopConnectClient();
}
// Add a new client to an existing copy of winvnc
i+=strlen(winvncConnect);
// First, we have to parse the command line to get the filename to use
int start, end;
start=i;
while (szCmdLine[start] <= ' ' && szCmdLine[start] != 0) start++;
end = start;
while (szCmdLine[end] > ' ') end++;
// Was there a hostname (and optionally a port number) given?
if (end-start > 0)
{
char *name = new char[end-start+1];
if (name != 0) {
strncpy(name, &(szCmdLine[start]), end-start);
name[end-start] = 0;
int port = INCOMING_PORT_OFFSET;
char *portp = strchr(name, ':');
if (portp) {
*portp++ = '\0';
if (*portp == ':') {
port = atoi(++portp); // Port number after "::"
} else {
port = atoi(portp); // Display number after ":"
}
}
vnclog.Print(LL_STATE, VNCLOG("test... %s %d\n"),name,port);
strcpy_s(dnsname,name);
VCard32 address = VSocket::Resolve(name);
delete [] name;
if (address != 0) {
// Post the IP address to the server
// We can not contact a runnning service, permissions, so we must store the settings
// and process until the vncmenu has been started
vnclog.Print(LL_INTERR, VNCLOG("PostAddNewClient III \n"));
if (!vncService::PostAddNewClientInit(address, port))
{
PostAddNewClient_bool=true;
port_int=port;
address_vcard=address;
}
}
else
{
//ask for host,port
PostAddNewClient_bool=true;
port_int=0;
address_vcard=0;
Sleep(2000);
//Beep(200,1000);
return 0;
}
}
i=end;
continue;
}
else
{
// Tell the server to show the Add New Client dialog
// We can not contact a runnning service, permissions, so we must store the settings
// and process until the vncmenu has been started
vnclog.Print(LL_INTERR, VNCLOG("PostAddNewClient IIII\n"));
if (!vncService::PostAddNewClient(0, 0))
{
PostAddNewClient_bool=true;
port_int=0;
address_vcard=0;
}
}
continue;
}
//adzm 2009-06-20
if (strncmp(&szCmdLine[i], winvncRepeater, strlen(winvncRepeater)) == 0)
{
// set the default repeater host
i+=strlen(winvncRepeater);
// First, we have to parse the command line to get the host to use
int start, end;
start=i;
while (szCmdLine[start] <= ' ' && szCmdLine[start] != 0) start++;
end = start;
while (szCmdLine[end] > ' ') end++;
// Was there a hostname (and optionally a port number) given?
if (end-start > 0)
{
if (g_szRepeaterHost) {
delete[] g_szRepeaterHost;
g_szRepeaterHost = NULL;
}
g_szRepeaterHost = new char[end-start+1];
if (g_szRepeaterHost != 0) {
strncpy(g_szRepeaterHost, &(szCmdLine[start]), end-start);
g_szRepeaterHost[end-start] = 0;
// We can not contact a runnning service, permissions, so we must store the settings
// and process until the vncmenu has been started
vnclog.Print(LL_INTERR, VNCLOG("PostAddNewRepeaterClient I\n"));
if (!vncService::PostAddNewRepeaterClient())
{
PostAddNewRepeaterClient_bool=true;
port_int=0;
address_vcard=0;
}
}
i=end;
continue;
}
else
{
/*
// Tell the server to show the Add New Client dialog
// We can not contact a runnning service, permissions, so we must store the settings
// and process until the vncmenu has been started
vnclog.Print(LL_INTERR, VNCLOG("PostAddNewClient IIII\n"));
if (!vncService::PostAddNewClient(0, 0))
{
PostAddNewClient_bool=true;
port_int=0;
address_vcard=0;
}
*/
}
continue;
}
// Either the user gave the -help option or there is something odd on the cmd-line!
// Show the usage dialog
MessageBoxSecure(NULL, winvncUsageText, sz_ID_WINVNC_USAGE, MB_OK | MB_ICONINFORMATION);
break;
};
// If no arguments were given then just run
if (!argfound)
{
if (!Myinit(hInstance))
{
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
int returnvalue= WinVNCAppMain();
#ifdef CRASHRPT
crUninstall();
#endif
return returnvalue;
}
#ifdef CRASHRPT
crUninstall();
#endif
return 0;
}
int WinVNCAppMain()
{
vnclog.Print(LL_INTINFO, VNCLOG("***** DBG - WinVNCAPPMain\n"));
#ifdef CRASH_ENABLED
LPVOID lpvState = Install(NULL, "*****@*****.**", "UltraVNC");
#endif
// Set this process to be the last application to be shut down.
// Check for previous instances of WinVNC!
vncInstHandler *instancehan=new vncInstHandler;
if (!multi) // this allow to overwrite the multiple instance check
{
if (!instancehan->Init())
{
vnclog.Print(LL_INTINFO, VNCLOG("%s -- exiting\n"), sz_ID_ANOTHER_INST);
// We don't allow multiple instances!
if (!fRunningFromExternalService)
MessageBoxSecure(NULL, sz_ID_ANOTHER_INST, szAppName, MB_OK);
if (instancehan != NULL) delete instancehan;
return 0;
}
}
//vnclog.Print(LL_INTINFO, VNCLOG("***** DBG - Previous instance checked - Trying to create server\n"));
// CREATE SERVER
vncServer server;
// Set the name and port number
server.SetName(szAppName);
vnclog.Print(LL_STATE, VNCLOG("server created ok\n"));
///uninstall driver before cont
// sf@2007 - Set Application0 special mode
server.RunningFromExternalService(fRunningFromExternalService);
// sf@2007 - New impersonation thread stuff for tray icon & menu
// Subscribe to shutdown event
hShutdownEvent = OpenEvent(EVENT_ALL_ACCESS, FALSE, "Global\\SessionEventUltra");
hShutdownEventcad = OpenEvent(EVENT_MODIFY_STATE, FALSE, "Global\\SessionEventUltraCad");
if (hShutdownEvent) ResetEvent(hShutdownEvent);
vnclog.Print(LL_STATE, VNCLOG("***************** SDEvent created \n"));
// Create the timer that looks periodicaly for shutdown event
mmRes = -1;
//InitSDTimer();
while ( !fShutdownOrdered)
{
//vnclog.Print(LL_STATE, VNCLOG("################## Creating Imp Thread : %d \n"), nn);
HANDLE threadHandle;
DWORD dwTId;
threadHandle = CreateThread(NULL, 0, imp_desktop_thread, &server, 0, &dwTId);
if (threadHandle)
{
WaitForSingleObject( threadHandle, INFINITE );
CloseHandle(threadHandle);
}
vnclog.Print(LL_STATE, VNCLOG("################## Closing Imp Thread\n"));
}
//KillSDTimer();
if (instancehan!=NULL)
delete instancehan;
if (hShutdownEvent)CloseHandle(hShutdownEvent);
if (hShutdownEventcad)CloseHandle(hShutdownEventcad);
vnclog.Print(LL_STATE, VNCLOG("################## SHUTING DOWN SERVER ####################\n"));
//adzm 2009-06-20
if (g_szRepeaterHost) {
delete[] g_szRepeaterHost;
g_szRepeaterHost = NULL;
}
return 1;
};
DWORD WINAPI imp_desktop_thread(LPVOID lpParam)
{
vncServer *server = (vncServer *)lpParam;
HDESK desktop;
//vnclog.Print(LL_INTERR, VNCLOG("SelectDesktop \n"));
//vnclog.Print(LL_INTERR, VNCLOG("OpenInputdesktop2 NULL\n"));
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 (!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"));
}
// ImpersonateCurrentUser_();
char m_username[UNLEN+1];
HWINSTA station = GetProcessWindowStation();
if (station != NULL)
{
DWORD usersize;
GetUserObjectInformation(station, UOI_USER_SID, NULL, 0, &usersize);
DWORD dwErrorCode = GetLastError();
SetLastError(0);
if (usersize != 0)
{
DWORD length = sizeof(m_username);
if (GetUserName(m_username, &length) == 0)
{
UINT error = GetLastError();
if (error != ERROR_NOT_LOGGED_ON)
{
vnclog.Print(LL_INTERR, VNCLOG("getusername error %d\n"), GetLastError());
SetThreadDesktop(old_desktop);
CloseDesktop(desktop);
Sleep(500);
return FALSE;
}
}
}
}
vnclog.Print(LL_INTERR, VNCLOG("Username %s \n"),m_username);
// Create tray icon and menu
vncMenu *menu = new vncMenu(server);
if (menu == NULL)
{
vnclog.Print(LL_INTERR, VNCLOG("failed to create tray menu\n"));
PostQuitMessage(0);
}
// This is a good spot to handle the old PostAdd messages
if (PostAddAutoConnectClient_bool)
vncService::PostAddAutoConnectClient( pszId_char );
if (PostAddAutoConnectClient_bool_null)
vncService::PostAddAutoConnectClient( NULL );
if (PostAddConnectClient_bool)
vncService::PostAddConnectClient( pszId_char );
if (PostAddConnectClient_bool_null)
vncService::PostAddConnectClient( NULL );
if (PostAddNewClient_bool)
{
PostAddNewClient_bool=false;
vnclog.Print(LL_INTERR, VNCLOG("PostAddNewClient IIIII\n"));
vncService::PostAddNewClient(address_vcard, port_int);
}
//adzm 2009-06-20
if (PostAddNewRepeaterClient_bool)
{
PostAddNewRepeaterClient_bool=false;
vnclog.Print(LL_INTERR, VNCLOG("PostAddNewRepeaterClient II\n"));
vncService::PostAddNewRepeaterClient();
}
bool Runonce=false;
MSG msg;
while (GetMessage(&msg,0,0,0) != 0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
if (fShutdownOrdered && !Runonce)
{
Runonce=true;
if (menu) menu->Shutdown(true);
}
if (hShutdownEvent)
{
// vnclog.Print(LL_INTERR, VNCLOG("****************** SDTimer tic\n"));
DWORD result = WaitForSingleObject(hShutdownEvent, 1);
if (WAIT_OBJECT_0 == result)
{
ResetEvent(hShutdownEvent);
fShutdownOrdered = true;
vnclog.Print(LL_INTERR, VNCLOG("****************** WaitForSingleObject - Shutdown server\n"));
}
}
}
// sf@2007 - Close all (vncMenu,tray icon, connections...)
if (menu != NULL)
delete menu;
//vnclog.Print(LL_INTERR, VNCLOG("GetMessage stop \n"));
SetThreadDesktop(old_desktop);
CloseDesktop(desktop);
// RevertToSelf();
return 0;
}
