开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 远程控制编程 > 查看源码
ClientConnection.cpp
资源名称：vnc3326s.zip　[点击查看]
上传用户：sbftbdw
上传日期：2007-01-03
资源大小：379k
文件大小：56k
源码类别：

远程控制编程

开发平台：

Visual C++

ClientConnection.cpp：源码内容
  1. //  Copyright (C) 1997, 1998 Olivetti & Oracle Research Laboratory
  2. //
  3. //  This file is part of the VNC system.
  4. //
  5. //  The VNC system is free software; you can redistribute it and/or modify
  6. //  it under the terms of the GNU General Public License as published by
  7. //  the Free Software Foundation; either version 2 of the License, or
  8. //  (at your option) any later version.
  9. //
  10. //  This program is distributed in the hope that it will be useful,
  11. //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. //  GNU General Public License for more details.
  14. //
  15. //  You should have received a copy of the GNU General Public License
  16. //  along with this program; if not, write to the Free Software
  17. //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
  18. //  USA.
  19. //
  20. // If the source code for the VNC system is not available from the place 
  21. // whence you received this file, check http://www.orl.co.uk/vnc or contact
  22. // the authors on vnc@orl.co.uk for information on obtaining it.
  24. // Many thanks to Randy Brown <rgb@inven.com> for providing the 3-button
  25. // emulation code.
  27. // This is the main source for a ClientConnection object.
  28. // It handles almost everything to do with a connection to a server.
  29. // The decoding of specific rectangle encodings is done in separate files.
  31. #include "stdhdrs.h"
  33. #include "vncviewer.h"
  35. #ifdef UNDER_CE
  36. #include "omnithreadce.h"
  37. #define SD_BOTH 0x02
  38. #else
  39. #include "omnithread.h"
  40. #endif
  42. #include "ClientConnection.h"
  43. #include "SessionDialog.h"
  44. #include "AuthDialog.h"
  45. #include "AboutBox.h"
  47. #include "Exception.h"
  48. extern "C" {
  49. #include "vncauth.h"
  50. }
  52. #define INITIALNETBUFSIZE 4096
  53. #define MAX_ENCODINGS 10
  54. #define VWR_WND_CLASS_NAME _T("VNCviewer")
  56. const rfbPixelFormat vnc8bitFormat = {8, 8, 1, 1, 7,7,3, 0,3,6,0,0};
  57. const rfbPixelFormat vnc16bitFormat = {16, 16, 1, 1, 63, 31, 31, 0,6,11,0,0};
  59. static LRESULT CALLBACK ClientConnection::WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam);
  61. // Some handy classes for temporary GDI object selection
  62. // These select objects when constructed and automatically release them when destructed.
  63. class ObjectSelector {
  64. public:
  65. ObjectSelector(HDC hdc, HGDIOBJ hobj) { m_hdc = hdc; m_hOldObj = SelectObject(hdc, hobj); }
  66. ~ObjectSelector() { m_hOldObj = SelectObject(m_hdc, m_hOldObj); }
  67. HGDIOBJ m_hOldObj;
  68. HDC m_hdc;
  69. };
  71. class PaletteSelector {
  72. public:
  73. PaletteSelector(HDC hdc, HPALETTE hpal) { 
  74. m_hdc = hdc; 
  75. m_hOldPal = SelectPalette(hdc, hpal, FALSE); 
  76. RealizePalette(hdc);
  77. }
  78. ~PaletteSelector() { 
  79. m_hOldPal = SelectPalette(m_hdc, m_hOldPal, FALSE); 
  80. RealizePalette(m_hdc);
  81. }
  82. HPALETTE m_hOldPal;
  83. HDC m_hdc;
  84. };
  86. class TempDC {
  87. public:
  88. TempDC(HWND hwnd) { m_hdc = GetDC(hwnd); m_hwnd = hwnd; }
  89. ~TempDC() { ReleaseDC(m_hwnd, m_hdc); }
  90. operator HDC() {return m_hdc;};
  91. HDC m_hdc;
  92. HWND m_hwnd;
  93. };
  95. // *************************************************************************
  96. //  A Client connection involves two threads - the main one which sets up
  97. //  connections and processes window messages and inputs, and a 
  98. //  client-specific one which receives, decodes and draws output data 
  99. //  from the remote server.
  100. //  This first section contains bits which are generally called by the main
  101. //  program thread.
  102. // *************************************************************************
  104. ClientConnection::ClientConnection(VNCviewerApp *pApp)
  105. {
  106. Init(pApp);
  107. }
  109. ClientConnection::ClientConnection(VNCviewerApp *pApp, SOCKET sock) 
  110. {
  111. Init(pApp);
  112. m_sock = sock;
  113. struct sockaddr_in svraddr;
  114. int sasize = sizeof(svraddr);
  115. if (getpeername(sock, (struct sockaddr *) &svraddr, 
  116. &sasize) != SOCKET_ERROR) {
  117. _stprintf(m_host, _T("%d.%d.%d.%d"), 
  118. svraddr.sin_addr.S_un.S_un_b.s_b1, 
  119. svraddr.sin_addr.S_un.S_un_b.s_b2, 
  120. svraddr.sin_addr.S_un.S_un_b.s_b3, 
  121. svraddr.sin_addr.S_un.S_un_b.s_b4);
  122. m_port = svraddr.sin_port;
  123. } else {
  124. _tcscpy(m_host,_T("(unknown)"));
  125. m_port = 0;
  126. };
  127. }
  129. ClientConnection::ClientConnection(VNCviewerApp *pApp, LPTSTR host, int port)
  130. {
  131. Init(pApp);
  132. _tcsncpy(m_host, host, 256);
  133. m_port = port;
  134. }
  136. void ClientConnection::Init(VNCviewerApp *pApp)
  137. {
  138. m_hwnd = 0;
  139. m_desktopName = NULL;
  140. m_port = -1;
  141. m_netbuf = NULL;
  142. m_netbufsize = 0;
  143. m_hwndNextViewer = NULL;
  144. m_pApp = pApp;
  145. m_dormant = false;
  146. m_hBitmapDC = NULL;
  147. m_hBitmap = NULL;
  148. m_hPalette = NULL;
  150. // We take the initial conn options from the application defaults
  151. m_opts = m_pApp->m_options;
  153. m_sock = INVALID_SOCKET;
  154. m_bKillThread = false;
  155. m_threadStarted = true;
  156. m_running = false;
  157. m_pendingFormatChange = false;
  159. m_hScrollPos = 0; m_vScrollPos = 0;
  161. m_waitingOnEmulateTimer = false;
  162. m_emulatingMiddleButton = false;
  164. // Create a buffer for various network operations
  165. CheckBufferSize(INITIALNETBUFSIZE);
  167. m_pApp->RegisterConnection(this);
  169. UpdateWindow(m_hwnd);
  170. }
  172. // 
  173. // Run() creates the connection if necessary, does the initial negotiations
  174. // and then starts the thread running which does the output (update) processing.
  175. // If Run throws an Exception, the caller must delete the ClientConnection object.
  176. //
  178. void ClientConnection::Run()
  179. {
  180. // Get the host name and port if we haven't got it
  181. if (m_port == -1) 
  182. GetConnectDetails();
  184. // Connect if we're not already connected
  185. if (m_sock == INVALID_SOCKET) 
  186. Connect();
  188. SetSocketOptions();
  190. NegotiateProtocolVersion();
  192. Authenticate();
  194. // Set up widows etc 
  195. CreateDisplay();
  197. SendClientInit();
  199. ReadServerInit();
  201. CreateLocalFramebuffer();
  203. SetupPixelFormat();
  205. SetFormatAndEncodings();
  207. // This starts the worker thread.
  208. // The rest of the processing continues in run_undetached.
  209. start_undetached();
  210. }
  212. void ClientConnection::CreateDisplay() 
  213. {
  214. // Create the window
  215. WNDCLASS wndclass;
  217. wndclass.style = 0;
  218. wndclass.lpfnWndProc = ClientConnection::WndProc;
  219. wndclass.cbClsExtra = 0;
  220. wndclass.cbWndExtra = 0;
  221. wndclass.hInstance = m_pApp->m_instance;
  222. wndclass.hIcon = LoadIcon(m_pApp->m_instance, MAKEINTRESOURCE(IDI_MAINICON));
  223. wndclass.hCursor = LoadCursor(m_pApp->m_instance, MAKEINTRESOURCE(IDC_DOTCURSOR));
  224. wndclass.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
  225.     wndclass.lpszMenuName = (const TCHAR *) NULL;
  226. wndclass.lpszClassName = VWR_WND_CLASS_NAME;
  228. RegisterClass(&wndclass);
  230. #ifdef _WIN32_WCE
  231. const DWORD winstyle = WS_VSCROLL | WS_HSCROLL | WS_CAPTION | WS_SYSMENU;
  232. #else
  233. const DWORD winstyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | 
  234.   WS_MINIMIZEBOX | WS_THICKFRAME | WS_VSCROLL | WS_HSCROLL;
  235. #endif
  237. m_hwnd = CreateWindow(VWR_WND_CLASS_NAME,
  238.       _T("VNCviewer"),
  239.       winstyle,
  240.       CW_USEDEFAULT,
  241.       CW_USEDEFAULT,
  242.       CW_USEDEFAULT,       // x-size
  243.       CW_USEDEFAULT,       // y-size
  244.       NULL,                // Parent handle
  245.       NULL,                // Menu handle
  246.       m_pApp->m_instance,
  247.       NULL);
  249. ShowWindow(m_hwnd, SW_HIDE);
  251. // record which client created this window
  252. SetWindowLong(m_hwnd, GWL_USERDATA, (LONG) this);
  255. // Create a memory DC which we'll use for drawing to
  256. // the local framebuffer
  257. m_hBitmapDC = CreateCompatibleDC(NULL);
  259. // Set a suitable palette up
  260. if (GetDeviceCaps(m_hBitmapDC, RASTERCAPS) & RC_PALETTE) {
  261. log.Print(3, _T("Palette-based display - %d entries, %d reservedn"), 
  262. GetDeviceCaps(m_hBitmapDC, SIZEPALETTE), GetDeviceCaps(m_hBitmapDC, NUMRESERVED));
  263. BYTE buf[sizeof(LOGPALETTE)+216*sizeof(PALETTEENTRY)];
  264. LOGPALETTE *plp = (LOGPALETTE *) buf;
  265. int pepos = 0;
  266. for (int r = 5; r >= 0; r--) {
  267. for (int g = 5; g >= 0; g--) {
  268. for (int b = 5; b >= 0; b--) {
  269. plp->palPalEntry[pepos].peRed   = r * 255 / 5; 
  270. plp->palPalEntry[pepos].peGreen = g * 255 / 5;
  271. plp->palPalEntry[pepos].peBlue  = b * 255 / 5;
  272. plp->palPalEntry[pepos].peFlags  = NULL;
  273. pepos++;
  274. }
  275. }
  276. }
  277. plp->palVersion = 0x300;
  278. plp->palNumEntries = 216;
  279. m_hPalette = CreatePalette(plp);
  280. }
  282. // Add stuff to System menu
  283. HMENU hsysmenu = GetSystemMenu(m_hwnd, FALSE);
  284. if (!m_opts.m_restricted) {
  285. AppendMenu(hsysmenu, MF_STRING, IDC_OPTIONBUTTON, _T("Connection &options..."));
  286. AppendMenu(hsysmenu, MF_STRING, ID_CONN_ABOUT, _T("Connection &info"));
  287. AppendMenu(hsysmenu, MF_STRING, ID_REQUEST_REFRESH, _T("Request screen &refresh"));
  289. AppendMenu(hsysmenu, MF_SEPARATOR, NULL, NULL);
  290. AppendMenu(hsysmenu, MF_STRING, ID_FULLSCREEN, _T("&Full screen"));
  291. AppendMenu(hsysmenu, MF_SEPARATOR, NULL, NULL);
  292.   AppendMenu(hsysmenu, MF_STRING, ID_CONN_CTLALTDEL, _T("Send Ctl-Alt-Del"));
  293. AppendMenu(hsysmenu, MF_STRING, ID_CONN_CTLDOWN, _T("Ctrl Down"));
  294. AppendMenu(hsysmenu, MF_STRING, ID_CONN_CTLUP, _T("Ctrl Up"));
  295. AppendMenu(hsysmenu, MF_STRING, ID_CONN_ALTDOWN, _T("Alt Down"));
  296. AppendMenu(hsysmenu, MF_STRING, ID_CONN_ALTUP, _T("Alt Up"));
  297. AppendMenu(hsysmenu, MF_SEPARATOR, NULL, NULL);
  298. AppendMenu(hsysmenu, MF_STRING, ID_NEWCONN, _T("Ne&w connection..."));
  299. }
  300.     AppendMenu(hsysmenu, MF_SEPARATOR, NULL, NULL);
  301. AppendMenu(hsysmenu, MF_STRING, IDD_APP_ABOUT, _T("&About VNCviewer..."));
  302. if (m_opts.m_listening) {
  303. AppendMenu(hsysmenu, MF_SEPARATOR, NULL, NULL);
  304. AppendMenu(hsysmenu, MF_STRING, ID_CLOSEDAEMON, _T("Close listening &daemon"));
  305. }
  306. DrawMenuBar(m_hwnd);
  308. // Set up clipboard watching
  309. #ifndef _WIN32_WCE
  310. // We want to know when the clipboard changes, so
  311. // insert ourselves in the viewer chain. But doing
  312. // this will cause us to be notified immediately of
  313. // the current state.
  314. // We don't want to send that.
  315. m_initialClipboardSeen = false;
  316. m_hwndNextViewer = SetClipboardViewer(m_hwnd); 
  317. #endif
  318. }
  320. void ClientConnection::GetConnectDetails()
  321. {
  322. SessionDialog sessdlg(&m_opts);
  323. if (!sessdlg.DoDialog()) {
  324. throw QuietException("User Cancelled");
  325. }
  326. _tcsncpy(m_host, sessdlg.m_host, 256);
  327. m_port = sessdlg.m_port;
  328. }
  330. void ClientConnection::Connect()
  331. {
  332. struct sockaddr_in thataddr;
  333. int res;
  335. m_sock = socket(PF_INET, SOCK_STREAM, 0);
  336. if (m_sock == INVALID_SOCKET) throw WarningException(_T("Error creating socket"));
  337. int one = 1;
  339. // The host may be specified as a dotted address "a.b.c.d"
  340. // Try that first
  341. thataddr.sin_addr.s_addr = inet_addr(m_host);
  343. // If it wasn't one of those, do gethostbyname
  344. if (thataddr.sin_addr.s_addr == INADDR_NONE) {
  345. LPHOSTENT lphost;
  346. lphost = gethostbyname(m_host);
  348. if (lphost == NULL) { 
  349. throw WarningException("Failed to get server address.nr"
  350. "Did you type the host name correctly?"); 
  351. };
  352. thataddr.sin_addr.s_addr = ((LPIN_ADDR) lphost->h_addr)->s_addr;
  353. };
  355. thataddr.sin_family = AF_INET;
  356. thataddr.sin_port = htons(m_port);
  357. res = connect(m_sock, (LPSOCKADDR) &thataddr, sizeof(thataddr));
  358. if (res == SOCKET_ERROR) throw WarningException("Failed to connect to server");
  359. log.Print(0, _T("Connected to %s port %dn"), m_host, m_port);
  361. }
  363. void ClientConnection::SetSocketOptions() {
  364. // Disable Nagle's algorithm
  365. BOOL nodelayval = TRUE;
  366. if (setsockopt(m_sock, IPPROTO_TCP, TCP_NODELAY, (const char *) &nodelayval, sizeof(BOOL)))
  367. throw WarningException("Error disabling Nagle's algorithm");
  368. }
  371. void ClientConnection::NegotiateProtocolVersion()
  372. {
  373. rfbProtocolVersionMsg pv;
  375.    /* if the connection is immediately closed, don't report anything, so
  376.        that pmw's monitor can make test connections */
  378.     try {
  379. ReadExact(pv, sz_rfbProtocolVersionMsg);
  380. } catch (Exception &c) {
  381. log.Print(0, _T("Error reading protocol version: %sn"), c);
  382. throw QuietException(c.m_info);
  383. }
  385.     pv[sz_rfbProtocolVersionMsg] = 0;
  387. // XXX This is a hack.  Under CE we just return to the server the
  388. // version number it gives us without parsing it.  
  389. // Too much hassle replacing sscanf for now. Fix this!
  390. #ifdef UNDER_CE
  391. m_majorVersion = rfbProtocolMajorVersion;
  392. m_minorVersion = rfbProtocolMinorVersion;
  393. #else
  394.     if (sscanf(pv,rfbProtocolVersionFormat,&m_majorVersion,&m_minorVersion) != 2) {
  395. throw WarningException(_T("Invalid protocol"));
  396.     }
  397.     log.Print(0, _T("RFB server supports protocol version %d.%dn"),
  398.     m_majorVersion,m_minorVersion);
  400.     if ((m_majorVersion == 3) && (m_minorVersion < 3)) {
  402.         /* if server is 3.2 we can't use the new authentication */
  403. log.Print(0, _T("Can't use IDEA authenticationn"));
  404.         /* This will be reported later if authentication is requested*/
  406.     } else {
  408.         /* any other server version, just tell the server what we want */
  409. m_majorVersion = rfbProtocolMajorVersion;
  410. m_minorVersion = rfbProtocolMinorVersion;
  412.     }
  414.     sprintf(pv,rfbProtocolVersionFormat,m_majorVersion,m_minorVersion);
  415. #endif
  417.     WriteExact(pv, sz_rfbProtocolVersionMsg);
  419. log.Print(0, _T("Connected to RFB server, using protocol version %d.%dn"),
  420. rfbProtocolMajorVersion, rfbProtocolMinorVersion);
  421. }
  423. void ClientConnection::Authenticate()
  424. {
  425. CARD32 authScheme, reasonLen, authResult;
  426.     CARD8 challenge[CHALLENGESIZE];
  428. ReadExact((char *)&authScheme, 4);
  429.     authScheme = Swap32IfLE(authScheme);
  431.     switch (authScheme) {
  433.     case rfbConnFailed:
  434. ReadExact((char *)&reasonLen, 4);
  435. reasonLen = Swap32IfLE(reasonLen);
  437. CheckBufferSize(reasonLen+1);
  438. ReadString(m_netbuf, reasonLen);
  440. log.Print(0, _T("RFB connection failed, reason: %sn"), m_netbuf);
  441. throw WarningException(m_netbuf);
  442.         break;
  444.     case rfbNoAuth:
  445. log.Print(0, _T("No authentication neededn"));
  446. break;
  448.     case rfbVncAuth:
  449. {
  450.             if ((m_majorVersion == 3) && (m_minorVersion < 3)) {
  451.                 /* if server is 3.2 we can't use the new authentication */
  452.                 log.Print(0, _T("Can't use IDEA authenticationn"));
  454.                 MessageBox(NULL, 
  455.                     _T("Sorry - this server uses an older authentication schemenr")
  456.                     _T("which is no longer supported."), 
  457.                     _T("Protocol Version error"), 
  458.                     MB_OK | MB_ICONSTOP | MB_SETFOREGROUND | MB_TOPMOST);
  460.                 throw WarningException("Can't use IDEA authentication any more!");
  461.             }
  463. ReadExact((char *)challenge, CHALLENGESIZE);
  465. AuthDialog ad;
  466. ad.DoDialog();
  467. char passwd[256];
  468. #ifndef UNDER_CE
  469. strcpy(passwd, ad.m_passwd);
  470. #else
  471.             int origlen = _tcslen(ad.m_passwd);
  472.             int newlen = WideCharToMultiByte(
  473.                 CP_ACP,    // code page
  474.                 0,         // performance and mapping flags
  475.                 ad.m_passwd, // address of wide-character string
  476.                 origlen,   // number of characters in string
  477.                 passwd,    // address of buffer for new string
  478.                 255,       // size of buffer
  479.                 NULL, NULL );
  480.  
  481.             passwd[newlen]= '';
  482. #endif
  483. if (strlen(passwd) == 0) {
  484. log.Print(0, _T("Password had zero lengthn"));
  485. throw WarningException("Empty password");
  486. }
  487. if (strlen(passwd) > 8) {
  488. passwd[8] = '';
  489. }
  490.     
  491. vncEncryptBytes(challenge, passwd);
  493. /* Lose the password from memory */
  494. for (int i=0; i< (int) strlen(passwd); i++) {
  495. passwd[i] = '';
  496. }
  498. WriteExact((char *) challenge, CHALLENGESIZE);
  499. ReadExact((char *) &authResult, 4);
  501. authResult = Swap32IfLE(authResult);
  503. switch (authResult) {
  504. case rfbVncAuthOK:
  505. log.Print(0, _T("VNC authentication succeededn"));
  506. break;
  507. case rfbVncAuthFailed:
  508. log.Print(0, _T("VNC authentication failed!"));
  509. throw WarningException("VNC authentication failed!");
  510. case rfbVncAuthTooMany:
  511. throw WarningException(
  512. "VNC authentication failed - too many tries!");
  513. default:
  514. log.Print(0, _T("Unknown VNC authentication result: %dn"),
  515. (int)authResult);
  516. throw ErrorException("Unknown VNC authentication result!");
  517. }
  518. break;
  519. }
  521. default:
  522. log.Print(0, _T("Unknown authentication scheme from RFB server: %dn"),
  523. (int)authScheme);
  524. throw ErrorException("Unknown authentication scheme!");
  525.     }
  526. }
  528. void ClientConnection::SendClientInit()
  529. {
  530.     rfbClientInitMsg ci;
  531. ci.shared = m_opts.m_Shared;
  533.     WriteExact((char *)&ci, sz_rfbClientInitMsg);
  534. }
  536. void ClientConnection::ReadServerInit()
  537. {
  538.     ReadExact((char *)&m_si, sz_rfbServerInitMsg);
  540.     m_si.framebufferWidth = Swap16IfLE(m_si.framebufferWidth);
  541.     m_si.framebufferHeight = Swap16IfLE(m_si.framebufferHeight);
  542.     m_si.format.redMax = Swap16IfLE(m_si.format.redMax);
  543.     m_si.format.greenMax = Swap16IfLE(m_si.format.greenMax);
  544.     m_si.format.blueMax = Swap16IfLE(m_si.format.blueMax);
  545.     m_si.nameLength = Swap32IfLE(m_si.nameLength);
  547.     m_desktopName = new TCHAR[m_si.nameLength + 2];
  549. #ifdef UNDER_CE
  550.     char *deskNameBuf = new char[m_si.nameLength + 2];
  552. ReadString(deskNameBuf, m_si.nameLength);
  553.     
  554. MultiByteToWideChar( CP_ACP,   MB_PRECOMPOSED, 
  555.      deskNameBuf, m_si.nameLength,
  556.      m_desktopName, m_si.nameLength+1);
  557.     delete deskNameBuf;
  558. #else
  559.     ReadString(m_desktopName, m_si.nameLength);
  560. #endif
  561.     
  562. SetWindowText(m_hwnd, m_desktopName);
  564. PaletteSelector p(m_hBitmapDC, m_hPalette);
  566. log.Print(0, _T("Desktop name "%s"n"),m_desktopName);
  567. log.Print(1, _T("Geometry %d x %d depth %dn"),
  568. m_si.framebufferWidth, m_si.framebufferHeight, m_si.format.depth );
  569. SetWindowText(m_hwnd, m_desktopName);
  571. // Find how large the desktop work area is
  572. RECT workrect;
  573. SystemParametersInfo(SPI_GETWORKAREA, 0, &workrect, 0);
  574. int workwidth = workrect.right -  workrect.left;
  575. int workheight = workrect.bottom - workrect.top;
  576. log.Print(2, _T("Screen work area is %d x %dn"), workwidth, workheight);
  578. // Size the window.
  579. // Let's find out how big a window would be needed to display the
  580. // whole desktop (assuming no scrollbars).
  582. RECT fullwinrect;
  583. SetRect(&fullwinrect, 0, 0, m_si.framebufferWidth, m_si.framebufferHeight);
  584. AdjustWindowRectEx(&fullwinrect, 
  585.    GetWindowLong(m_hwnd, GWL_STYLE) & ~WS_VSCROLL & ~WS_HSCROLL, 
  586.    FALSE, GetWindowLong(m_hwnd, GWL_EXSTYLE));
  587. m_fullwinwidth = fullwinrect.right - fullwinrect.left;
  588. m_fullwinheight = fullwinrect.bottom - fullwinrect.top;
  590. m_winwidth  = min(m_fullwinwidth,  workwidth);
  591. m_winheight = min(m_fullwinheight, workheight);
  592. SetWindowPos(m_hwnd, HWND_TOP,
  593. workrect.left + (workwidth-m_winwidth) / 2,
  594. workrect.top + (workheight-m_winheight) / 2,
  595. m_winwidth, m_winheight, SWP_SHOWWINDOW);
  597. SetForegroundWindow(m_hwnd);
  598. RealiseFullScreenMode();
  599. }
  601. // We keep a local copy of the whole screen.  This is not sctrictly necessary
  602. // for VNC, but makes scrolling & deiconifying much smoother.
  604. void ClientConnection::CreateLocalFramebuffer() {
  605. // We create a bitmap which has the same pixel characteristics as
  606. // the local display, in the hope that blitting will be faster.
  607. TempDC hdc(m_hwnd);
  608. m_hBitmap = ::CreateCompatibleBitmap(hdc, 
  609. m_si.framebufferWidth, 
  610. m_si.framebufferHeight);
  612. if (m_hBitmap == NULL)
  613. throw WarningException("Error creating local image of screen.");
  615. // Select this bitmap into the DC with an appropriate palette
  616. ObjectSelector b(m_hBitmapDC, m_hBitmap);
  617. PaletteSelector p(m_hBitmapDC, m_hPalette);
  619. // Put a "please wait" message up initially
  620.     RECT rect;
  621. SetRect(&rect, 0,0, m_si.framebufferWidth, m_si.framebufferHeight);
  622. COLORREF bgcol = RGB(0xcc, 0xcc, 0xcc);
  623. FillSolidRect(&rect, bgcol);
  625. COLORREF oldbgcol  = SetBkColor(  m_hBitmapDC, bgcol);
  626. COLORREF oldtxtcol = SetTextColor(m_hBitmapDC, RGB(0,0,64));
  627. rect.right = m_si.framebufferWidth / 2;
  628. rect.bottom = m_si.framebufferHeight / 2;
  630.     DrawText (m_hBitmapDC, _T("Please wait - initial screen loading"), -1, &rect,
  631.                     DT_SINGLELINE | DT_CENTER | DT_VCENTER);
  632. SetBkColor(  m_hBitmapDC, oldbgcol);
  633. SetTextColor(m_hBitmapDC, oldtxtcol);
  635. InvalidateRect(m_hwnd, NULL, FALSE);
  636. }
  638. void ClientConnection::SetupPixelFormat() {
  639. // Have we requested a reduction to 8-bit?
  640.     if (m_opts.m_Use8Bit) {
  641.       
  642. log.Print(2, _T("Requesting 8-bit truecolourn"));  
  643. m_myFormat = vnc8bitFormat;
  644.     
  645. // We don't support colormaps so we'll ask the server to convert
  646.     } else if (!m_si.format.trueColour) {
  647.         
  648.         // We'll just request a standard 16-bit truecolor
  649.         log.Print(2, _T("Requesting 16-bit truecolourn"));
  650.         m_myFormat = vnc16bitFormat;
  651.         
  652.     } else {
  654. // Normally we just use the sever's format suggestion
  655. m_myFormat = m_si.format;
  657. // It's silly requesting more bits than our current display has, but
  658. // in fact it doesn't usually amount to much on the network.
  659. // Windows doesn't support 8-bit truecolour.
  660. // If our display is palette-based, we want more than 8 bit anyway,
  661. // unless we're going to start doing palette stuff at the server.
  662. // So the main use would be a 24-bit true-colour desktop being viewed
  663. // on a 16-bit true-colour display, and unless you have lots of images
  664. // and hence lots of raw-encoded stuff, the size of the pixel is not
  665. // going to make much difference.
  666. //   We therefore don't bother with any restrictions, but here's the
  667. // start of the code if we wanted to do it.
  669. if (false) {
  671. // Get a DC for the root window
  672. TempDC hrootdc(NULL);
  673. int localBitsPerPixel = GetDeviceCaps(hrootdc, BITSPIXEL);
  674. int localRasterCaps   = GetDeviceCaps(hrootdc, RASTERCAPS);
  675. log.Print(2, _T("Memory DC has depth of %d and %s pallete-based.n"), 
  676. localBitsPerPixel, (localRasterCaps & RC_PALETTE) ? "is" : "is not");
  678. // If we're using truecolor, and the server has more bits than we do
  679. if ( (localBitsPerPixel > m_myFormat.depth) && 
  680. ! (localRasterCaps & RC_PALETTE)) {
  681. m_myFormat.depth = localBitsPerPixel;
  683. // create a bitmap compatible with the current display
  684. // call GetDIBits twice to get the colour info.
  685. // set colour masks and shifts
  687. }
  688. }
  689. }
  691. // The endian will be set before sending
  692. }
  694. void ClientConnection::SetFormatAndEncodings()
  695. {
  696. // Set pixel format to myFormat
  697.     
  698. rfbSetPixelFormatMsg spf;
  700.     spf.type = rfbSetPixelFormat;
  701.     spf.format = m_myFormat;
  702.     spf.format.redMax = Swap16IfLE(spf.format.redMax);
  703.     spf.format.greenMax = Swap16IfLE(spf.format.greenMax);
  704.     spf.format.blueMax = Swap16IfLE(spf.format.blueMax);
  705. spf.format.bigEndian = 0;
  707.     WriteExact((char *)&spf, sz_rfbSetPixelFormatMsg);
  709.     // The number of bytes required to hold at least one pixel.
  710. m_minPixelBytes = (m_myFormat.bitsPerPixel + 7) >> 3;
  712. // Set encodings
  713.     char buf[sz_rfbSetEncodingsMsg + MAX_ENCODINGS * 4];
  714.     rfbSetEncodingsMsg *se = (rfbSetEncodingsMsg *)buf;
  715.     CARD32 *encs = (CARD32 *)(&buf[sz_rfbSetEncodingsMsg]);
  716.     int len = 0;
  718.     se->type = rfbSetEncodings;
  719.     se->nEncodings = 0;
  721. // Put the preferred encoding first, and change it if the
  722. // preferred encoding is not actually usable.
  723. for (int i = LASTENCODING; i >= rfbEncodingRaw; i--)
  724. {
  725. if (m_opts.m_PreferredEncoding == i) {
  726. if (m_opts.m_UseEnc[i]) {
  727. encs[se->nEncodings++] = Swap32IfLE(i);
  728. } else {
  729. m_opts.m_PreferredEncoding--;
  730. }
  731. }
  732. }
  734. // Now we go through and put in all the other encodings in order.
  735. // We do rather assume that the most recent encoding is the most
  736. // desirable!
  737. for (i = LASTENCODING; i >= rfbEncodingRaw; i--)
  738. {
  739. if ( (m_opts.m_PreferredEncoding != i) &&
  740.  (m_opts.m_UseEnc[i]))
  741. {
  742. encs[se->nEncodings++] = Swap32IfLE(i);
  743. }
  744. }
  746.     len = sz_rfbSetEncodingsMsg + se->nEncodings * 4;
  748.     se->nEncodings = Swap16IfLE(se->nEncodings);
  750.     WriteExact((char *) buf, len);
  753. }
  755. // Closing down the connection.
  756. // Close the socket, kill the thread.
  757. void ClientConnection::KillThread()
  758. {
  759. m_bKillThread = true;
  760. m_running = false;
  762. if (m_sock != INVALID_SOCKET) {
  763. shutdown(m_sock, SD_BOTH);
  764. closesocket(m_sock);
  765. m_sock = INVALID_SOCKET;
  766. }
  767. }
  770. ClientConnection::~ClientConnection()
  771. {
  772. if (m_hwnd != 0)
  773. DestroyWindow(m_hwnd);
  775. if (m_sock != INVALID_SOCKET) {
  776. shutdown(m_sock, SD_BOTH);
  777. closesocket(m_sock);
  778. m_sock = INVALID_SOCKET;
  779. }
  781. if (m_desktopName != NULL) delete [] m_desktopName;
  782. delete [] m_netbuf;
  783. DeleteDC(m_hBitmapDC);
  784. if (m_hBitmap != NULL)
  785. DeleteObject(m_hBitmap);
  786. if (m_hBitmapDC != NULL)
  787. DeleteObject(m_hBitmapDC);
  788. if (m_hPalette != NULL)
  789. DeleteObject(m_hPalette);
  791. m_pApp->DeregisterConnection(this);
  792. }
  794. // You can specify a dx & dy outside the limits; the return value will
  795. // tell you whether it actually scrolled.
  796. bool ClientConnection::ScrollScreen(int dx, int dy) 
  797. {
  798. dx = max(dx, -m_hScrollPos);
  799. //dx = min(dx, m_hScrollMax-(m_cliwidth-1)-m_hScrollPos);
  800. dx = min(dx, m_hScrollMax-(m_cliwidth)-m_hScrollPos);
  801. dy = max(dy, -m_vScrollPos);
  802. //dy = min(dy, m_vScrollMax-(m_cliheight-1)-m_vScrollPos);
  803. dy = min(dy, m_vScrollMax-(m_cliheight)-m_vScrollPos);
  804. if (dx || dy) {
  805. m_hScrollPos += dx;
  806. m_vScrollPos += dy;
  807. RECT clirect;
  808. GetClientRect(m_hwnd, &clirect);
  809. ScrollWindowEx(m_hwnd, -dx, -dy, NULL, &clirect, NULL, NULL,  SW_INVALIDATE);
  810. UpdateScrollbars();
  811. UpdateWindow(m_hwnd);
  812. return true;
  813. }
  814. return false;
  815. }
  817. // Process windows messages
  819. LRESULT CALLBACK ClientConnection::WndProc(HWND hwnd, UINT iMsg, 
  820.    WPARAM wParam, LPARAM lParam) {
  822. // This is a static method, so we don't know which instantiation we're 
  823. // dealing with.  But we've stored a 'pseudo-this' in the window data.
  824. ClientConnection *_this = (ClientConnection *) GetWindowLong(hwnd, GWL_USERDATA);
  826. switch (iMsg) {
  828. case WM_CREATE:
  829. return 0;
  831. case WM_PAINT:
  832. _this->DoBlit();
  833. return 0;
  835. case WM_TIMER:
  836.   if (wParam == _this->m_emulate3ButtonsTimer)
  837.     {
  838.       _this->SubProcessPointerEvent( 
  839.     _this->m_emulateButtonPressedX,
  840.     _this->m_emulateButtonPressedY,
  841.     _this->m_emulateKeyFlags);
  842.       KillTimer(_this->m_hwnd, _this->m_emulate3ButtonsTimer);
  843.       _this->m_waitingOnEmulateTimer = false;
  844.     }
  845.   return 0;
  846.  
  847. case WM_LBUTTONDOWN:
  848. case WM_LBUTTONUP:
  849. case WM_MBUTTONDOWN:
  850. case WM_MBUTTONUP:
  851. case WM_RBUTTONDOWN:
  852. case WM_RBUTTONUP:
  853. case WM_MOUSEMOVE:
  854. {
  855. if (!_this->m_running) return 0;
  856. if (GetFocus() != hwnd) return 0;
  857. int x = LOWORD(lParam);
  858. int y = HIWORD(lParam);
  859. if (_this->InFullScreenMode()) {
  860. if (_this->BumpScroll(x,y))
  861. return 0;
  862. }
  863. if ( _this->m_opts.m_ViewOnly) return 0;
  864. _this->ProcessPointerEvent(x,y, wParam, iMsg);
  865. return 0;
  866. }
  868. case WM_KEYDOWN:
  869. case WM_KEYUP:
  870. case WM_SYSKEYDOWN:
  871. case WM_SYSKEYUP:
  872. {
  873. if (!_this->m_running) return 0;
  874. if ( _this->m_opts.m_ViewOnly) return 0;
  875.             _this->ProcessKeyEvent((int) wParam, (DWORD) lParam);
  876. return 0;
  877. }
  879. case WM_CHAR:
  880. case WM_SYSCHAR:
  881. #ifdef UNDER_CE
  882.         {
  883.             int key = wParam;
  884.             log.Print(4,_T("CHAR msg : %02xn"), key);
  885.             // Control keys which are in the Keymap table will already
  886.             // have been handled.
  887.             if (key == 0x0D  ||  // return
  888.                 key == 0x20 ||   // space
  889.                 key == 0x08)     // backspace
  890.                 return 0;
  892.             if (key < 32) key += 64;  // map ctrl-keys onto alphabet
  893.             if (key > 32 && key < 127) {
  894.                 _this->SendKeyEvent(wParam & 0xff, true);
  895.                 _this->SendKeyEvent(wParam & 0xff, false);
  896.             }
  897.             return 0;
  898.         }
  899. #endif
  900. case WM_DEADCHAR:
  901. case WM_SYSDEADCHAR:
  902.   return 0;
  904. case WM_SETFOCUS:
  905. if (_this->InFullScreenMode())
  906. SetWindowPos(hwnd, HWND_TOPMOST, 0,0,100,100, SWP_NOMOVE | SWP_NOSIZE);
  907. return 0;
  908. // Cacnel modifiers when we lose focus
  909. case WM_KILLFOCUS:
  910. {
  911. if (!_this->m_running) return 0;
  912. if (_this->InFullScreenMode()) {
  913. // We must top being topmost, but we want to choose our
  914. // position carefully.
  915. HWND foreground = GetForegroundWindow();
  916. HWND hwndafter = NULL;
  917. if ((foreground == NULL) || 
  918. (GetWindowLong(foreground, GWL_EXSTYLE) & WS_EX_TOPMOST)) {
  919. hwndafter = HWND_NOTOPMOST;
  920. } else {
  921. hwndafter = GetNextWindow(foreground, GW_HWNDNEXT); 
  922. }
  924. SetWindowPos(hwnd, hwndafter, 0,0,100,100, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
  925. }
  926. log.Print(6, _T("Losing focus - cancelling modifiersn"));
  927. _this->SendKeyEvent(XK_Alt_L,     false);
  928. _this->SendKeyEvent(XK_Control_L, false);
  929. _this->SendKeyEvent(XK_Shift_L,   false);
  930. _this->SendKeyEvent(XK_Alt_R,     false);
  931. _this->SendKeyEvent(XK_Control_R, false);
  932. _this->SendKeyEvent(XK_Shift_R,   false);
  933. return 0;
  934. }
  935. case WM_CLOSE:
  936. {
  938. // Close the worker thread as well
  939. _this->KillThread();
  940. DestroyWindow(hwnd);
  941. return 0;
  942. }
  944. case WM_DESTROY:
  945. {
  946. #ifndef UNDER_CE
  947. // Remove us from the clipboard viewer chain
  948. BOOL res = ChangeClipboardChain( hwnd, _this->m_hwndNextViewer);
  949. #endif
  950. if (_this->m_waitingOnEmulateTimer)
  951.   {
  952.     KillTimer(_this->m_hwnd, _this->m_emulate3ButtonsTimer);
  953.     _this->m_waitingOnEmulateTimer = false;
  954.   }
  955.   
  956. _this->m_hwnd = 0;
  957. // We are currently in the main thread.
  958. // The worker thread should be about to finish if
  959. // it hasn't already. Wait for it.
  960. try {
  961. void *p;
  962. _this->join(&p);  // After joining, _this is no longer valid
  963. } catch (omni_thread_invalid& e) {
  964. // The thread probably hasn't been started yet,
  965. }
  967. return 0;
  968. }
  970. case WM_SIZE:
  971. {
  972. // Calculate window dimensions
  973. RECT rect;
  974. GetWindowRect(hwnd, &rect);
  975. // update these for the record
  976. _this->m_winwidth = rect.right - rect.left;
  977. _this->m_winheight = rect.bottom - rect.top;
  979. // If the current window size would be large enough to hold the
  980. // whole screen without scrollbars, or if we're full-screen,
  981. // we turn them off.  Under CE, the scroll bars are unchangeable.
  983. #ifndef UNDER_CE
  984. if (_this->InFullScreenMode() ||
  985. _this->m_winwidth  >= _this->m_fullwinwidth  &&
  986. _this->m_winheight >= _this->m_fullwinheight ) {
  987. ShowScrollBar(hwnd, SB_HORZ, FALSE);
  988. ShowScrollBar(hwnd, SB_VERT, FALSE);
  989. } else {
  990. ShowScrollBar(hwnd, SB_HORZ, TRUE);
  991. ShowScrollBar(hwnd, SB_VERT, TRUE);
  992. }
  993. #endif
  995.             // Update these for the record
  996. // And consider that in full-screen mode the window
  997. // is actually bigger than the remote screen.
  998. GetClientRect(hwnd, &rect);
  999. _this->m_cliwidth = min( rect.right - rect.left, 
  1000.  _this->m_si.framebufferWidth );
  1001. _this->m_cliheight = min( rect.bottom - rect.top,
  1002.  _this->m_si.framebufferHeight );
  1004. _this->m_hScrollMax = _this->m_si.framebufferWidth;
  1005. _this->m_vScrollMax = _this->m_si.framebufferHeight;
  1006.             
  1007. int newhpos, newvpos;
  1008. newhpos = max(0, min(_this->m_hScrollPos, 
  1009.  _this->m_hScrollMax - max(_this->m_cliwidth, 0)));
  1010. newvpos = max(0, min(_this->m_vScrollPos, 
  1011.                  _this->m_vScrollMax - max(_this->m_cliheight, 0)));
  1013. ScrollWindowEx(hwnd, _this->m_hScrollPos-newhpos, _this->m_vScrollPos-newvpos,
  1014. NULL, &rect, NULL, NULL,  SW_INVALIDATE);
  1016. _this->m_hScrollPos = newhpos;
  1017. _this->m_vScrollPos = newvpos;
  1018.             _this->UpdateScrollbars();
  1020. return 0;
  1021. }
  1023. case WM_HSCROLL:
  1024. {
  1025. int dx = 0;
  1026. int pos = HIWORD(wParam);
  1027. switch (LOWORD(wParam)) {
  1028. case SB_LINEUP:
  1029. dx = -2; break;
  1030. case SB_LINEDOWN:
  1031. dx = 2; break;
  1032. case SB_PAGEUP:
  1033. dx = _this->m_cliwidth * -1/4; break;
  1034. case SB_PAGEDOWN:
  1035. dx = _this->m_cliwidth * 1/4; break;
  1036. case SB_THUMBPOSITION:
  1037. dx = pos - _this->m_hScrollPos;
  1038. case SB_THUMBTRACK:
  1039. dx = pos - _this->m_hScrollPos;
  1040. }
  1041. _this->ScrollScreen(dx,0);
  1042. return 0;
  1043. }
  1045. case WM_VSCROLL:
  1046. {
  1047. int dy = 0;
  1048. int pos = HIWORD(wParam);
  1049. switch (LOWORD(wParam)) {
  1050. case SB_LINEUP:
  1051. dy = -2; break;
  1052. case SB_LINEDOWN:
  1053. dy = 2; break;
  1054. case SB_PAGEUP:
  1055. dy = _this->m_cliheight * -1/4; break;
  1056. case SB_PAGEDOWN:
  1057. dy = _this->m_cliheight * 1/4; break;
  1058. case SB_THUMBPOSITION:
  1059. dy = pos - _this->m_vScrollPos;
  1060. case SB_THUMBTRACK:
  1061. dy = pos - _this->m_vScrollPos;
  1062. }
  1063. _this->ScrollScreen(0,dy);
  1064. return 0;
  1065. }
  1067.     case WM_QUERYNEWPALETTE:
  1068.         {
  1069. TempDC hDC(hwnd);
  1071. // Select and realize hPalette
  1072. PaletteSelector p(hDC, _this->m_hPalette);
  1073. InvalidateRect(hwnd, NULL, FALSE);
  1074. UpdateWindow(hwnd);
  1076. return TRUE;
  1077.         }
  1079. case WM_PALETTECHANGED:
  1080. // If this application did not change the palette, select
  1081. // and realize this application's palette
  1082. if ((HWND) wParam != hwnd)
  1083. {
  1084. // Need the window's DC for SelectPalette/RealizePalette
  1085. TempDC hDC(hwnd);
  1086. PaletteSelector p(hDC, _this->m_hPalette);
  1087. // When updating the colors for an inactive window,
  1088. // UpdateColors can be called because it is faster than
  1089. // redrawing the client area (even though the results are
  1090. // not as good)
  1091. #ifndef UNDER_CE
  1092. UpdateColors(hDC);
  1093. #else
  1094. InvalidateRect(hwnd, NULL, FALSE);
  1095. UpdateWindow(hwnd);
  1096. #endif
  1098. }
  1099.         break;
  1101. #ifndef UNDER_CE
  1102. case WM_SIZING:
  1103. {
  1104. // Don't allow sizing larger than framebuffer
  1105. RECT *lprc = (LPRECT) lParam;
  1106. switch (wParam) {
  1107. case WMSZ_RIGHT: 
  1108. case WMSZ_TOPRIGHT:
  1109. case WMSZ_BOTTOMRIGHT:
  1110. lprc->right = min(lprc->right, lprc->left + _this->m_fullwinwidth+1);
  1111. break;
  1112. case WMSZ_LEFT:
  1113. case WMSZ_TOPLEFT:
  1114. case WMSZ_BOTTOMLEFT:
  1115. lprc->left = max(lprc->left, lprc->right - _this->m_fullwinwidth);
  1116. break;
  1117. }
  1119. switch (wParam) {
  1120. case WMSZ_TOP:
  1121. case WMSZ_TOPLEFT:
  1122. case WMSZ_TOPRIGHT:
  1123. lprc->top = max(lprc->top, lprc->bottom - _this->m_fullwinheight);
  1124. break;
  1125. case WMSZ_BOTTOM:
  1126. case WMSZ_BOTTOMLEFT:
  1127. case WMSZ_BOTTOMRIGHT:
  1128. lprc->bottom = min(lprc->bottom, lprc->top + _this->m_fullwinheight);
  1129. break;
  1130. }
  1132. return 0;
  1133. }
  1135. case WM_SETCURSOR:
  1136. {
  1137. // if we have the focus, let the cursor change as normal
  1138. if (GetFocus() == hwnd) 
  1139. break;
  1141. // if not, set to default system cursor
  1142. SetCursor( LoadCursor(NULL, IDC_ARROW));
  1143. return 0;
  1144. }
  1146. case WM_SYSCOMMAND:
  1147. {
  1148. switch (LOWORD(wParam)) {
  1149. case SC_MINIMIZE:
  1150. _this->SetDormant(true);
  1151. break;
  1152. case SC_RESTORE:
  1153. _this->SetDormant(false);
  1154. break;
  1155.             case ID_NEWCONN:
  1156. _this->m_pApp->NewConnection();
  1157. return 0;
  1158. case IDC_OPTIONBUTTON: 
  1159. if (_this->m_opts.DoDialog(true)) {
  1160. _this->m_pendingFormatChange = true;
  1161. // Make the window correspond to the requested state
  1162. _this->RealiseFullScreenMode();
  1163. };
  1164. return 0;
  1165. case IDD_APP_ABOUT:
  1166. ShowAboutBox();
  1167. return 0;
  1168. case ID_CONN_ABOUT:
  1169. _this->ShowConnInfo();
  1170. return 0;
  1171. case ID_FULLSCREEN: 
  1172. // Toggle full screen mode
  1173. _this->SetFullScreenMode(!_this->InFullScreenMode());
  1174. return 0;
  1175. case ID_REQUEST_REFRESH: 
  1176. // Request a full-screen update
  1177. _this->SendFullFramebufferUpdateRequest();
  1178. return 0;
  1180. case ID_CONN_CTLALTDEL:
  1181. _this->SendKeyEvent(XK_Control_L, true);
  1182. _this->SendKeyEvent(XK_Alt_L,     true);
  1183. _this->SendKeyEvent(XK_Delete,    true);
  1184. _this->SendKeyEvent(XK_Delete,    false);
  1185. _this->SendKeyEvent(XK_Alt_L,     false);
  1186. _this->SendKeyEvent(XK_Control_L, false);
  1187. return 0;
  1188.             case ID_CONN_CTLDOWN:
  1189.                 _this->SendKeyEvent(XK_Control_L, true);
  1190.                 return 0;
  1191.             case ID_CONN_CTLUP:
  1192. _this->SendKeyEvent(XK_Control_L, false);
  1193. return 0;
  1194. case ID_CONN_ALTDOWN:
  1195.                 _this->SendKeyEvent(XK_Alt_L, true);
  1196. return 0;
  1197. case ID_CONN_ALTUP:
  1198.                 _this->SendKeyEvent(XK_Alt_L, false);
  1199.                 return 0;
  1200. case ID_CLOSEDAEMON:
  1201. if (MessageBox(NULL, _T("Are you sure you want to exit?"), 
  1202. _T("Closing VNCviewer"), 
  1203. MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2) == IDYES)
  1204. PostQuitMessage(0);
  1205. return 0;
  1206. }
  1207. break;
  1208. }
  1210. case WM_DRAWCLIPBOARD:
  1211. _this->ProcessLocalClipboardChange();
  1212. return 0;
  1214. case WM_CHANGECBCHAIN:
  1215. {
  1216. // The clipboard chain is changing
  1217. HWND hWndRemove = (HWND) wParam;     // handle of window being removed 
  1218. HWND hWndNext = (HWND) lParam;       // handle of next window in chain 
  1219. // If next window is closing, update our pointer.
  1220. if (hWndRemove == _this->m_hwndNextViewer)  
  1221. _this->m_hwndNextViewer = hWndNext;  
  1222. // Otherwise, pass the message to the next link.  
  1223. else if (_this->m_hwndNextViewer != NULL) 
  1224. ::SendMessage(_this->m_hwndNextViewer, WM_CHANGECBCHAIN, 
  1225. (WPARAM) hWndRemove,  (LPARAM) hWndNext );  
  1226. return 0;
  1228. }
  1229. #endif
  1230. }
  1232. return DefWindowProc(hwnd, iMsg, wParam, lParam);
  1234. // We know about an unused variable here.
  1235. #pragma warning(disable : 4101)
  1236. }
  1238. #pragma warning(default : 4101)
  1240. // ProcessPointerEvent handles the delicate case of emulating 3 buttons
  1241. // on a two button mouse, then passes events off to SubProcessPointerEvent.
  1242. void
  1243. ClientConnection::ProcessPointerEvent(int x, int y, DWORD keyflags, UINT msg) 
  1244. {
  1245. if (m_opts.m_Emul3Buttons) {
  1246. // XXX To be done:
  1247. // If this is a left or right press, the user may be 
  1248. // about to press the other button to emulate a middle press.
  1249. // We need to start a timer, and if it expires without any
  1250. // further presses, then we send the button press. 
  1251. // If a press of the other button, or any release, comes in
  1252. // before timer has expired, we cancel timer & take different action.
  1253.   if (m_waitingOnEmulateTimer)
  1254.     {
  1255.       if (msg == WM_LBUTTONUP || msg == WM_RBUTTONUP ||
  1256.   abs(x - m_emulateButtonPressedX) > m_opts.m_Emul3Fuzz ||
  1257.   abs(y - m_emulateButtonPressedY) > m_opts.m_Emul3Fuzz)
  1258. {
  1259.   // if button released or we moved too far then cancel.
  1260.   // First let the remote know where the button was down
  1261.   SubProcessPointerEvent(
  1262.  m_emulateButtonPressedX, 
  1263.  m_emulateButtonPressedY, 
  1264.  m_emulateKeyFlags);
  1265.   // Then tell it where we are now
  1266.   SubProcessPointerEvent(x, y, keyflags);
  1267. }
  1268.       else if (
  1269.        (msg == WM_LBUTTONDOWN && (m_emulateKeyFlags & MK_RBUTTON))
  1270.        || (msg == WM_RBUTTONDOWN && (m_emulateKeyFlags & MK_LBUTTON)))
  1271. {
  1272.   // Triggered an emulate; remove left and right buttons, put
  1273.   // in middle one.
  1274.   DWORD emulatekeys = keyflags & ~(MK_LBUTTON|MK_RBUTTON);
  1275.   emulatekeys |= MK_MBUTTON;
  1276.   SubProcessPointerEvent(x, y, emulatekeys);
  1277.   
  1278.   m_emulatingMiddleButton = true;
  1279. }
  1280.       else
  1281. {
  1282.   // handle movement normally & don't kill timer.
  1283.   // just remove the pressed button from the mask.
  1284.   DWORD keymask = m_emulateKeyFlags & (MK_LBUTTON|MK_RBUTTON);
  1285.   DWORD emulatekeys = keyflags & ~keymask;
  1286.   SubProcessPointerEvent(x, y, emulatekeys);
  1287.   return;
  1288. }
  1289.       
  1290.       // if we reached here, we don't need the timer anymore.
  1291.       KillTimer(m_hwnd, m_emulate3ButtonsTimer);
  1292.       m_waitingOnEmulateTimer = false;
  1293.     }
  1294.   else if (m_emulatingMiddleButton)
  1295.     {
  1296.       if ((keyflags & MK_LBUTTON) == 0 && (keyflags & MK_RBUTTON) == 0)
  1297. {
  1298.   // We finish emulation only when both buttons come back up.
  1299.   m_emulatingMiddleButton = false;
  1300.   SubProcessPointerEvent(x, y, keyflags);
  1301. }
  1302.       else
  1303. {
  1304.   // keep emulating.
  1305.   DWORD emulatekeys = keyflags & ~(MK_LBUTTON|MK_RBUTTON);
  1306.   emulatekeys |= MK_MBUTTON;
  1307.   SubProcessPointerEvent(x, y, emulatekeys);
  1308. }
  1309.     }
  1310.   else
  1311.     {
  1312.       // Start considering emulation if we've pressed a button
  1313.       // and the other isn't pressed.
  1314.       if ( (msg == WM_LBUTTONDOWN && !(keyflags & MK_RBUTTON))
  1315.    || (msg == WM_RBUTTONDOWN && !(keyflags & MK_LBUTTON)))
  1316. {
  1317.   // Start timer for emulation.
  1318.   m_emulate3ButtonsTimer = 
  1319.     SetTimer(
  1320.      m_hwnd, 
  1321.      IDT_EMULATE3BUTTONSTIMER, 
  1322.      m_opts.m_Emul3Timeout, 
  1323.      NULL);
  1324.   
  1325.   if (!m_emulate3ButtonsTimer)
  1326.     {
  1327.       log.Print(0, _T("Failed to create timer for emulating 3 buttons"));
  1328.       PostMessage(m_hwnd, WM_CLOSE, 0, 0);
  1329.       return;
  1330.     }
  1331.   
  1332.   m_waitingOnEmulateTimer = true;
  1333.   
  1334.   // Note that we don't send the event here; we're batching it for
  1335.   // later.
  1336.   m_emulateKeyFlags = keyflags;
  1337.   m_emulateButtonPressedX = x;
  1338.   m_emulateButtonPressedY = y;
  1339. }
  1340.       else
  1341. {
  1342.   // just send event noramlly
  1343.   SubProcessPointerEvent(x, y, keyflags);
  1344. }
  1345.     }
  1346.   }
  1347. else
  1348.   {
  1349.     SubProcessPointerEvent(x, y, keyflags);
  1350.   }
  1351. }
  1353. // SubProcessPointerEvent takes windows positions and flags and converts 
  1354. // them into VNC ones.
  1356. inline void 
  1357. ClientConnection::SubProcessPointerEvent(int x, int y, DWORD keyflags) 
  1358. {
  1359.   int mask;
  1360.   
  1361.   if (m_opts.m_SwapMouse) {
  1362. mask = ( ((keyflags & MK_LBUTTON) ? rfbButton1Mask : 0) |
  1363. ((keyflags & MK_MBUTTON) ? rfbButton3Mask : 0) |
  1364. ((keyflags & MK_RBUTTON) ? rfbButton2Mask : 0)  );
  1365. } else {
  1366. mask = ( ((keyflags & MK_LBUTTON) ? rfbButton1Mask : 0) |
  1367. ((keyflags & MK_MBUTTON) ? rfbButton2Mask : 0) |
  1368. ((keyflags & MK_RBUTTON) ? rfbButton3Mask : 0)  );
  1369. }
  1371. try {
  1372. SendPointerEvent(x + m_hScrollPos, y + m_vScrollPos, mask);
  1373. } catch (Exception &e) {
  1374. e.Report();
  1375. PostMessage(m_hwnd, WM_CLOSE, 0, 0);
  1376. }
  1377. }
  1379. //
  1380. // SendPointerEvent.
  1381. //
  1383. inline void
  1384. ClientConnection::SendPointerEvent(int x, int y, int buttonMask)
  1385. {
  1386.     rfbPointerEventMsg pe;
  1388.     pe.type = rfbPointerEvent;
  1389.     pe.buttonMask = buttonMask;
  1390.     if (x < 0) x = 0;
  1391.     if (y < 0) y = 0;
  1392.     pe.x = Swap16IfLE(x);
  1393.     pe.y = Swap16IfLE(y);
  1394. WriteExact((char *)&pe, sz_rfbPointerEventMsg);
  1395. }
  1397. //
  1398. // ProcessKeyEvent
  1399. //
  1400. // Normally a single Windows key event will map onto a single RFB
  1401. // key message, but this is not always the case.  Much of the stuff
  1402. // here is to handle AltGr (=Ctrl-Alt) on international keyboards.
  1403. // Example cases:
  1404. //
  1405. //    We want Ctrl-F to be sent as:
  1406. //      Ctrl-Down, F-Down, F-Up, Ctrl-Up.
  1407. //    because there is no keysym for ctrl-f, and because the ctrl
  1408. //    will already have been sent by the time we get the F.
  1409. //
  1410. //    On German keyboards, @ is produced using AltGr-Q, which is
  1411. //    Ctrl-Alt-Q.  But @ is a valid keysym in its own right, and when
  1412. //    a German user types this combination, he doesn't mean Ctrl-@.
  1413. //    So for this we will send, in total:
  1414. //
  1415. //      Ctrl-Down, Alt-Down,   
  1416. //                 (when we get the AltGr pressed)
  1417. //
  1418. //      Alt-Up, Ctrl-Up, @-Down, Ctrl-Down, Alt-Down 
  1419. //                 (when we discover that this is @ being pressed)
  1420. //
  1421. //      Alt-Up, Ctrl-Up, @-Up, Ctrl-Down, Alt-Down
  1422. //                 (when we discover that this is @ being released)
  1423. //
  1424. //      Alt-Up, Ctrl-Up
  1425. //                 (when the AltGr is released)
  1427. inline void ClientConnection::ProcessKeyEvent(int virtkey, DWORD keyData)
  1428. {
  1429.     bool down = ((keyData & 0x80000000l) == 0);
  1431.     // if virtkey found in mapping table, send X equivalent
  1432.     // else
  1433.     //   try to convert directly to ascii
  1434.     //   if result is in range supported by X keysyms,
  1435.     //      raise any modifiers, send it, then restore mods
  1436.     //   else
  1437.     //      calculate what the ascii would be without mods
  1438.     //      send that
  1440. #ifdef _DEBUG
  1441. #ifdef UNDER_CE
  1442. char *keyname="";
  1443. #else
  1444.     char keyname[32];
  1445.     if (GetKeyNameText(  keyData,keyname, 31)) {
  1446.         log.Print(4, _T("Process key: %s (keyData %04x): "), keyname, keyData);
  1447.     };
  1448. #endif
  1449. #endif
  1451. try {
  1452. KeyActionSpec kas = m_keymap.PCtoX(virtkey, keyData);    
  1454. if (kas.releaseModifiers & KEYMAP_LCONTROL) {
  1455. SendKeyEvent(XK_Control_L, false );
  1456. log.Print(5, _T("fake L Ctrl raisedn"));
  1457. }
  1458. if (kas.releaseModifiers & KEYMAP_LALT) {
  1459. SendKeyEvent(XK_Alt_L, false );
  1460. log.Print(5, _T("fake L Alt raisedn"));
  1461. }
  1462. if (kas.releaseModifiers & KEYMAP_RCONTROL) {
  1463. SendKeyEvent(XK_Control_R, false );
  1464. log.Print(5, _T("fake R Ctrl raisedn"));
  1465. }
  1466. if (kas.releaseModifiers & KEYMAP_RALT) {
  1467. SendKeyEvent(XK_Alt_R, false );
  1468. log.Print(5, _T("fake R Alt raisedn"));
  1469. }
  1471. for (int i = 0; kas.keycodes[i] != XK_VoidSymbol && i < MaxKeysPerKey; i++) {
  1472. SendKeyEvent(kas.keycodes[i], down );
  1473. log.Print(4, _T("Sent keysym %04x (%s)n"), 
  1474. kas.keycodes[i], down ? _T("press") : _T("release"));
  1475. }
  1477. if (kas.releaseModifiers & KEYMAP_RALT) {
  1478. SendKeyEvent(XK_Alt_R, true );
  1479. log.Print(5, _T("fake R Alt pressedn"));
  1480. }
  1481. if (kas.releaseModifiers & KEYMAP_RCONTROL) {
  1482. SendKeyEvent(XK_Control_R, true );
  1483. log.Print(5, _T("fake R Ctrl pressedn"));
  1484. }
  1485. if (kas.releaseModifiers & KEYMAP_LALT) {
  1486. SendKeyEvent(XK_Alt_L, false );
  1487. log.Print(5, _T("fake L Alt pressedn"));
  1488. }
  1489. if (kas.releaseModifiers & KEYMAP_LCONTROL) {
  1490. SendKeyEvent(XK_Control_L, false );
  1491. log.Print(5, _T("fake L Ctrl pressedn"));
  1492. }
  1493. } catch (Exception &e) {
  1494. e.Report();
  1495. PostMessage(m_hwnd, WM_CLOSE, 0, 0);
  1496. }
  1498. }
  1500. //
  1501. // SendKeyEvent
  1502. //
  1504. inline void
  1505. ClientConnection::SendKeyEvent(CARD32 key, bool down)
  1506. {
  1507.     rfbKeyEventMsg ke;
  1509.     ke.type = rfbKeyEvent;
  1510.     ke.down = down ? 1 : 0;
  1511.     ke.key = Swap32IfLE(key);
  1512.     WriteExact((char *)&ke, sz_rfbKeyEventMsg);
  1513.     log.Print(6, _T("SendKeyEvent: key = x%04x status = %sn"), key, 
  1514.         down ? _T("down") : _T("up"));
  1515. }
  1517. #ifndef UNDER_CE
  1518. //
  1519. // SendClientCutText
  1520. //
  1522. void ClientConnection::SendClientCutText(char *str, int len)
  1523. {
  1524.     rfbClientCutTextMsg cct;
  1526.     cct.type = rfbClientCutText;
  1527.     cct.length = Swap32IfLE(len);
  1528.     WriteExact((char *)&cct, sz_rfbClientCutTextMsg);
  1529. WriteExact(str, len);
  1530. log.Print(6, _T("Sent %d bytes of clipboardn"), len);
  1531. }
  1532. #endif
  1534. // Copy any updated areas from the bitmap onto the screen.
  1536. inline void ClientConnection::DoBlit() 
  1537. {
  1538. if (m_hBitmap == NULL) return;
  1539. if (!m_running) return;
  1540. omni_mutex_lock l(m_bitmapdcMutex);
  1542. PAINTSTRUCT ps;
  1543. HDC hdc = BeginPaint(m_hwnd, &ps);
  1544. HPALETTE hOldPal = NULL;
  1545. // Select and realize hPalette
  1546. PaletteSelector p(hdc, m_hPalette);
  1548. ObjectSelector b(m_hBitmapDC, m_hBitmap);
  1550. if (m_opts.m_delay) {
  1551. // Display the area to be updated for debugging purposes
  1552. COLORREF oldbgcol = SetBkColor(hdc, RGB(0,0,0));
  1553. ::ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &ps.rcPaint, NULL, 0, NULL);
  1554. SetBkColor(hdc,oldbgcol);
  1555. ::Sleep(m_pApp->m_options.m_delay);
  1556. }
  1558. if (!BitBlt(hdc, ps.rcPaint.left, ps.rcPaint.top, 
  1559. ps.rcPaint.right-ps.rcPaint.left, ps.rcPaint.bottom-ps.rcPaint.top, 
  1560. m_hBitmapDC, ps.rcPaint.left+m_hScrollPos, ps.rcPaint.top+m_vScrollPos, SRCCOPY)) 
  1561. {
  1562. log.Print(0, _T("Blit error %dn"), GetLastError());
  1563. throw ErrorException("Error in blit!n");
  1564. }
  1567. EndPaint(m_hwnd, &ps);
  1568. }
  1570. inline void ClientConnection::UpdateScrollbars() 
  1571. {
  1572. // We don't update the actual scrollbar info in full-screen mode
  1573. // because it causes them to flicker.
  1574. bool setInfo = !InFullScreenMode();
  1576. SCROLLINFO scri;
  1577. scri.cbSize = sizeof(scri);
  1578. scri.fMask = SIF_ALL;
  1579. scri.nMin = 0;
  1580. scri.nMax = m_hScrollMax;     
  1581. scri.nPage= m_cliwidth;
  1582. scri.nPos = m_hScrollPos; 
  1584. if (setInfo) 
  1585. SetScrollInfo(m_hwnd, SB_HORZ, &scri, TRUE);
  1587. scri.cbSize = sizeof(scri);
  1588. scri.fMask = SIF_ALL;
  1589. scri.nMin = 0;
  1590. scri.nMax = m_vScrollMax;     
  1591. scri.nPage= m_cliheight;
  1592. scri.nPos = m_vScrollPos; 
  1594. if (setInfo) 
  1595. SetScrollInfo(m_hwnd, SB_VERT, &scri, TRUE);
  1596. }
  1599. void ClientConnection::ShowConnInfo()
  1600. {
  1601. TCHAR buf[2048];
  1602. #ifndef UNDER_CE
  1603. char kbdname[9];
  1604. GetKeyboardLayoutName(kbdname);
  1605. #else
  1606. TCHAR *kbdname = _T("(n/a)");
  1607. #endif
  1608. _stprintf(
  1609. buf,
  1610. _T("Connected to: %s:nr")
  1611. _T("Host: %s port: %dnrnr")
  1612. _T("Desktop geometry: %d x %d x %dnr")
  1613. _T("Using depth: %dnr")
  1614. _T("Current protocol version: %d.%dnrnr")
  1615. _T("Current keyboard name: %snr"),
  1616. m_desktopName, m_host, m_port,
  1617. m_si.framebufferWidth, m_si.framebufferHeight, m_si.format.depth,
  1618. m_myFormat.depth,
  1619. m_majorVersion, m_minorVersion,
  1620. kbdname);
  1621. MessageBox(NULL, buf, _T("VNC connection info"), MB_ICONINFORMATION | MB_OK);
  1622. }
  1624. // ********************************************************************
  1625. //  Methods after this point are generally called by the worker thread.
  1626. //  They finish the initialisation, then chiefly read data from the server.
  1627. // ********************************************************************
  1630. void* ClientConnection::run_undetached(void* arg) {
  1632. log.Print(9,_T("Update-processing thread startedn"));
  1634. m_threadStarted = true;
  1636. try {
  1639. UpdateWindow(m_hwnd);
  1641. SendFullFramebufferUpdateRequest();
  1643. m_running = true;
  1645. while (!m_bKillThread) {
  1647. // Look at the type of the message, but leave it in the buffer 
  1648. CARD8 msgType;
  1649. {
  1650.   omni_mutex_lock l(m_readMutex);
  1651.   int bytes = recv(m_sock, (char *) &msgType, 1, MSG_PEEK);
  1652.   if (bytes == 0) {
  1653.     log.Print(0, _T("Socket closedn") );
  1654.     throw QuietException(_T("SocketClosed"));
  1655.   }
  1656.   if (bytes < 0) {
  1657.     log.Print(3, _T("Socket error reading message: %dn"), WSAGetLastError() );
  1658.     throw WarningException("Error while waiting for server message");
  1659.   }
  1660. }
  1662. switch (msgType) {
  1663. case rfbFramebufferUpdate:
  1664. ReadScreenUpdate();
  1665. if (m_pendingFormatChange) {
  1666. log.Print(3, _T("Requesting new pixel formatn") );
  1667. rfbPixelFormat oldFormat = m_myFormat;
  1668. SetupPixelFormat();
  1669. SetFormatAndEncodings();
  1670. m_pendingFormatChange = false;
  1671. // If the pixel format has changed, request whole screen
  1672. if (memcmp(&m_myFormat, &oldFormat, sizeof(rfbPixelFormat)) != 0) {
  1673. SendFullFramebufferUpdateRequest();
  1674. } else {
  1675. SendIncrementalFramebufferUpdateRequest();
  1676. }
  1677. } else {
  1678. if (!m_dormant)
  1679. SendIncrementalFramebufferUpdateRequest();
  1680. }
  1681. break;
  1682. case rfbSetColourMapEntries:
  1683.         log.Print(3, _T("rfbSetColourMapEntries read but not supportedn") );
  1684. throw WarningException("Unhandled SetColormap message type received!n");
  1685. break;
  1686. case rfbBell:
  1687. ReadBell();
  1688. break;
  1689. case rfbServerCutText:
  1690. ReadServerCutText();
  1691. break;
  1692. default:
  1693.                 log.Print(3, _T("Unknown message type x%02xn"), msgType );
  1694. throw WarningException("Unhandled message type received!n");
  1695. }
  1697. }
  1698.         
  1699.         log.Print(4, _T("Update-processing thread finishingn") );
  1701. } catch (WarningException) {
  1702. PostMessage(m_hwnd, WM_CLOSE, 0, 0);
  1703. } catch (QuietException &e) {
  1704. e.Report();
  1705. PostMessage(m_hwnd, WM_CLOSE, 0, 0);
  1706. } 
  1707. return this;
  1708. }
  1711. //
  1712. // Requesting screen updates from the server
  1713. //
  1715. inline void
  1716. ClientConnection::SendFramebufferUpdateRequest(int x, int y, int w, int h, bool incremental)
  1717. {
  1718.     rfbFramebufferUpdateRequestMsg fur;
  1720.     fur.type = rfbFramebufferUpdateRequest;
  1721.     fur.incremental = incremental ? 1 : 0;
  1722.     fur.x = Swap16IfLE(x);
  1723.     fur.y = Swap16IfLE(y);
  1724.     fur.w = Swap16IfLE(w);
  1725.     fur.h = Swap16IfLE(h);
  1727. log.Print(10, _T("Request %s updaten"), incremental ? _T("incremental") : _T("full"));
  1728.     WriteExact((char *)&fur, sz_rfbFramebufferUpdateRequestMsg);
  1729. }
  1731. inline void ClientConnection::SendIncrementalFramebufferUpdateRequest()
  1732. {
  1733.     SendFramebufferUpdateRequest(0, 0, m_si.framebufferWidth,
  1734. m_si.framebufferHeight, true);
  1735. }
  1737. inline void ClientConnection::SendFullFramebufferUpdateRequest()
  1738. {
  1739.     SendFramebufferUpdateRequest(0, 0, m_si.framebufferWidth,
  1740. m_si.framebufferHeight, false);
  1741. }
  1745. // A ScreenUpdate message has been received
  1747. void ClientConnection::ReadScreenUpdate() {
  1749. rfbFramebufferUpdateMsg sut;
  1750. ReadExact((char *) &sut, sz_rfbFramebufferUpdateMsg);
  1751.     sut.nRects = Swap16IfLE(sut.nRects);
  1752. if (sut.nRects == 0) return;
  1754. // No other threads can use DC
  1755. omni_mutex_lock l(m_bitmapdcMutex);
  1757. ObjectSelector b(m_hBitmapDC, m_hBitmap);
  1758. PaletteSelector p(m_hBitmapDC, m_hPalette);
  1760. // Find the bounding region of this batch of updates
  1761. HRGN fullregion = NULL;
  1763. for (UINT i=0; i < sut.nRects; i++) {
  1765. rfbFramebufferUpdateRectHeader surh;
  1766. ReadExact((char *) &surh, sz_rfbFramebufferUpdateRectHeader);
  1767. surh.r.x = Swap16IfLE(surh.r.x);
  1768. surh.r.y = Swap16IfLE(surh.r.y);
  1769. surh.r.w = Swap16IfLE(surh.r.w);
  1770. surh.r.h = Swap16IfLE(surh.r.h);
  1771. surh.encoding = Swap32IfLE(surh.encoding);
  1773. switch (surh.encoding) {
  1774. case rfbEncodingRaw:
  1775. ReadRawRect(&surh);
  1776. break;
  1777. case rfbEncodingCopyRect:
  1778. ReadCopyRect(&surh);
  1779. break;
  1780. case rfbEncodingRRE:
  1781. ReadRRERect(&surh);
  1782. break;
  1783. case rfbEncodingCoRRE:
  1784. ReadCoRRERect(&surh);
  1785. break;
  1786. case rfbEncodingHextile:
  1787. ReadHextileRect(&surh);
  1788. break;
  1789. default:
  1790. log.Print(0, _T("Unknown encoding %d - not supported!n"), surh.encoding);
  1791. break;
  1792. }
  1794. RECT rect;
  1795. rect.left   = surh.r.x - m_hScrollPos;
  1796. rect.top    = surh.r.y - m_vScrollPos;
  1797. rect.right  = rect.left + surh.r.w;
  1798. rect.bottom = rect.top  + surh.r.h;
  1799. InvalidateRect(m_hwnd, &rect, FALSE);
  1800. }
  1801. }
  1803. void ClientConnection::SetDormant(bool newstate)
  1804. {
  1805. log.Print(5, _T("%s dormant moden"), newstate ? _T("Entering") : _T("Leaving"));
  1806. m_dormant = newstate;
  1807. if (!m_dormant)
  1808. SendIncrementalFramebufferUpdateRequest();
  1809. }
  1811. // The server has copied some text to the clipboard - put it 
  1812. // in the local clipboard too.
  1814. void ClientConnection::ReadServerCutText() {
  1815. rfbServerCutTextMsg sctm;
  1816. log.Print(6, _T("Read remote clipboard changen"));
  1817. ReadExact((char *) &sctm, sz_rfbServerCutTextMsg);
  1818. int len = Swap32IfLE(sctm.length);
  1820. CheckBufferSize(len);
  1821. if (len == 0) {
  1822. m_netbuf[0] = '';
  1823. } else {
  1824. ReadString(m_netbuf, len);
  1825. }
  1826. UpdateLocalClipboard(m_netbuf, len);
  1827. }
  1830. void ClientConnection::ReadBell() {
  1831. rfbBellMsg bm;
  1832. ReadExact((char *) &bm, sz_rfbBellMsg);
  1834. #ifdef UNDER_CE
  1835. MessageBeep( MB_OK );
  1836. #else
  1838. if (! ::PlaySound("VNCViewerBell", NULL, 
  1839. SND_APPLICATION | SND_ALIAS | SND_NODEFAULT | SND_ASYNC) ) {
  1840. ::Beep(440, 125);
  1841. }
  1842. #endif
  1843. if (m_opts.m_DeiconifyOnBell) {
  1844. if (IsIconic(m_hwnd)) {
  1845. SetDormant(false);
  1846. ShowWindow(m_hwnd, SW_SHOWNORMAL);
  1847. }
  1848. }
  1849. log.Print(6, _T("Bell!n"));
  1850. }
  1853. // General utilities -------------------------------------------------
  1855. // Reads the number of bytes specified into the buffer given
  1857. inline void ClientConnection::ReadExact(char *inbuf, int wanted)
  1858. {
  1859. omni_mutex_lock l(m_readMutex);
  1860. // omni_mutex_lock l2(sockMutex);
  1861. int offset = 0;
  1862.     log.Print(10, _T("  reading %d bytesn"), wanted);
  1864. while (wanted > 0) {
  1866. int bytes = recv(m_sock, inbuf+offset, wanted, 0);
  1867. if (bytes == 0) throw WarningException("Connection closed.");
  1868. if (bytes == SOCKET_ERROR) {
  1869. int err = ::GetLastError();
  1870. log.Print(1, _T("Socket error while reading %dn"), err);
  1871. m_running = false;
  1872. throw WarningException("ReadExact: Socket error while reading.");
  1873. }
  1874. wanted -= bytes;
  1875. offset += bytes;
  1877. }
  1878. }
  1880. // Read the number of bytes and return them zero terminated in the buffer 
  1881. inline void ClientConnection::ReadString(char *buf, int length)
  1882. {
  1883. if (length > 0)
  1884. ReadExact(buf, length);
  1885. buf[length] = '';
  1886.     log.Print(10, _T("Read a %d-byte stringn"), length);
  1887. }
  1890. // Sends the number of bytes specified from the buffer
  1891. inline void ClientConnection::WriteExact(char *buf, int bytes)
  1892. {
  1893. if (bytes == 0) return;
  1895. omni_mutex_lock l(m_writeMutex);
  1896. log.Print(10, _T("  writing %d bytesn"), bytes);
  1898. int i = 0;
  1899.     int j;
  1901.     while (i < bytes) {
  1903. j = send(m_sock, buf+i, bytes-i, 0);
  1904. if (j == SOCKET_ERROR || j==0) {
  1905. int err = ::GetLastError();
  1906. log.Print(1, _T("Socket error %dn"), err);
  1907. m_running = false;
  1909. throw WarningException("WriteExact: Socket error while writing.");
  1910. }
  1911. i += j;
  1912.     }
  1913. }
  1915. // Makes sure netbuf is at least as big as the specified size.
  1916. // Note that netbuf itself may change as a result of this call.
  1917. // Throws an exception on failure.
  1918. inline void ClientConnection::CheckBufferSize(int bufsize)
  1919. {
  1920. if (m_netbufsize > bufsize) return;
  1922. omni_mutex_lock l(m_bufferMutex);
  1924. char *newbuf = new char[bufsize+256];;
  1925. if (newbuf == NULL) {
  1926. throw ErrorException("Insufficient memory to allocate network buffer.");
  1927. }
  1929. // Only if we're successful...
  1931. if (m_netbuf != NULL)
  1932. delete [] m_netbuf;
  1933. m_netbuf = newbuf;
  1934. m_netbufsize=bufsize + 256;
  1935. log.Print(4, _T("bufsize expanded to %dn"), m_netbufsize);
  1936. }