Remote control PC's across a LAN part 2

• Download vnc_src.zip-90.72KB

Introduction

Remote Control it's a client-server application which allow users to remotely control another computer. It transmits the keyboard and mouse events from one computer to another, relaying the graphical screen updates back in the other direction, over a network.

This article represent a better version of the application described in this article. The application architecture has been radically changed and the CPU and memory usage was considerable reduced.

This application was written in c++ and compiled using Microsoft Visual Studio. NET 2003 , 2005 and 2008.

As technology has been used MFC (Microsoft Foundation Classes), API (Application Programming Interface), ATL (Active Template Library), COM (Component Object Model), + GDI (Graphical Device Interface +) and STL (Standard Template Library).

How does it work?

When it is started the server application launch two threads . In the first thread the application wait potential clients which will connect on port 5001.

unsigned long __stdcall CServerApplication::AcceptClientThreadProc(void* lpParameter) { CServerApplication * pThis = (CServerApplication*) lpParameter; try { CComPtr<CSocket> serverSocket = new CSocket(pThis->GetServerPort()); while(1) { CSocket *clientSock = serverSocket->Accept(); if(clientSock && pThis) pThis->OnNewClient(clientSock , pThis->m_dwThreadID); } if(serverSocket) serverSocket->Close(); } catch(CSocketException e) { pThis->OnServerError(e.getText()); return 0; } return 1; }

Once connected each client runs in two new threads (one used to receive packages and one used to send packages). The server application has a "Client Manager" which retain a reference to each connected client.

The "Client Manager" is implemented in CClientsManager class.

class CClientsManager { public: CClientsManager(void); ~CClientsManager(void); DWORD AddClient(CThread * client); void RemoveClient(DWORD threadID); void RemoveAllClients(); DWORD GetClientsCount(); private: std::vector<CThread*>m_arrClients; CCriticalSection m_crtSection; };

This class has two private members . In m_arrClients container are retained references to each connected client . m_crtSection it's a CCriticalSection object used to synchronize the access of the class methods to m_arrClients container.

• DWORD AddClient(CThread * client) - Add a client in m_arrClients .
• void RemoveClient(DWORD threadID) - Remove the client with the specified thread id.
• void RemoveAllClients() - Remove all clients from the server
• DWORD GetClientsCount() - Return the connected clients count

In the other thread the server run a module which takes screen capture and save them in a memory share .From this memory share each connected client reads the images bytes which must be send over the network.

his module is implemented in CGrabSystemMessages class.

class CGrabSystemMessages { public: CGrabSystemMessages(void); ~CGrabSystemMessages(void); bool Init(); void GrabWindowFrame(); private: CComPtr<CIStreamImpl> stream ; CLSID jpgClsid; EncoderParameters encoderParameters; int nScreenWidth; int nScreenHeight; HWND hDesktopWnd; HDC hDesktopDC; HDC hCaptureDC; HBITMAP hCaptureBitmap; HANDLE hMapFile; BYTE * mappedBytes; HANDLE hEvent; private: inline int GetEncoderClsid(const WCHAR* format, CLSID* pClsid); inline Bitmap* ScaleImage(Bitmap *b ,int width , int height); };

• bool Init() - create the memory share and some events used to synchronize the read/write from/to memory share.
• void GrabWindowFrame() -Take a screenshot ,compress it in jpg and write it's bytes in the memory share.

As shown above each connected client runs in two separated threads which allow to send /receive messages in the same time.

The thread which is used for client authentication and for sending the screen capture is implemented in CClientThread . The thread used for receiving the mouse and keyboard events is implemented in CClientThreadReceiveCommand class.

lass CClientThread :public CThread { public: CClientThread(CSocket *socket, DWORD serverThreadID); ~CClientThread(void); #ifdef USE_AUTHENTIFICATION BOOL isAuthenticated(){return this->isAutentificatedUser;} BOOL waitingForAuthentification(); #endif protected: virtual bool InitInstance(); virtual void ExitInstance(); virtual void DoLoop(); virtual bool PreTranslateMessage(MSG *pMsg); private: DWORD m_dwParentThread; CComPtr<CSocket> socketClient; BYTE *ptrInternalBuffer; HANDLE hFileMapping; BYTE *pSharedBytes; HANDLE hEvent; CClientThreadReceiveCommand *m_pReceiveThread; bool isAutentificatedUser; };

The user authentication it's made in plain text . As you can observe the application can be compiled without authentication module . All you must to do is to comment the #define USE_AUTHENTIFICATION line from stdafx.h

The image transfer is implemented in DoLoop . This thread wait until the reading from memory share can be done safely and after that read the frame buffer length and copy the frame bytes into a temporary buffer. After all this operations the informations are send over the network . In case any transmission error occur the client is disconnected from the server.

WaitForSingleObject(hEvent,INFINITE); DWORD imageSize = *((DWORD*)(pSharedBytes)); memcpy(ptrInternalBuffer,pSharedBytes+sizeof(DWORD),imageSize); if(imageSize) { if(!OK_READ_WRITE(socketClient->Write(&imageSize,sizeof(DWORD)))) break; #if 0 printf("image size:%d\n",imageSize); #endif if(!OK_READ_WRITE(socketClient->Write(ptrInternalBuffer,imageSize))) break; }

The informations about keyboard and mouse events are stored in the following structure:

struct evMSG
{
	UINT uMsg;	 // WM_ mesaj
	WPARAM wParam;	 // key indicators
	LPARAM lParam ;  // horizontal and vertical position
};

class CClientThreadReceiveCommand : public CThread { public: CClientThreadReceiveCommand(CSocket * socket){this->m_pSocket = socket;}; ~CClientThreadReceiveCommand(void){}; protected: virtual bool InitInstance(); virtual void ExitInstance(); virtual void DoLoop(); private: inline float GetScaleCoeficient(int res1 , int res2); inline LPARAM recalculatePosition(LPARAM old); void LeftButtonDown(); void LeftButtonUp(); void RightButtonDown(); void RightButtonUp(); void LeftClick(); void MouseMove(LPARAM param ); void OnKeyDown(evMSG msg); void OnKeyUp(evMSG msg); private: CComPtr<CSocket> m_pSocket; HWND desktop; float scale_coef_x; float scale_coef_y; CSendKeys keysSender; };

VNC Viewer functionality

The viewer establish a connection to an address and port specified in "Options". When user press "Start" the application launch a new thread used to receive the screen captures from the server. The keyboard and mouse events are send in the main thread.

The keyboard and mouse events which are send to server are :

afx_msg void OnLButtonDown(UINT nFlags, CPoint point); afx_msg void OnMouseMove(UINT nFlags, CPoint point); afx_msg void OnRButtonDown(UINT nFlags, CPoint point); afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point); afx_msg void OnLButtonUp(UINT nFlags, CPoint point); afx_msg void OnRButtonUp(UINT nFlags, CPoint point); afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags); afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);

The viewer application support the following compiling feature:

• traffic optimizing by filtering of WM_MOUSEMOVE (OnMouseMove) , the most generated message.
• Add / remove authentication module
• changing of sending /receiving messages over network (byte by byte or using a temporary buffer)

License

This article, along with any associated source code and files, is licensed under The Intelliproject Open License (IPOL)

About the author