barrier/synergy/CClient.cpp

334 lines
7.5 KiB
C++
Raw Normal View History

2001-10-06 14:13:28 +00:00
#include "CClient.h"
#include "CInputPacketStream.h"
#include "COutputPacketStream.h"
#include "CProtocolUtil.h"
#include "ISecondaryScreen.h"
#include "ProtocolTypes.h"
#include "CThread.h"
2001-10-06 14:13:28 +00:00
#include "CTimerThread.h"
#include "XSynergy.h"
#include "TMethodJob.h"
#include "CLog.h"
#include <memory>
2001-10-06 14:13:28 +00:00
//
// CClient
//
CClient::CClient(const CString& clientName) :
m_name(clientName),
m_input(NULL),
m_output(NULL),
m_screen(NULL)
2001-10-06 14:13:28 +00:00
{
// do nothing
2001-10-06 14:13:28 +00:00
}
CClient::~CClient()
{
// do nothing
}
void CClient::run(const CNetworkAddress& serverAddress)
{
m_serverAddress = &serverAddress;
CThread thread(new TMethodJob<CClient>(this, &CClient::runSession));
thread.wait();
2001-10-06 14:13:28 +00:00
}
#include "CTCPSocket.h"
#include "CXWindowsSecondaryScreen.h"
void CClient::runSession(void*)
2001-10-06 14:13:28 +00:00
{
log((CLOG_DEBUG "starting client \"%s\"", m_name.c_str()));
2001-10-06 14:13:28 +00:00
std::auto_ptr<ISocket> socket;
std::auto_ptr<IInputStream> input;
std::auto_ptr<IOutputStream> output;
try {
// allow connect this much time to succeed
CTimerThread timer(30.0); // FIXME -- timeout in member
// create socket and attempt to connect to server
log((CLOG_DEBUG "connecting to server"));
2001-10-06 14:13:28 +00:00
socket.reset(new CTCPSocket()); // FIXME -- use factory
socket->connect(*m_serverAddress);
log((CLOG_INFO "connected to server"));
2001-10-06 14:13:28 +00:00
// get the input and output streams
IInputStream* srcInput = socket->getInputStream();
IOutputStream* srcOutput = socket->getOutputStream();
// attach the encryption layer
2001-10-21 00:21:21 +00:00
bool own = false;
2001-10-06 14:13:28 +00:00
/* FIXME -- implement ISecurityFactory
if (m_securityFactory != NULL) {
2001-10-21 00:21:21 +00:00
input.reset(m_securityFactory->createInputFilter(srcInput, own));
output.reset(m_securityFactory->createOutputFilter(srcOutput, own));
2001-10-06 14:13:28 +00:00
srcInput = input.get();
srcOutput = output.get();
2001-10-21 00:21:21 +00:00
own = true;
2001-10-06 14:13:28 +00:00
}
*/
// attach the packetizing filters
2001-10-21 00:21:21 +00:00
input.reset(new CInputPacketStream(srcInput, own));
output.reset(new COutputPacketStream(srcOutput, own));
2001-10-06 14:13:28 +00:00
// wait for hello from server
log((CLOG_DEBUG "wait for hello"));
2001-10-06 14:13:28 +00:00
SInt32 major, minor;
CProtocolUtil::readf(input.get(), "Synergy%2i%2i", &major, &minor);
// check versions
log((CLOG_DEBUG "got hello version %d.%d", major, minor));
2001-10-06 14:13:28 +00:00
if (major < kMajorVersion ||
(major == kMajorVersion && minor < kMinorVersion)) {
throw XIncompatibleClient(major, minor);
}
// say hello back
log((CLOG_DEBUG "say hello version %d.%d", kMajorVersion, kMinorVersion));
2001-10-06 14:13:28 +00:00
CProtocolUtil::writef(output.get(), "Synergy%2i%2i%s",
kMajorVersion, kMinorVersion,
m_name.size(), m_name.data());
// record streams in a more useful place
m_input = input.get();
m_output = output.get();
}
catch (XIncompatibleClient& e) {
log((CLOG_ERR "server has incompatible version %d.%d", e.getMajor(), e.getMinor()));
2001-10-06 14:13:28 +00:00
return;
}
catch (XThread&) {
log((CLOG_ERR "connection timed out"));
2001-10-06 14:13:28 +00:00
throw;
}
catch (XBase& e) {
log((CLOG_ERR "connection failed: %s", e.what()));
2001-10-06 14:13:28 +00:00
return;
}
// connect to screen
std::auto_ptr<CScreenCleaner> screenCleaner;
try {
log((CLOG_DEBUG "creating secondary screen"));
m_screen = new CXWindowsSecondaryScreen;
screenCleaner.reset(new CScreenCleaner(this, m_screen));
}
catch (XBase& e) {
log((CLOG_ERR "cannot open screen: %s", e.what()));
return;
}
2001-10-06 14:13:28 +00:00
try {
// handle messages from server
2001-10-06 14:13:28 +00:00
for (;;) {
// wait for reply
log((CLOG_DEBUG "waiting for message"));
2001-10-06 14:13:28 +00:00
UInt8 code[4];
UInt32 n = input->read(code, 4);
// verify we got an entire code
if (n == 0) {
log((CLOG_NOTE "server disconnected"));
2001-10-06 14:13:28 +00:00
// server hungup
break;
}
if (n != 4) {
// client sent an incomplete message
log((CLOG_ERR "incomplete message from server"));
2001-10-06 14:13:28 +00:00
break;
}
// parse message
log((CLOG_DEBUG "msg from server: %c%c%c%c", code[0], code[1], code[2], code[3]));
2001-10-06 14:13:28 +00:00
if (memcmp(code, kMsgDMouseMove, 4) == 0) {
onMouseMove();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgDMouseWheel, 4) == 0) {
onMouseWheel();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgDKeyDown, 4) == 0) {
onKeyDown();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgDKeyUp, 4) == 0) {
onKeyUp();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgDMouseDown, 4) == 0) {
onMouseDown();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgDMouseUp, 4) == 0) {
onMouseUp();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgDKeyRepeat, 4) == 0) {
onKeyRepeat();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgCEnter, 4) == 0) {
onEnter();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgCLeave, 4) == 0) {
onLeave();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgCClipboard, 4) == 0) {
onGrabClipboard();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgCScreenSaver, 4) == 0) {
onScreenSaver();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgQInfo, 4) == 0) {
onQueryInfo();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgQClipboard, 4) == 0) {
onQueryClipboard();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgDClipboard, 4) == 0) {
onSetClipboard();
2001-10-06 14:13:28 +00:00
}
else if (memcmp(code, kMsgCClose, 4) == 0) {
// server wants us to hangup
break;
}
else {
// unknown message
log((CLOG_ERR "unknown message from server"));
2001-10-06 14:13:28 +00:00
break;
}
}
}
catch (XBase& e) {
log((CLOG_ERR "error: %s", e.what()));
2001-10-06 14:13:28 +00:00
return;
}
// done with screen
log((CLOG_DEBUG "destroying secondary screen"));
screenCleaner.reset();
// done with socket
log((CLOG_DEBUG "disconnecting from server"));
socket->close();
2001-10-06 14:13:28 +00:00
}
void CClient::onEnter()
{
SInt32 x, y;
CProtocolUtil::readf(m_input, kMsgCEnter + 4, &x, &y);
m_screen->enter(x, y);
}
void CClient::onLeave()
{
m_screen->leave();
}
void CClient::onGrabClipboard()
{
// FIXME
}
void CClient::onScreenSaver()
{
SInt32 on;
CProtocolUtil::readf(m_input, kMsgCScreenSaver + 4, &on);
// FIXME
}
void CClient::onQueryInfo()
{
SInt32 w, h;
m_screen->getSize(&w, &h);
2001-10-06 14:13:28 +00:00
SInt32 zoneSize = m_screen->getJumpZoneSize();
log((CLOG_DEBUG "sending info size=%d,%d zone=%d", w, h, zoneSize));
2001-10-06 14:13:28 +00:00
CProtocolUtil::writef(m_output, kMsgDInfo, w, h, zoneSize);
}
void CClient::onQueryClipboard()
{
// FIXME
}
void CClient::onSetClipboard()
{
// FIXME
}
void CClient::onKeyDown()
{
SInt32 id, mask;
CProtocolUtil::readf(m_input, kMsgDKeyDown + 4, &id, &mask);
m_screen->onKeyDown(static_cast<KeyID>(id),
static_cast<KeyModifierMask>(mask));
2001-10-06 14:13:28 +00:00
}
void CClient::onKeyRepeat()
{
SInt32 id, mask, count;
CProtocolUtil::readf(m_input, kMsgDKeyRepeat + 4, &id, &mask, &count);
m_screen->onKeyRepeat(static_cast<KeyID>(id),
static_cast<KeyModifierMask>(mask),
2001-10-06 14:13:28 +00:00
count);
}
void CClient::onKeyUp()
{
SInt32 id, mask;
CProtocolUtil::readf(m_input, kMsgDKeyUp + 4, &id, &mask);
m_screen->onKeyUp(static_cast<KeyID>(id),
static_cast<KeyModifierMask>(mask));
2001-10-06 14:13:28 +00:00
}
void CClient::onMouseDown()
{
SInt32 id;
CProtocolUtil::readf(m_input, kMsgDMouseDown + 4, &id);
m_screen->onMouseDown(static_cast<ButtonID>(id));
2001-10-06 14:13:28 +00:00
}
void CClient::onMouseUp()
{
SInt32 id;
CProtocolUtil::readf(m_input, kMsgDMouseUp + 4, &id);
m_screen->onMouseUp(static_cast<ButtonID>(id));
2001-10-06 14:13:28 +00:00
}
void CClient::onMouseMove()
{
SInt32 x, y;
CProtocolUtil::readf(m_input, kMsgDMouseMove + 4, &x, &y);
m_screen->onMouseMove(x, y);
}
void CClient::onMouseWheel()
{
SInt32 delta;
CProtocolUtil::readf(m_input, kMsgDMouseWheel + 4, &delta);
m_screen->onMouseWheel(delta);
}
//
// CClient::CScreenCleaner
//
CClient::CScreenCleaner::CScreenCleaner(CClient* client,
ISecondaryScreen* screen) :
m_screen(screen)
{
assert(m_screen != NULL);
try {
m_screen->open(client);
}
catch (...) {
delete m_screen;
throw;
}
}
CClient::CScreenCleaner::~CScreenCleaner()
{
m_screen->close();
delete m_screen;
}