Checkpoint. Code does not run. Still converting over to new
event loop model. Streams, stream filters, and sockets are converted. Client proxies are almost converted. CServer is in progress. Removed all HTTP code. Haven't converted the necessary win32 arch stuff.
This commit is contained in:
parent
618aa7fedd
commit
848aee7a3a
|
@ -88,7 +88,6 @@ public:
|
||||||
const char* m_logFilter;
|
const char* m_logFilter;
|
||||||
CString m_name;
|
CString m_name;
|
||||||
CNetworkAddress m_synergyAddress;
|
CNetworkAddress m_synergyAddress;
|
||||||
CNetworkAddress m_httpAddress;
|
|
||||||
CConfig m_config;
|
CConfig m_config;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -191,11 +190,6 @@ realMain(void)
|
||||||
ARG->m_config.setSynergyAddress(CNetworkAddress(kDefaultPort));
|
ARG->m_config.setSynergyAddress(CNetworkAddress(kDefaultPort));
|
||||||
}
|
}
|
||||||
|
|
||||||
// set HTTP address if provided
|
|
||||||
if (ARG->m_httpAddress.isValid()) {
|
|
||||||
ARG->m_config.setHTTPAddress(ARG->m_httpAddress);
|
|
||||||
}
|
|
||||||
|
|
||||||
// create server
|
// create server
|
||||||
s_server = new CServer(ARG->m_name);
|
s_server = new CServer(ARG->m_name);
|
||||||
s_server->setConfig(ARG->m_config);
|
s_server->setConfig(ARG->m_config);
|
||||||
|
@ -454,20 +448,6 @@ parse(int argc, const char* const* argv)
|
||||||
++i;
|
++i;
|
||||||
}
|
}
|
||||||
|
|
||||||
else if (isArg(i, argc, argv, NULL, "--http", 1)) {
|
|
||||||
// save listen address
|
|
||||||
try {
|
|
||||||
ARG->m_httpAddress = CNetworkAddress(argv[i + 1],
|
|
||||||
kDefaultPort + 1);
|
|
||||||
}
|
|
||||||
catch (XSocketAddress& e) {
|
|
||||||
LOG((CLOG_PRINT "%s: %s" BYE,
|
|
||||||
ARG->m_pname, e.what(), ARG->m_pname));
|
|
||||||
bye(kExitArgs);
|
|
||||||
}
|
|
||||||
++i;
|
|
||||||
}
|
|
||||||
|
|
||||||
else if (isArg(i, argc, argv, "-n", "--name", 1)) {
|
else if (isArg(i, argc, argv, "-n", "--name", 1)) {
|
||||||
// save screen name
|
// save screen name
|
||||||
ARG->m_name = argv[++i];
|
ARG->m_name = argv[++i];
|
||||||
|
|
|
@ -387,6 +387,18 @@ CArch::getIDOfThread(CArchThread thread)
|
||||||
return m_mt->getIDOfThread(thread);
|
return m_mt->getIDOfThread(thread);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CArch::setInterruptHandler(InterruptFunc func, void* userData)
|
||||||
|
{
|
||||||
|
return m_mt->setInterruptHandler(func, userData);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CArch::interrupt()
|
||||||
|
{
|
||||||
|
return m_mt->interrupt();
|
||||||
|
}
|
||||||
|
|
||||||
CArchSocket
|
CArchSocket
|
||||||
CArch::newSocket(EAddressFamily family, ESocketType type)
|
CArch::newSocket(EAddressFamily family, ESocketType type)
|
||||||
{
|
{
|
||||||
|
|
|
@ -122,6 +122,8 @@ public:
|
||||||
virtual bool isExitedThread(CArchThread);
|
virtual bool isExitedThread(CArchThread);
|
||||||
virtual void* getResultOfThread(CArchThread);
|
virtual void* getResultOfThread(CArchThread);
|
||||||
virtual ThreadID getIDOfThread(CArchThread);
|
virtual ThreadID getIDOfThread(CArchThread);
|
||||||
|
virtual void setInterruptHandler(InterruptFunc, void*);
|
||||||
|
virtual void interrupt();
|
||||||
|
|
||||||
// IArchNetwork overrides
|
// IArchNetwork overrides
|
||||||
virtual CArchSocket newSocket(EAddressFamily, ESocketType);
|
virtual CArchSocket newSocket(EAddressFamily, ESocketType);
|
||||||
|
|
|
@ -83,7 +83,9 @@ CArchMultithreadPosix* CArchMultithreadPosix::s_instance = NULL;
|
||||||
|
|
||||||
CArchMultithreadPosix::CArchMultithreadPosix() :
|
CArchMultithreadPosix::CArchMultithreadPosix() :
|
||||||
m_newThreadCalled(false),
|
m_newThreadCalled(false),
|
||||||
m_nextID(0)
|
m_nextID(0),
|
||||||
|
m_signalFunc(NULL),
|
||||||
|
m_signalUserData(NULL)
|
||||||
{
|
{
|
||||||
assert(s_instance == NULL);
|
assert(s_instance == NULL);
|
||||||
|
|
||||||
|
@ -558,6 +560,28 @@ CArchMultithreadPosix::getIDOfThread(CArchThread thread)
|
||||||
return thread->m_id;
|
return thread->m_id;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CArchMultithreadPosix::setInterruptHandler(InterruptFunc func, void* userData)
|
||||||
|
{
|
||||||
|
lockMutex(m_threadMutex);
|
||||||
|
m_signalFunc = func;
|
||||||
|
m_signalUserData = userData;
|
||||||
|
unlockMutex(m_threadMutex);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CArchMultithreadPosix::interrupt()
|
||||||
|
{
|
||||||
|
lockMutex(m_threadMutex);
|
||||||
|
if (m_signalFunc != NULL) {
|
||||||
|
m_signalFunc(m_signalUserData);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
ARCH->cancelThread(m_mainThread);
|
||||||
|
}
|
||||||
|
unlockMutex(m_threadMutex);
|
||||||
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CArchMultithreadPosix::startSignalHandler()
|
CArchMultithreadPosix::startSignalHandler()
|
||||||
{
|
{
|
||||||
|
@ -578,7 +602,7 @@ CArchMultithreadPosix::startSignalHandler()
|
||||||
if (status == 0) {
|
if (status == 0) {
|
||||||
status = pthread_create(&m_signalThread, &attr,
|
status = pthread_create(&m_signalThread, &attr,
|
||||||
&CArchMultithreadPosix::threadSignalHandler,
|
&CArchMultithreadPosix::threadSignalHandler,
|
||||||
m_mainThread);
|
NULL);
|
||||||
pthread_attr_destroy(&attr);
|
pthread_attr_destroy(&attr);
|
||||||
}
|
}
|
||||||
if (status != 0) {
|
if (status != 0) {
|
||||||
|
@ -735,10 +759,8 @@ CArchMultithreadPosix::threadCancel(int)
|
||||||
}
|
}
|
||||||
|
|
||||||
void*
|
void*
|
||||||
CArchMultithreadPosix::threadSignalHandler(void* vrep)
|
CArchMultithreadPosix::threadSignalHandler(void*)
|
||||||
{
|
{
|
||||||
CArchThreadImpl* mainThread = reinterpret_cast<CArchThreadImpl*>(vrep);
|
|
||||||
|
|
||||||
// detach
|
// detach
|
||||||
pthread_detach(pthread_self());
|
pthread_detach(pthread_self());
|
||||||
|
|
||||||
|
@ -768,8 +790,7 @@ CArchMultithreadPosix::threadSignalHandler(void* vrep)
|
||||||
sigwait(&sigset);
|
sigwait(&sigset);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// if we get here then the signal was raised. cancel the main
|
// if we get here then the signal was raised
|
||||||
// thread so it can shut down cleanly.
|
ARCH->interrupt();
|
||||||
ARCH->cancelThread(mainThread);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -61,6 +61,8 @@ public:
|
||||||
virtual bool isExitedThread(CArchThread);
|
virtual bool isExitedThread(CArchThread);
|
||||||
virtual void* getResultOfThread(CArchThread);
|
virtual void* getResultOfThread(CArchThread);
|
||||||
virtual ThreadID getIDOfThread(CArchThread);
|
virtual ThreadID getIDOfThread(CArchThread);
|
||||||
|
virtual void setInterruptHandler(InterruptFunc, void*);
|
||||||
|
virtual void interrupt();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
void startSignalHandler();
|
void startSignalHandler();
|
||||||
|
@ -91,6 +93,8 @@ private:
|
||||||
ThreadID m_nextID;
|
ThreadID m_nextID;
|
||||||
|
|
||||||
pthread_t m_signalThread;
|
pthread_t m_signalThread;
|
||||||
|
InterruptFunc m_signalFunc;
|
||||||
|
void* m_signalUserData;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -437,6 +437,10 @@ CArchNetworkBSD::readSocket(CArchSocket s, void* buf, size_t len)
|
||||||
ARCH->testCancelThread();
|
ARCH->testCancelThread();
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
else if (errno == EAGAIN) {
|
||||||
|
n = 0;
|
||||||
|
break;
|
||||||
|
}
|
||||||
throwError(errno);
|
throwError(errno);
|
||||||
}
|
}
|
||||||
} while (false);
|
} while (false);
|
||||||
|
@ -458,6 +462,11 @@ CArchNetworkBSD::writeSocket(CArchSocket s, const void* buf, size_t len)
|
||||||
ARCH->testCancelThread();
|
ARCH->testCancelThread();
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
else if (errno == EAGAIN) {
|
||||||
|
// no buffer space
|
||||||
|
n = 0;
|
||||||
|
break;
|
||||||
|
}
|
||||||
throwError(errno);
|
throwError(errno);
|
||||||
}
|
}
|
||||||
} while (false);
|
} while (false);
|
||||||
|
@ -794,6 +803,8 @@ CArchNetworkBSD::throwError(int err)
|
||||||
throw XArchNetworkNotConnected(new XArchEvalUnix(err));
|
throw XArchNetworkNotConnected(new XArchEvalUnix(err));
|
||||||
|
|
||||||
case EPIPE:
|
case EPIPE:
|
||||||
|
throw XArchNetworkShutdown(new XArchEvalUnix(err));
|
||||||
|
|
||||||
case ECONNABORTED:
|
case ECONNABORTED:
|
||||||
case ECONNRESET:
|
case ECONNRESET:
|
||||||
throw XArchNetworkDisconnected(new XArchEvalUnix(err));
|
throw XArchNetworkDisconnected(new XArchEvalUnix(err));
|
||||||
|
|
|
@ -268,6 +268,18 @@ public:
|
||||||
*/
|
*/
|
||||||
virtual ThreadID getIDOfThread(CArchThread thread) = 0;
|
virtual ThreadID getIDOfThread(CArchThread thread) = 0;
|
||||||
|
|
||||||
|
//! Set the interrupt handler
|
||||||
|
/*!
|
||||||
|
Sets the function to call on receipt of an external interrupt.
|
||||||
|
By default and when \p func is NULL, the main thread is cancelled.
|
||||||
|
*/
|
||||||
|
typedef void (*InterruptFunc)(void*);
|
||||||
|
virtual void setInterruptHandler(InterruptFunc func,
|
||||||
|
void* userData) = 0;
|
||||||
|
|
||||||
|
//! Invoke the interrupt handler
|
||||||
|
virtual void interrupt() = 0;
|
||||||
|
|
||||||
//@}
|
//@}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
|
@ -89,7 +89,7 @@ library to indicate various errors.
|
||||||
*/
|
*/
|
||||||
XARCH_SUBCLASS(XArchNetwork, XArch);
|
XARCH_SUBCLASS(XArchNetwork, XArch);
|
||||||
|
|
||||||
//! Network insufficient permission
|
//! Operation would block
|
||||||
XARCH_SUBCLASS(XArchNetworkWouldBlock, XArchNetwork);
|
XARCH_SUBCLASS(XArchNetworkWouldBlock, XArchNetwork);
|
||||||
|
|
||||||
//! Network insufficient permission
|
//! Network insufficient permission
|
||||||
|
@ -116,6 +116,9 @@ XARCH_SUBCLASS(XArchNetworkNoRoute, XArchNetwork);
|
||||||
//! Socket not connected
|
//! Socket not connected
|
||||||
XARCH_SUBCLASS(XArchNetworkNotConnected, XArchNetwork);
|
XARCH_SUBCLASS(XArchNetworkNotConnected, XArchNetwork);
|
||||||
|
|
||||||
|
//! Remote read end of socket has closed
|
||||||
|
XARCH_SUBCLASS(XArchNetworkShutdown, XArchNetwork);
|
||||||
|
|
||||||
//! Remote end of socket has disconnected
|
//! Remote end of socket has disconnected
|
||||||
XARCH_SUBCLASS(XArchNetworkDisconnected, XArchNetwork);
|
XARCH_SUBCLASS(XArchNetworkDisconnected, XArchNetwork);
|
||||||
|
|
||||||
|
|
|
@ -16,37 +16,31 @@
|
||||||
#include "IEventJob.h"
|
#include "IEventJob.h"
|
||||||
#include "CArch.h"
|
#include "CArch.h"
|
||||||
|
|
||||||
|
// interrupt handler. this just adds a quit event to the queue.
|
||||||
|
static
|
||||||
|
void
|
||||||
|
interrupt(void*)
|
||||||
|
{
|
||||||
|
EVENTQUEUE->addEvent(CEvent(CEvent::kQuit));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
//
|
//
|
||||||
// CEventQueue
|
// CEventQueue
|
||||||
//
|
//
|
||||||
|
|
||||||
static int g_systemTarget = 0;
|
|
||||||
CEventQueue* CEventQueue::s_instance = NULL;
|
|
||||||
|
|
||||||
CEventQueue::CEventQueue()
|
CEventQueue::CEventQueue()
|
||||||
{
|
{
|
||||||
assert(s_instance == NULL);
|
setInstance(this);
|
||||||
s_instance = this;
|
|
||||||
m_mutex = ARCH->newMutex();
|
m_mutex = ARCH->newMutex();
|
||||||
|
ARCH->setInterruptHandler(&interrupt, NULL);
|
||||||
}
|
}
|
||||||
|
|
||||||
CEventQueue::~CEventQueue()
|
CEventQueue::~CEventQueue()
|
||||||
{
|
{
|
||||||
|
ARCH->setInterruptHandler(NULL, NULL);
|
||||||
ARCH->closeMutex(m_mutex);
|
ARCH->closeMutex(m_mutex);
|
||||||
s_instance = NULL;
|
setInstance(NULL);
|
||||||
}
|
|
||||||
|
|
||||||
void*
|
|
||||||
CEventQueue::getSystemTarget()
|
|
||||||
{
|
|
||||||
// any unique arbitrary pointer will do
|
|
||||||
return &g_systemTarget;
|
|
||||||
}
|
|
||||||
|
|
||||||
CEventQueue*
|
|
||||||
CEventQueue::getInstance()
|
|
||||||
{
|
|
||||||
return s_instance;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
bool
|
bool
|
||||||
|
@ -83,7 +77,7 @@ bool
|
||||||
CEventQueue::dispatchEvent(const CEvent& event)
|
CEventQueue::dispatchEvent(const CEvent& event)
|
||||||
{
|
{
|
||||||
void* target = event.getTarget();
|
void* target = event.getTarget();
|
||||||
IEventJob* job = getHandler(target);
|
IEventJob* job = getHandler(event.getType(), target);
|
||||||
if (job != NULL) {
|
if (job != NULL) {
|
||||||
job->run(event);
|
job->run(event);
|
||||||
return true;
|
return true;
|
||||||
|
@ -164,16 +158,56 @@ void
|
||||||
CEventQueue::adoptHandler(void* target, IEventJob* handler)
|
CEventQueue::adoptHandler(void* target, IEventJob* handler)
|
||||||
{
|
{
|
||||||
CArchMutexLock lock(m_mutex);
|
CArchMutexLock lock(m_mutex);
|
||||||
IEventJob*& job = m_handlers[target];
|
doAdoptHandler(CEvent::kUnknown, target, handler);
|
||||||
delete job;
|
}
|
||||||
job = handler;
|
|
||||||
|
void
|
||||||
|
CEventQueue::adoptHandler(CEvent::Type type, void* target, IEventJob* handler)
|
||||||
|
{
|
||||||
|
assert(type != CEvent::kUnknown);
|
||||||
|
CArchMutexLock lock(m_mutex);
|
||||||
|
doAdoptHandler(type, target, handler);
|
||||||
}
|
}
|
||||||
|
|
||||||
IEventJob*
|
IEventJob*
|
||||||
CEventQueue::orphanHandler(void* target)
|
CEventQueue::orphanHandler(void* target)
|
||||||
{
|
{
|
||||||
CArchMutexLock lock(m_mutex);
|
CArchMutexLock lock(m_mutex);
|
||||||
CHandlerTable::iterator index = m_handlers.find(target);
|
return doOrphanHandler(CEvent::kUnknown, target);
|
||||||
|
}
|
||||||
|
|
||||||
|
IEventJob*
|
||||||
|
CEventQueue::orphanHandler(CEvent::Type type, void* target)
|
||||||
|
{
|
||||||
|
assert(type != CEvent::kUnknown);
|
||||||
|
CArchMutexLock lock(m_mutex);
|
||||||
|
return doOrphanHandler(type, target);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CEventQueue::removeHandler(void* target)
|
||||||
|
{
|
||||||
|
delete orphanHandler(target);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CEventQueue::removeHandler(CEvent::Type type, void* target)
|
||||||
|
{
|
||||||
|
delete orphanHandler(type, target);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CEventQueue::doAdoptHandler(CEvent::Type type, void* target, IEventJob* handler)
|
||||||
|
{
|
||||||
|
IEventJob*& job = m_handlers[CTypeTarget(type, target)];
|
||||||
|
delete job;
|
||||||
|
job = handler;
|
||||||
|
}
|
||||||
|
|
||||||
|
IEventJob*
|
||||||
|
CEventQueue::doOrphanHandler(CEvent::Type type, void* target)
|
||||||
|
{
|
||||||
|
CHandlerTable::iterator index = m_handlers.find(CTypeTarget(type, target));
|
||||||
if (index != m_handlers.end()) {
|
if (index != m_handlers.end()) {
|
||||||
IEventJob* handler = index->second;
|
IEventJob* handler = index->second;
|
||||||
m_handlers.erase(index);
|
m_handlers.erase(index);
|
||||||
|
@ -191,16 +225,19 @@ CEventQueue::isEmpty() const
|
||||||
}
|
}
|
||||||
|
|
||||||
IEventJob*
|
IEventJob*
|
||||||
CEventQueue::getHandler(void* target) const
|
CEventQueue::getHandler(CEvent::Type type, void* target) const
|
||||||
{
|
{
|
||||||
CArchMutexLock lock(m_mutex);
|
CArchMutexLock lock(m_mutex);
|
||||||
CHandlerTable::const_iterator index = m_handlers.find(target);
|
CHandlerTable::const_iterator index =
|
||||||
|
m_handlers.find(CTypeTarget(type, target));
|
||||||
if (index != m_handlers.end()) {
|
if (index != m_handlers.end()) {
|
||||||
return index->second;
|
return index->second;
|
||||||
}
|
}
|
||||||
else {
|
index = m_handlers.find(CTypeTarget(CEvent::kUnknown, target));
|
||||||
return NULL;
|
if (index != m_handlers.end()) {
|
||||||
|
return index->second;
|
||||||
}
|
}
|
||||||
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
UInt32
|
UInt32
|
||||||
|
@ -217,7 +254,7 @@ CEventQueue::saveEvent(const CEvent& event)
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
// make a new id
|
// make a new id
|
||||||
id = static_cast<UInt32>(m_oldEventIDs.size());
|
id = static_cast<UInt32>(m_events.size());
|
||||||
}
|
}
|
||||||
|
|
||||||
// save data
|
// save data
|
||||||
|
@ -309,7 +346,31 @@ CEventQueue::getNextTimerTimeout() const
|
||||||
|
|
||||||
|
|
||||||
//
|
//
|
||||||
// CXWindowsScreen::CTimer
|
// CEventQueue::CTypeTarget
|
||||||
|
//
|
||||||
|
|
||||||
|
CEventQueue::CTypeTarget::CTypeTarget(CEvent::Type type, void* target) :
|
||||||
|
m_type(type),
|
||||||
|
m_target(target)
|
||||||
|
{
|
||||||
|
// do nothing
|
||||||
|
}
|
||||||
|
|
||||||
|
CEventQueue::CTypeTarget::~CTypeTarget()
|
||||||
|
{
|
||||||
|
// do nothing
|
||||||
|
}
|
||||||
|
|
||||||
|
bool
|
||||||
|
CEventQueue::CTypeTarget::operator<(const CTypeTarget& tt) const
|
||||||
|
{
|
||||||
|
return (m_type < tt.m_type ||
|
||||||
|
(m_type == tt.m_type && m_target < tt.m_target));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//
|
||||||
|
// CEventQueue::CTimer
|
||||||
//
|
//
|
||||||
|
|
||||||
CEventQueue::CTimer::CTimer(CEventQueueTimer* timer,
|
CEventQueue::CTimer::CTimer(CEventQueueTimer* timer,
|
||||||
|
|
|
@ -33,27 +33,6 @@ public:
|
||||||
CEventQueue();
|
CEventQueue();
|
||||||
virtual ~CEventQueue();
|
virtual ~CEventQueue();
|
||||||
|
|
||||||
//! @name manipulators
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//@}
|
|
||||||
//! @name accessors
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//! Get the system event type target
|
|
||||||
/*!
|
|
||||||
Returns the target to use for dispatching \c CEvent::kSystem events.
|
|
||||||
*/
|
|
||||||
static void* getSystemTarget();
|
|
||||||
|
|
||||||
//! Get the singleton instance
|
|
||||||
/*!
|
|
||||||
Returns the singleton instance of the event queue
|
|
||||||
*/
|
|
||||||
static CEventQueue* getInstance();
|
|
||||||
|
|
||||||
//@}
|
|
||||||
|
|
||||||
// IEventQueue overrides
|
// IEventQueue overrides
|
||||||
virtual bool getEvent(CEvent& event, double timeout = -1.0);
|
virtual bool getEvent(CEvent& event, double timeout = -1.0);
|
||||||
virtual bool dispatchEvent(const CEvent& event);
|
virtual bool dispatchEvent(const CEvent& event);
|
||||||
|
@ -64,9 +43,14 @@ public:
|
||||||
newOneShotTimer(double duration, void* target = NULL);
|
newOneShotTimer(double duration, void* target = NULL);
|
||||||
virtual void deleteTimer(CEventQueueTimer*);
|
virtual void deleteTimer(CEventQueueTimer*);
|
||||||
virtual void adoptHandler(void* target, IEventJob* dispatcher);
|
virtual void adoptHandler(void* target, IEventJob* dispatcher);
|
||||||
|
virtual void adoptHandler(CEvent::Type type,
|
||||||
|
void* target, IEventJob* handler);
|
||||||
virtual IEventJob* orphanHandler(void* target);
|
virtual IEventJob* orphanHandler(void* target);
|
||||||
|
virtual IEventJob* orphanHandler(CEvent::Type type, void* target);
|
||||||
|
virtual void removeHandler(void* target);
|
||||||
|
virtual void removeHandler(CEvent::Type type, void* target);
|
||||||
virtual bool isEmpty() const;
|
virtual bool isEmpty() const;
|
||||||
virtual IEventJob* getHandler(void* target) const;
|
virtual IEventJob* getHandler(CEvent::Type type, void* target) const;
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
//! @name manipulators
|
//! @name manipulators
|
||||||
|
@ -137,11 +121,26 @@ protected:
|
||||||
//@}
|
//@}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
|
void doAdoptHandler(CEvent::Type type,
|
||||||
|
void* target, IEventJob* handler);
|
||||||
|
IEventJob* doOrphanHandler(CEvent::Type type, void* target);
|
||||||
|
|
||||||
UInt32 saveEvent(const CEvent& event);
|
UInt32 saveEvent(const CEvent& event);
|
||||||
bool hasTimerExpired(CEvent& event);
|
bool hasTimerExpired(CEvent& event);
|
||||||
double getNextTimerTimeout() const;
|
double getNextTimerTimeout() const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
|
class CTypeTarget {
|
||||||
|
public:
|
||||||
|
CTypeTarget(CEvent::Type type, void* target);
|
||||||
|
~CTypeTarget();
|
||||||
|
|
||||||
|
bool operator<(const CTypeTarget&) const;
|
||||||
|
|
||||||
|
private:
|
||||||
|
CEvent::Type m_type;
|
||||||
|
void* m_target;
|
||||||
|
};
|
||||||
class CTimer {
|
class CTimer {
|
||||||
public:
|
public:
|
||||||
CTimer(CEventQueueTimer*, double timeout, void* target, bool oneShot);
|
CTimer(CEventQueueTimer*, double timeout, void* target, bool oneShot);
|
||||||
|
@ -172,9 +171,7 @@ private:
|
||||||
typedef CPriorityQueue<CTimer> CTimerQueue;
|
typedef CPriorityQueue<CTimer> CTimerQueue;
|
||||||
typedef std::map<UInt32, CEvent> CEventTable;
|
typedef std::map<UInt32, CEvent> CEventTable;
|
||||||
typedef std::vector<UInt32> CEventIDList;
|
typedef std::vector<UInt32> CEventIDList;
|
||||||
typedef std::map<void*, IEventJob*> CHandlerTable;
|
typedef std::map<CTypeTarget, IEventJob*> CHandlerTable;
|
||||||
|
|
||||||
static CEventQueue* s_instance;
|
|
||||||
|
|
||||||
CArchMutex m_mutex;
|
CArchMutex m_mutex;
|
||||||
|
|
||||||
|
|
|
@ -1,6 +1,6 @@
|
||||||
/*
|
/*
|
||||||
* synergy -- mouse and keyboard sharing utility
|
* synergy -- mouse and keyboard sharing utility
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
*
|
*
|
||||||
* This package is free software; you can redistribute it and/or
|
* This package is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU General Public License
|
* modify it under the terms of the GNU General Public License
|
||||||
|
@ -12,28 +12,32 @@
|
||||||
* GNU General Public License for more details.
|
* GNU General Public License for more details.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "CInputStreamFilter.h"
|
#include "IEventQueue.h"
|
||||||
|
|
||||||
//
|
//
|
||||||
// CInputStreamFilter
|
// IEventQueue
|
||||||
//
|
//
|
||||||
|
|
||||||
CInputStreamFilter::CInputStreamFilter(IInputStream* stream, bool adopted) :
|
static int g_systemTarget = 0;
|
||||||
m_stream(stream),
|
IEventQueue* IEventQueue::s_instance = NULL;
|
||||||
m_adopted(adopted)
|
|
||||||
|
void*
|
||||||
|
IEventQueue::getSystemTarget()
|
||||||
{
|
{
|
||||||
assert(m_stream != NULL);
|
// any unique arbitrary pointer will do
|
||||||
|
return &g_systemTarget;
|
||||||
}
|
}
|
||||||
|
|
||||||
CInputStreamFilter::~CInputStreamFilter()
|
IEventQueue*
|
||||||
|
IEventQueue::getInstance()
|
||||||
{
|
{
|
||||||
if (m_adopted) {
|
assert(s_instance != NULL);
|
||||||
delete m_stream;
|
return s_instance;
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
IInputStream*
|
void
|
||||||
CInputStreamFilter::getStream() const
|
IEventQueue::setInstance(IEventQueue* instance)
|
||||||
{
|
{
|
||||||
return m_stream;
|
assert(s_instance == NULL || instance == NULL);
|
||||||
|
s_instance = instance;
|
||||||
}
|
}
|
|
@ -16,9 +16,10 @@
|
||||||
#define IEVENTQUEUE_H
|
#define IEVENTQUEUE_H
|
||||||
|
|
||||||
#include "IInterface.h"
|
#include "IInterface.h"
|
||||||
#include "BasicTypes.h"
|
#include "CEvent.h"
|
||||||
|
|
||||||
|
#define EVENTQUEUE IEventQueue::getInstance()
|
||||||
|
|
||||||
class CEvent;
|
|
||||||
class IEventJob;
|
class IEventJob;
|
||||||
|
|
||||||
// Opaque type for timer info. This is defined by subclasses of
|
// Opaque type for timer info. This is defined by subclasses of
|
||||||
|
@ -107,9 +108,21 @@ public:
|
||||||
/*!
|
/*!
|
||||||
Registers an event handler for \p target. The \p handler is
|
Registers an event handler for \p target. The \p handler is
|
||||||
adopted. Any existing handler for the target is deleted.
|
adopted. Any existing handler for the target is deleted.
|
||||||
|
\c dispatchEvent() will invoke \p handler for any event for
|
||||||
|
\p target that doesn't have a type specific handler.
|
||||||
*/
|
*/
|
||||||
virtual void adoptHandler(void* target, IEventJob* handler) = 0;
|
virtual void adoptHandler(void* target, IEventJob* handler) = 0;
|
||||||
|
|
||||||
|
//! Register an event handler for an event type
|
||||||
|
/*!
|
||||||
|
Registers an event handler for \p type and \p target. The \p handler
|
||||||
|
is adopted. Any existing handler for the type,target pair is deleted.
|
||||||
|
\c dispatchEvent() will invoke \p handler for any event for \p target
|
||||||
|
of type \p type.
|
||||||
|
*/
|
||||||
|
virtual void adoptHandler(CEvent::Type type,
|
||||||
|
void* target, IEventJob* handler) = 0;
|
||||||
|
|
||||||
//! Unregister an event handler
|
//! Unregister an event handler
|
||||||
/*!
|
/*!
|
||||||
Unregisters an event handler for \p target and returns it.
|
Unregisters an event handler for \p target and returns it.
|
||||||
|
@ -118,6 +131,27 @@ public:
|
||||||
*/
|
*/
|
||||||
virtual IEventJob* orphanHandler(void* target) = 0;
|
virtual IEventJob* orphanHandler(void* target) = 0;
|
||||||
|
|
||||||
|
//! Unregister an event handler for an event type
|
||||||
|
/*!
|
||||||
|
Unregisters an event handler for the \p type, \p target pair and
|
||||||
|
returns it. Returns NULL if there was no such handler. The
|
||||||
|
client becomes responsible for deleting the returned handler.
|
||||||
|
*/
|
||||||
|
virtual IEventJob* orphanHandler(CEvent::Type type, void* target) = 0;
|
||||||
|
|
||||||
|
//! Unregister an event handler
|
||||||
|
/*!
|
||||||
|
Unregisters an event handler for \p target and deletes it.
|
||||||
|
*/
|
||||||
|
virtual void removeHandler(void* target) = 0;
|
||||||
|
|
||||||
|
//! Unregister an event handler for an event type
|
||||||
|
/*!
|
||||||
|
Unregisters an event handler for the \p type, \p target pair and
|
||||||
|
deletes it.
|
||||||
|
*/
|
||||||
|
virtual void removeHandler(CEvent::Type type, void* target) = 0;
|
||||||
|
|
||||||
//@}
|
//@}
|
||||||
//! @name accessors
|
//! @name accessors
|
||||||
//@{
|
//@{
|
||||||
|
@ -131,12 +165,40 @@ public:
|
||||||
|
|
||||||
//! Get an event handler
|
//! Get an event handler
|
||||||
/*!
|
/*!
|
||||||
Finds and returns the event handler for \p target, or NULL if
|
Finds and returns the event handler for the \p type, \p target pair.
|
||||||
there is no such handler.
|
If there is no such handler, returns the handler for \p target. If
|
||||||
|
that doesn't exist, returns NULL.
|
||||||
*/
|
*/
|
||||||
virtual IEventJob* getHandler(void* target) const = 0;
|
virtual IEventJob* getHandler(CEvent::Type type, void* target) const = 0;
|
||||||
|
|
||||||
|
//! Get the system event type target
|
||||||
|
/*!
|
||||||
|
Returns the target to use for dispatching \c CEvent::kSystem events.
|
||||||
|
*/
|
||||||
|
static void* getSystemTarget();
|
||||||
|
|
||||||
|
//! Get the singleton instance
|
||||||
|
/*!
|
||||||
|
Returns the singleton instance of the event queue
|
||||||
|
*/
|
||||||
|
static IEventQueue* getInstance();
|
||||||
|
|
||||||
//@}
|
//@}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
//! @name manipulators
|
||||||
|
//@{
|
||||||
|
|
||||||
|
//! Set the singleton instance
|
||||||
|
/*!
|
||||||
|
Sets the singleton instance of the event queue
|
||||||
|
*/
|
||||||
|
static void setInstance(IEventQueue*);
|
||||||
|
|
||||||
|
//@}
|
||||||
|
|
||||||
|
private:
|
||||||
|
static IEventQueue* s_instance;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -35,6 +35,7 @@ libbase_a_SOURCES = \
|
||||||
CStopwatch.cpp \
|
CStopwatch.cpp \
|
||||||
CStringUtil.cpp \
|
CStringUtil.cpp \
|
||||||
CUnicode.cpp \
|
CUnicode.cpp \
|
||||||
|
IEventQueue.cpp \
|
||||||
LogOutputters.cpp \
|
LogOutputters.cpp \
|
||||||
XBase.cpp \
|
XBase.cpp \
|
||||||
CEvent.h \
|
CEvent.h \
|
||||||
|
|
|
@ -1,140 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "CBufferedInputStream.h"
|
|
||||||
#include "CLock.h"
|
|
||||||
#include "CMutex.h"
|
|
||||||
#include "CThread.h"
|
|
||||||
#include "CStopwatch.h"
|
|
||||||
#include "IJob.h"
|
|
||||||
#include "XIO.h"
|
|
||||||
#include <cstring>
|
|
||||||
|
|
||||||
//
|
|
||||||
// CBufferedInputStream
|
|
||||||
//
|
|
||||||
|
|
||||||
CBufferedInputStream::CBufferedInputStream(
|
|
||||||
CMutex* mutex, IJob* adoptedEmptyCB, IJob* adoptedCloseCB) :
|
|
||||||
m_mutex(mutex),
|
|
||||||
m_empty(mutex, true),
|
|
||||||
m_emptyCB(adoptedEmptyCB),
|
|
||||||
m_closeCB(adoptedCloseCB),
|
|
||||||
m_closed(false),
|
|
||||||
m_hungup(false)
|
|
||||||
{
|
|
||||||
assert(m_mutex != NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
CBufferedInputStream::~CBufferedInputStream()
|
|
||||||
{
|
|
||||||
delete m_closeCB;
|
|
||||||
delete m_emptyCB;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CBufferedInputStream::write(const void* buffer, UInt32 n)
|
|
||||||
{
|
|
||||||
if (!m_hungup && n > 0) {
|
|
||||||
m_buffer.write(buffer, n);
|
|
||||||
m_empty = (m_buffer.getSize() == 0);
|
|
||||||
m_empty.broadcast();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CBufferedInputStream::hangup()
|
|
||||||
{
|
|
||||||
m_hungup = true;
|
|
||||||
m_empty.broadcast();
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
CBufferedInputStream::readNoLock(void* buffer, UInt32 n, double timeout)
|
|
||||||
{
|
|
||||||
if (m_closed) {
|
|
||||||
throw XIOClosed();
|
|
||||||
}
|
|
||||||
if (n == 0) {
|
|
||||||
return n;
|
|
||||||
}
|
|
||||||
|
|
||||||
// wait for data, hangup, or timeout
|
|
||||||
CStopwatch timer(true);
|
|
||||||
while (!m_hungup && m_empty == true) {
|
|
||||||
if (!m_empty.wait(timer, timeout)) {
|
|
||||||
// timed out
|
|
||||||
return (UInt32)-1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// read data
|
|
||||||
const UInt32 count = m_buffer.getSize();
|
|
||||||
if (n > count) {
|
|
||||||
n = count;
|
|
||||||
}
|
|
||||||
if (n > 0) {
|
|
||||||
if (buffer != NULL) {
|
|
||||||
memcpy(buffer, m_buffer.peek(n), n);
|
|
||||||
}
|
|
||||||
m_buffer.pop(n);
|
|
||||||
}
|
|
||||||
|
|
||||||
// update empty state
|
|
||||||
if (m_buffer.getSize() == 0) {
|
|
||||||
m_empty = true;
|
|
||||||
m_empty.broadcast();
|
|
||||||
if (m_emptyCB != NULL) {
|
|
||||||
m_emptyCB->run();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return n;
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
CBufferedInputStream::getSizeNoLock() const
|
|
||||||
{
|
|
||||||
return m_buffer.getSize();
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CBufferedInputStream::close()
|
|
||||||
{
|
|
||||||
CLock lock(m_mutex);
|
|
||||||
if (m_closed) {
|
|
||||||
throw XIOClosed();
|
|
||||||
}
|
|
||||||
|
|
||||||
m_closed = true;
|
|
||||||
m_hungup = true;
|
|
||||||
m_buffer.pop(m_buffer.getSize());
|
|
||||||
m_empty.broadcast();
|
|
||||||
if (m_closeCB != NULL) {
|
|
||||||
m_closeCB->run();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
CBufferedInputStream::read(void* buffer, UInt32 n, double timeout)
|
|
||||||
{
|
|
||||||
CLock lock(m_mutex);
|
|
||||||
return readNoLock(buffer, n, timeout);
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
CBufferedInputStream::getSize() const
|
|
||||||
{
|
|
||||||
CLock lock(m_mutex);
|
|
||||||
return getSizeNoLock();
|
|
||||||
}
|
|
|
@ -1,101 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef CBUFFEREDINPUTSTREAM_H
|
|
||||||
#define CBUFFEREDINPUTSTREAM_H
|
|
||||||
|
|
||||||
#include "IInputStream.h"
|
|
||||||
#include "CStreamBuffer.h"
|
|
||||||
#include "CCondVar.h"
|
|
||||||
|
|
||||||
class CMutex;
|
|
||||||
class IJob;
|
|
||||||
|
|
||||||
//! Memory buffer input stream
|
|
||||||
/*!
|
|
||||||
This class provides an input stream that reads from a memory buffer.
|
|
||||||
It also provides a means for the owner to ensure thread safe access.
|
|
||||||
Typically, an owner object will make this object visible to clients
|
|
||||||
that need access to an IInputStream while using the CBufferedInputStream
|
|
||||||
methods to write data to the stream.
|
|
||||||
*/
|
|
||||||
class CBufferedInputStream : public IInputStream {
|
|
||||||
public:
|
|
||||||
/*!
|
|
||||||
The \c mutex must not be NULL and will be used to ensure thread
|
|
||||||
safe access. If \c adoptedCloseCB is not NULL it will be called
|
|
||||||
when close() is called, allowing the creator to detect the close.
|
|
||||||
If adoptedEmptyCB is not NULL, it will be called whenever the
|
|
||||||
buffer becomes empty (except it won't be called by the c'tor nor
|
|
||||||
when the buffer is closed).
|
|
||||||
*/
|
|
||||||
CBufferedInputStream(CMutex* mutex,
|
|
||||||
IJob* adoptedEmptyCB, IJob* adoptedCloseCB);
|
|
||||||
~CBufferedInputStream();
|
|
||||||
|
|
||||||
//! @name manipulators
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//! Write data to stream
|
|
||||||
/*!
|
|
||||||
Write \c n bytes from \c buffer to the stream. The mutex must
|
|
||||||
be locked before calling this.
|
|
||||||
*/
|
|
||||||
void write(const void* buffer, UInt32 n);
|
|
||||||
|
|
||||||
//! Hangup stream
|
|
||||||
/*!
|
|
||||||
Causes read() to always return immediately. If there is no
|
|
||||||
more data to read then it returns 0. Further writes are discarded.
|
|
||||||
The mutex must be locked before calling this.
|
|
||||||
*/
|
|
||||||
void hangup();
|
|
||||||
|
|
||||||
//! Read from stream
|
|
||||||
/*!
|
|
||||||
This is the same as read() but the mutex must be locked before
|
|
||||||
calling this.
|
|
||||||
*/
|
|
||||||
UInt32 readNoLock(void*, UInt32 n, double timeout);
|
|
||||||
|
|
||||||
//@}
|
|
||||||
//! @name accessors
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//! Get remaining size of stream
|
|
||||||
/*!
|
|
||||||
This is the same as getSize() but the mutex must be locked before
|
|
||||||
calling this.
|
|
||||||
*/
|
|
||||||
UInt32 getSizeNoLock() const;
|
|
||||||
|
|
||||||
//@}
|
|
||||||
|
|
||||||
// IInputStream overrides
|
|
||||||
// these all lock the mutex for their duration
|
|
||||||
virtual void close();
|
|
||||||
virtual UInt32 read(void*, UInt32 n, double timeout);
|
|
||||||
virtual UInt32 getSize() const;
|
|
||||||
|
|
||||||
private:
|
|
||||||
CMutex* m_mutex;
|
|
||||||
CCondVar<bool> m_empty;
|
|
||||||
IJob* m_emptyCB;
|
|
||||||
IJob* m_closeCB;
|
|
||||||
CStreamBuffer m_buffer;
|
|
||||||
bool m_closed;
|
|
||||||
bool m_hungup;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,104 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "CBufferedOutputStream.h"
|
|
||||||
#include "XIO.h"
|
|
||||||
#include "CLock.h"
|
|
||||||
#include "CMutex.h"
|
|
||||||
#include "CThread.h"
|
|
||||||
#include "IJob.h"
|
|
||||||
|
|
||||||
//
|
|
||||||
// CBufferedOutputStream
|
|
||||||
//
|
|
||||||
|
|
||||||
CBufferedOutputStream::CBufferedOutputStream(
|
|
||||||
CMutex* mutex, IJob* adoptedFillCB, IJob* adoptedCloseCB) :
|
|
||||||
m_mutex(mutex),
|
|
||||||
m_fillCB(adoptedFillCB),
|
|
||||||
m_closeCB(adoptedCloseCB),
|
|
||||||
m_empty(mutex, true),
|
|
||||||
m_closed(false)
|
|
||||||
{
|
|
||||||
assert(m_mutex != NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
CBufferedOutputStream::~CBufferedOutputStream()
|
|
||||||
{
|
|
||||||
delete m_closeCB;
|
|
||||||
delete m_fillCB;
|
|
||||||
}
|
|
||||||
|
|
||||||
const void*
|
|
||||||
CBufferedOutputStream::peek(UInt32 n)
|
|
||||||
{
|
|
||||||
return m_buffer.peek(n);
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CBufferedOutputStream::pop(UInt32 n)
|
|
||||||
{
|
|
||||||
m_buffer.pop(n);
|
|
||||||
if (m_buffer.getSize() == 0) {
|
|
||||||
m_empty.broadcast();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
CBufferedOutputStream::getSize() const
|
|
||||||
{
|
|
||||||
return m_buffer.getSize();
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CBufferedOutputStream::close()
|
|
||||||
{
|
|
||||||
CLock lock(m_mutex);
|
|
||||||
if (m_closed) {
|
|
||||||
throw XIOClosed();
|
|
||||||
}
|
|
||||||
|
|
||||||
m_closed = true;
|
|
||||||
if (m_closeCB != NULL) {
|
|
||||||
m_closeCB->run();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
CBufferedOutputStream::write(const void* buffer, UInt32 n)
|
|
||||||
{
|
|
||||||
CLock lock(m_mutex);
|
|
||||||
if (m_closed) {
|
|
||||||
throw XIOClosed();
|
|
||||||
}
|
|
||||||
|
|
||||||
bool wasEmpty = (m_buffer.getSize() == 0);
|
|
||||||
m_buffer.write(buffer, n);
|
|
||||||
if (wasEmpty && n > 0) {
|
|
||||||
if (m_fillCB != NULL) {
|
|
||||||
m_fillCB->run();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return n;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CBufferedOutputStream::flush()
|
|
||||||
{
|
|
||||||
// wait until all data is written
|
|
||||||
CLock lock(m_mutex);
|
|
||||||
while (m_buffer.getSize() > 0) {
|
|
||||||
m_empty.wait();
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,92 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef CBUFFEREDOUTPUTSTREAM_H
|
|
||||||
#define CBUFFEREDOUTPUTSTREAM_H
|
|
||||||
|
|
||||||
#include "IOutputStream.h"
|
|
||||||
#include "CStreamBuffer.h"
|
|
||||||
#include "CCondVar.h"
|
|
||||||
|
|
||||||
class CMutex;
|
|
||||||
class IJob;
|
|
||||||
|
|
||||||
//! Memory buffer output stream
|
|
||||||
/*!
|
|
||||||
This class provides an output stream that writes to a memory buffer.
|
|
||||||
It also provides a means for the owner to ensure thread safe access.
|
|
||||||
Typically, an owner object will make this object visible to clients
|
|
||||||
that need access to an IOutputStream while using the CBufferedOutputStream
|
|
||||||
methods to read the data written to the stream.
|
|
||||||
*/
|
|
||||||
class CBufferedOutputStream : public IOutputStream {
|
|
||||||
public:
|
|
||||||
/*!
|
|
||||||
The \c mutex must not be NULL and will be used to ensure thread
|
|
||||||
safe access. If \c adoptedCloseCB is not NULL it will be called
|
|
||||||
when close() is called, allowing the creator to detect the close.
|
|
||||||
If \c adoptedFillCB is not NULL, it will be called whenever the
|
|
||||||
buffer becomes non-empty.
|
|
||||||
*/
|
|
||||||
CBufferedOutputStream(CMutex* mutex,
|
|
||||||
IJob* adoptedFillCB, IJob* adoptedCloseCB);
|
|
||||||
~CBufferedOutputStream();
|
|
||||||
|
|
||||||
//! @name manipulators
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//! Read data without removing from buffer
|
|
||||||
/*!
|
|
||||||
Returns a buffer of \c n bytes (which must be <= getSize()). The
|
|
||||||
caller must not modify the buffer nor delete it. The mutex must
|
|
||||||
be locked before calling this.
|
|
||||||
*/
|
|
||||||
const void* peek(UInt32 n);
|
|
||||||
|
|
||||||
//! Discard data
|
|
||||||
/*!
|
|
||||||
Discards the next \c n bytes. If \c n >= getSize() then the buffer
|
|
||||||
is cleared. The mutex must be locked before calling this.
|
|
||||||
*/
|
|
||||||
void pop(UInt32 n);
|
|
||||||
|
|
||||||
//@}
|
|
||||||
//! @name accessors
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//! Get size of buffer
|
|
||||||
/*!
|
|
||||||
Returns the number of bytes in the buffer. The mutex must be locked
|
|
||||||
before calling this.
|
|
||||||
*/
|
|
||||||
UInt32 getSize() const;
|
|
||||||
|
|
||||||
//@}
|
|
||||||
|
|
||||||
// IOutputStream overrides
|
|
||||||
// these all lock the mutex for their duration
|
|
||||||
virtual void close();
|
|
||||||
virtual UInt32 write(const void*, UInt32 n);
|
|
||||||
virtual void flush();
|
|
||||||
|
|
||||||
private:
|
|
||||||
CMutex* m_mutex;
|
|
||||||
IJob* m_fillCB;
|
|
||||||
IJob* m_closeCB;
|
|
||||||
CCondVar<bool> m_empty;
|
|
||||||
CStreamBuffer m_buffer;
|
|
||||||
bool m_closed;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,52 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef CINPUTSTREAMFILTER_H
|
|
||||||
#define CINPUTSTREAMFILTER_H
|
|
||||||
|
|
||||||
#include "IInputStream.h"
|
|
||||||
|
|
||||||
//! A filtering input stream
|
|
||||||
/*!
|
|
||||||
This class wraps an input stream. Subclasses provide indirect access
|
|
||||||
to the stream, typically performing some filtering.
|
|
||||||
*/
|
|
||||||
class CInputStreamFilter : public IInputStream {
|
|
||||||
public:
|
|
||||||
/*!
|
|
||||||
Create a wrapper around \c stream. Iff \c adoptStream is true then
|
|
||||||
this object takes ownership of the stream and will delete it in the
|
|
||||||
d'tor.
|
|
||||||
*/
|
|
||||||
CInputStreamFilter(IInputStream* stream, bool adoptStream = true);
|
|
||||||
~CInputStreamFilter();
|
|
||||||
|
|
||||||
// IInputStream overrides
|
|
||||||
virtual void close() = 0;
|
|
||||||
virtual UInt32 read(void*, UInt32 n, double timeout) = 0;
|
|
||||||
virtual UInt32 getSize() const = 0;
|
|
||||||
|
|
||||||
protected:
|
|
||||||
//! Get the stream
|
|
||||||
/*!
|
|
||||||
Returns the stream passed to the c'tor.
|
|
||||||
*/
|
|
||||||
IInputStream* getStream() const;
|
|
||||||
|
|
||||||
private:
|
|
||||||
IInputStream* m_stream;
|
|
||||||
bool m_adopted;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,39 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "COutputStreamFilter.h"
|
|
||||||
|
|
||||||
//
|
|
||||||
// COutputStreamFilter
|
|
||||||
//
|
|
||||||
|
|
||||||
COutputStreamFilter::COutputStreamFilter(IOutputStream* stream, bool adopted) :
|
|
||||||
m_stream(stream),
|
|
||||||
m_adopted(adopted)
|
|
||||||
{
|
|
||||||
assert(m_stream != NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
COutputStreamFilter::~COutputStreamFilter()
|
|
||||||
{
|
|
||||||
if (m_adopted) {
|
|
||||||
delete m_stream;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
IOutputStream*
|
|
||||||
COutputStreamFilter::getStream() const
|
|
||||||
{
|
|
||||||
return m_stream;
|
|
||||||
}
|
|
|
@ -1,52 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef COUTPUTSTREAMFILTER_H
|
|
||||||
#define COUTPUTSTREAMFILTER_H
|
|
||||||
|
|
||||||
#include "IOutputStream.h"
|
|
||||||
|
|
||||||
//! A filtering output stream
|
|
||||||
/*!
|
|
||||||
This class wraps an output stream. Subclasses provide indirect access
|
|
||||||
to the stream, typically performing some filtering.
|
|
||||||
*/
|
|
||||||
class COutputStreamFilter : public IOutputStream {
|
|
||||||
public:
|
|
||||||
/*!
|
|
||||||
Create a wrapper around \c stream. Iff \c adoptStream is true then
|
|
||||||
this object takes ownership of the stream and will delete it in the
|
|
||||||
d'tor.
|
|
||||||
*/
|
|
||||||
COutputStreamFilter(IOutputStream* stream, bool adoptStream = true);
|
|
||||||
~COutputStreamFilter();
|
|
||||||
|
|
||||||
// IOutputStream overrides
|
|
||||||
virtual void close() = 0;
|
|
||||||
virtual UInt32 write(const void*, UInt32 count) = 0;
|
|
||||||
virtual void flush() = 0;
|
|
||||||
|
|
||||||
protected:
|
|
||||||
//! Get the stream
|
|
||||||
/*!
|
|
||||||
Returns the stream passed to the c'tor.
|
|
||||||
*/
|
|
||||||
IOutputStream* getStream() const;
|
|
||||||
|
|
||||||
private:
|
|
||||||
IOutputStream* m_stream;
|
|
||||||
bool m_adopted;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -0,0 +1,105 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "CStreamFilter.h"
|
||||||
|
|
||||||
|
//
|
||||||
|
// CStreamFilter
|
||||||
|
//
|
||||||
|
|
||||||
|
CStreamFilter::CStreamFilter(IStream* stream, bool adoptStream) :
|
||||||
|
m_stream(stream),
|
||||||
|
m_adopted(adoptStream)
|
||||||
|
{
|
||||||
|
// do nothing
|
||||||
|
}
|
||||||
|
|
||||||
|
CStreamFilter::~CStreamFilter()
|
||||||
|
{
|
||||||
|
if (m_adopted) {
|
||||||
|
delete m_stream;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CStreamFilter::close()
|
||||||
|
{
|
||||||
|
getStream()->close();
|
||||||
|
}
|
||||||
|
|
||||||
|
UInt32
|
||||||
|
CStreamFilter::read(void* buffer, UInt32 n)
|
||||||
|
{
|
||||||
|
return getStream()->read(buffer, n);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CStreamFilter::write(const void* buffer, UInt32 n)
|
||||||
|
{
|
||||||
|
getStream()->write(buffer, n);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CStreamFilter::flush()
|
||||||
|
{
|
||||||
|
getStream()->flush();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CStreamFilter::shutdownInput()
|
||||||
|
{
|
||||||
|
getStream()->shutdownInput();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CStreamFilter::shutdownOutput()
|
||||||
|
{
|
||||||
|
getStream()->shutdownOutput();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CStreamFilter::setEventFilter(IEventJob* filter)
|
||||||
|
{
|
||||||
|
getStream()->setEventFilter(filter);
|
||||||
|
}
|
||||||
|
|
||||||
|
void*
|
||||||
|
CStreamFilter::getEventTarget() const
|
||||||
|
{
|
||||||
|
return const_cast<void*>(reinterpret_cast<const void*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
bool
|
||||||
|
CStreamFilter::isReady() const
|
||||||
|
{
|
||||||
|
return getStream()->isReady();
|
||||||
|
}
|
||||||
|
|
||||||
|
UInt32
|
||||||
|
CStreamFilter::getSize() const
|
||||||
|
{
|
||||||
|
return getStream()->getSize();
|
||||||
|
}
|
||||||
|
|
||||||
|
IEventJob*
|
||||||
|
CStreamFilter::getEventFilter() const
|
||||||
|
{
|
||||||
|
return getStream()->getEventFilter();
|
||||||
|
}
|
||||||
|
|
||||||
|
IStream*
|
||||||
|
CStreamFilter::getStream() const
|
||||||
|
{
|
||||||
|
return m_stream;
|
||||||
|
}
|
|
@ -0,0 +1,62 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CSTREAMFILTER_H
|
||||||
|
#define CSTREAMFILTER_H
|
||||||
|
|
||||||
|
#include "IStream.h"
|
||||||
|
|
||||||
|
//! A stream filter
|
||||||
|
/*!
|
||||||
|
This class wraps a stream. Subclasses provide indirect access
|
||||||
|
to the wrapped stream, typically performing some filtering.
|
||||||
|
*/
|
||||||
|
class CStreamFilter : public IStream {
|
||||||
|
public:
|
||||||
|
/*!
|
||||||
|
Create a wrapper around \c stream. Iff \c adoptStream is true then
|
||||||
|
this object takes ownership of the stream and will delete it in the
|
||||||
|
d'tor.
|
||||||
|
*/
|
||||||
|
CStreamFilter(IStream* stream, bool adoptStream = true);
|
||||||
|
~CStreamFilter();
|
||||||
|
|
||||||
|
// IStream overrides
|
||||||
|
// These all just forward to the underlying stream. Override as
|
||||||
|
// necessary.
|
||||||
|
virtual void close();
|
||||||
|
virtual UInt32 read(void* buffer, UInt32 n);
|
||||||
|
virtual void write(const void* buffer, UInt32 n);
|
||||||
|
virtual void flush();
|
||||||
|
virtual void shutdownInput();
|
||||||
|
virtual void shutdownOutput();
|
||||||
|
virtual void setEventFilter(IEventJob* filter);
|
||||||
|
virtual void* getEventTarget() const;
|
||||||
|
virtual bool isReady() const;
|
||||||
|
virtual UInt32 getSize() const;
|
||||||
|
virtual IEventJob* getEventFilter() const;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
//! Get the stream
|
||||||
|
/*!
|
||||||
|
Returns the stream passed to the c'tor.
|
||||||
|
*/
|
||||||
|
IStream* getStream() const;
|
||||||
|
|
||||||
|
private:
|
||||||
|
IStream* m_stream;
|
||||||
|
bool m_adopted;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif
|
|
@ -1,67 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef IINPUTSTREAM_H
|
|
||||||
#define IINPUTSTREAM_H
|
|
||||||
|
|
||||||
#include "IInterface.h"
|
|
||||||
#include "BasicTypes.h"
|
|
||||||
|
|
||||||
//! Input stream interface
|
|
||||||
/*!
|
|
||||||
Defines the interface for all input streams.
|
|
||||||
*/
|
|
||||||
class IInputStream : public IInterface {
|
|
||||||
public:
|
|
||||||
//! @name manipulators
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//! Close the stream
|
|
||||||
/*!
|
|
||||||
Closes the stream. Attempting to read() after close() throws
|
|
||||||
XIOClosed and getSize() always returns zero.
|
|
||||||
*/
|
|
||||||
virtual void close() = 0;
|
|
||||||
|
|
||||||
//! Read from stream
|
|
||||||
/*!
|
|
||||||
Read up to \c n bytes into buffer, returning the number read.
|
|
||||||
Blocks for up to \c timeout seconds if no data is available but does
|
|
||||||
not wait if any data is available, even if less than \c n bytes.
|
|
||||||
If \c timeout < 0 then it blocks indefinitely until data is available.
|
|
||||||
If \c buffer is NULL then the data is discarded. Returns (UInt32)-1 if
|
|
||||||
it times out and 0 if no data is available and the other end of the
|
|
||||||
stream has hungup.
|
|
||||||
|
|
||||||
(cancellation point)
|
|
||||||
*/
|
|
||||||
virtual UInt32 read(void* buffer, UInt32 n, double timeout) = 0;
|
|
||||||
|
|
||||||
//@}
|
|
||||||
//! @name accessors
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//! Get remaining size of stream
|
|
||||||
/*!
|
|
||||||
Returns a conservative estimate of the available bytes to read
|
|
||||||
(i.e. a number not greater than the actual number of bytes).
|
|
||||||
Some streams may not be able to determine this and will always
|
|
||||||
return zero.
|
|
||||||
*/
|
|
||||||
virtual UInt32 getSize() const = 0;
|
|
||||||
|
|
||||||
//@}
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,58 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef IOUTPUTSTREAM_H
|
|
||||||
#define IOUTPUTSTREAM_H
|
|
||||||
|
|
||||||
#include "IInterface.h"
|
|
||||||
#include "BasicTypes.h"
|
|
||||||
|
|
||||||
//! Output stream interface
|
|
||||||
/*!
|
|
||||||
Defines the interface for all output streams.
|
|
||||||
*/
|
|
||||||
class IOutputStream : public IInterface {
|
|
||||||
public:
|
|
||||||
//! @name manipulators
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//! Close the stream
|
|
||||||
/*!
|
|
||||||
Closes the stream. Attempting to write() after close() throws
|
|
||||||
XIOClosed.
|
|
||||||
*/
|
|
||||||
virtual void close() = 0;
|
|
||||||
|
|
||||||
//! Write to stream
|
|
||||||
/*!
|
|
||||||
Write \c n bytes from \c buffer to the stream. If this can't
|
|
||||||
complete immeditely it will block. If cancelled, an indeterminate
|
|
||||||
amount of data may have been written.
|
|
||||||
|
|
||||||
(cancellation point)
|
|
||||||
*/
|
|
||||||
virtual UInt32 write(const void* buffer, UInt32 n) = 0;
|
|
||||||
|
|
||||||
//! Flush the stream
|
|
||||||
/*!
|
|
||||||
Waits until all buffered data has been written to the stream.
|
|
||||||
|
|
||||||
(cancellation point)
|
|
||||||
*/
|
|
||||||
virtual void flush() = 0;
|
|
||||||
|
|
||||||
//@}
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -0,0 +1,55 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "IStream.h"
|
||||||
|
|
||||||
|
//
|
||||||
|
// IStream
|
||||||
|
//
|
||||||
|
|
||||||
|
CEvent::Type IStream::s_inputReadyEvent = CEvent::kUnknown;
|
||||||
|
CEvent::Type IStream::s_outputFlushedEvent = CEvent::kUnknown;
|
||||||
|
CEvent::Type IStream::s_outputErrorEvent = CEvent::kUnknown;
|
||||||
|
CEvent::Type IStream::s_inputShutdownEvent = CEvent::kUnknown;
|
||||||
|
CEvent::Type IStream::s_outputShutdownEvent = CEvent::kUnknown;
|
||||||
|
|
||||||
|
CEvent::Type
|
||||||
|
IStream::getInputReadyEvent()
|
||||||
|
{
|
||||||
|
return CEvent::registerTypeOnce(s_inputReadyEvent);
|
||||||
|
}
|
||||||
|
|
||||||
|
CEvent::Type
|
||||||
|
IStream::getOutputFlushedEvent()
|
||||||
|
{
|
||||||
|
return CEvent::registerTypeOnce(s_outputFlushedEvent);
|
||||||
|
}
|
||||||
|
|
||||||
|
CEvent::Type
|
||||||
|
IStream::getOutputErrorEvent()
|
||||||
|
{
|
||||||
|
return CEvent::registerTypeOnce(s_outputErrorEvent);
|
||||||
|
}
|
||||||
|
|
||||||
|
CEvent::Type
|
||||||
|
IStream::getInputShutdownEvent()
|
||||||
|
{
|
||||||
|
return CEvent::registerTypeOnce(s_inputShutdownEvent);
|
||||||
|
}
|
||||||
|
|
||||||
|
CEvent::Type
|
||||||
|
IStream::getOutputShutdownEvent()
|
||||||
|
{
|
||||||
|
return CEvent::registerTypeOnce(s_outputShutdownEvent);
|
||||||
|
}
|
|
@ -0,0 +1,175 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef ISTREAM_H
|
||||||
|
#define ISTREAM_H
|
||||||
|
|
||||||
|
#include "IInterface.h"
|
||||||
|
#include "CEvent.h"
|
||||||
|
|
||||||
|
class IEventJob;
|
||||||
|
|
||||||
|
//! Bidirectional stream interface
|
||||||
|
/*!
|
||||||
|
Defines the interface for all streams.
|
||||||
|
*/
|
||||||
|
class IStream : public IInterface {
|
||||||
|
public:
|
||||||
|
//! @name manipulators
|
||||||
|
//@{
|
||||||
|
|
||||||
|
//! Close the stream
|
||||||
|
/*!
|
||||||
|
Closes the stream. Pending input data and buffered output data
|
||||||
|
are discarded. Use \c flush() before \c close() to send buffered
|
||||||
|
output data. Attempts to \c read() after a close return 0,
|
||||||
|
attempts to \c write() generate output error events, and attempts
|
||||||
|
to \c flush() return immediately.
|
||||||
|
*/
|
||||||
|
virtual void close() = 0;
|
||||||
|
|
||||||
|
//! Read from stream
|
||||||
|
/*!
|
||||||
|
Read up to \p n bytes into \p buffer, returning the number read
|
||||||
|
(zero if no data is available or input is shutdown). \p buffer
|
||||||
|
may be NULL in which case the data is discarded.
|
||||||
|
*/
|
||||||
|
virtual UInt32 read(void* buffer, UInt32 n) = 0;
|
||||||
|
|
||||||
|
//! Write to stream
|
||||||
|
/*!
|
||||||
|
Write \c n bytes from \c buffer to the stream. If this can't
|
||||||
|
complete immediately it will block. Data may be buffered in
|
||||||
|
order to return more quickly. A output error event is generated
|
||||||
|
when writing fails.
|
||||||
|
*/
|
||||||
|
virtual void write(const void* buffer, UInt32 n) = 0;
|
||||||
|
|
||||||
|
//! Flush the stream
|
||||||
|
/*!
|
||||||
|
Waits until all buffered data has been written to the stream.
|
||||||
|
*/
|
||||||
|
virtual void flush() = 0;
|
||||||
|
|
||||||
|
//! Shutdown input
|
||||||
|
/*!
|
||||||
|
Shutdown the input side of the stream. Any pending input data is
|
||||||
|
discarded and further reads immediately return 0.
|
||||||
|
*/
|
||||||
|
virtual void shutdownInput() = 0;
|
||||||
|
|
||||||
|
//! Shutdown output
|
||||||
|
/*!
|
||||||
|
Shutdown the output side of the stream. Any buffered output data
|
||||||
|
is discarded and further writes generate output error events. Use
|
||||||
|
\c flush() before \c shutdownOutput() to send buffered output data.
|
||||||
|
*/
|
||||||
|
virtual void shutdownOutput() = 0;
|
||||||
|
|
||||||
|
//! Set the event filter
|
||||||
|
/*!
|
||||||
|
If not NULL, the \p filter is passed any event that would've been
|
||||||
|
added to the queue. The filter can discard the event, modify it
|
||||||
|
and add it to the queue, and add other events. The default filter
|
||||||
|
is NULL. The caller retains ownership of the filter.
|
||||||
|
*/
|
||||||
|
virtual void setEventFilter(IEventJob* filter) = 0;
|
||||||
|
|
||||||
|
//@}
|
||||||
|
|
||||||
|
//@}
|
||||||
|
//! @name accessors
|
||||||
|
//@{
|
||||||
|
|
||||||
|
//! Get event target
|
||||||
|
/*!
|
||||||
|
Returns the event target for events generated by this stream.
|
||||||
|
*/
|
||||||
|
virtual void* getEventTarget() const = 0;
|
||||||
|
|
||||||
|
//! Test if \c read() will succeed
|
||||||
|
/*!
|
||||||
|
Returns true iff an immediate \c read() will return data. This
|
||||||
|
may or may not be the same as \c getSize() > 0, depending on the
|
||||||
|
stream type.
|
||||||
|
*/
|
||||||
|
virtual bool isReady() const = 0;
|
||||||
|
|
||||||
|
//! Get bytes available to read
|
||||||
|
/*!
|
||||||
|
Returns a conservative estimate of the available bytes to read
|
||||||
|
(i.e. a number not greater than the actual number of bytes).
|
||||||
|
Some streams may not be able to determine this and will always
|
||||||
|
return zero.
|
||||||
|
*/
|
||||||
|
virtual UInt32 getSize() const = 0;
|
||||||
|
|
||||||
|
//! Get the event filter
|
||||||
|
/*!
|
||||||
|
Returns the current event filter.
|
||||||
|
*/
|
||||||
|
virtual IEventJob* getEventFilter() const = 0;
|
||||||
|
|
||||||
|
//! Get input ready event type
|
||||||
|
/*!
|
||||||
|
Returns the input ready event type. A stream sends this event
|
||||||
|
when \c read() will return with data.
|
||||||
|
*/
|
||||||
|
static CEvent::Type getInputReadyEvent();
|
||||||
|
|
||||||
|
//! Get output flushed event type
|
||||||
|
/*!
|
||||||
|
Returns the output flushed event type. A stream sends this event
|
||||||
|
when the output buffer has been flushed. If there have been no
|
||||||
|
writes since the event was posted, calling \c shutdownOutput() or
|
||||||
|
\c close() will not discard any data and \c flush() will return
|
||||||
|
immediately.
|
||||||
|
*/
|
||||||
|
static CEvent::Type getOutputFlushedEvent();
|
||||||
|
|
||||||
|
//! Get output error event type
|
||||||
|
/*!
|
||||||
|
Returns the output error event type. A stream sends this event
|
||||||
|
when a write has failed.
|
||||||
|
*/
|
||||||
|
static CEvent::Type getOutputErrorEvent();
|
||||||
|
|
||||||
|
//! Get input shutdown event type
|
||||||
|
/*!
|
||||||
|
Returns the input shutdown event type. This is sent when the
|
||||||
|
input side of the stream has shutdown. When the input has
|
||||||
|
shutdown, no more data will ever be available to read.
|
||||||
|
*/
|
||||||
|
static CEvent::Type getInputShutdownEvent();
|
||||||
|
|
||||||
|
//! Get output shutdown event type
|
||||||
|
/*!
|
||||||
|
Returns the output shutdown event type. This is sent when the
|
||||||
|
output side of the stream has shutdown. When the output has
|
||||||
|
shutdown, no more data can ever be written to the stream. Any
|
||||||
|
attempt to do so will generate a output error event.
|
||||||
|
*/
|
||||||
|
static CEvent::Type getOutputShutdownEvent();
|
||||||
|
|
||||||
|
//@}
|
||||||
|
|
||||||
|
private:
|
||||||
|
static CEvent::Type s_inputReadyEvent;
|
||||||
|
static CEvent::Type s_outputFlushedEvent;
|
||||||
|
static CEvent::Type s_outputErrorEvent;
|
||||||
|
static CEvent::Type s_inputShutdownEvent;
|
||||||
|
static CEvent::Type s_outputShutdownEvent;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif
|
|
@ -17,10 +17,7 @@
|
||||||
|
|
||||||
#include "IInterface.h"
|
#include "IInterface.h"
|
||||||
|
|
||||||
class CInputStreamFilter;
|
class IStream;
|
||||||
class COutputStreamFilter;
|
|
||||||
class IInputStream;
|
|
||||||
class IOutputStream;
|
|
||||||
|
|
||||||
//! Stream filter factory interface
|
//! Stream filter factory interface
|
||||||
/*!
|
/*!
|
||||||
|
@ -28,21 +25,12 @@ This interface provides factory methods to create stream filters.
|
||||||
*/
|
*/
|
||||||
class IStreamFilterFactory : public IInterface {
|
class IStreamFilterFactory : public IInterface {
|
||||||
public:
|
public:
|
||||||
//! Create input filter
|
//! Create filter
|
||||||
/*!
|
/*!
|
||||||
Create and return an input stream filter. The caller must delete the
|
Create and return a stream filter on \p stream. The caller must
|
||||||
returned object.
|
delete the returned object.
|
||||||
*/
|
*/
|
||||||
virtual CInputStreamFilter*
|
virtual IStream* create(IStream* stream, bool adoptStream) = 0;
|
||||||
createInput(IInputStream*, bool adoptStream) = 0;
|
|
||||||
|
|
||||||
//! Create output filter
|
|
||||||
/*!
|
|
||||||
Create and return an output stream filter. The caller must delete the
|
|
||||||
returned object.
|
|
||||||
*/
|
|
||||||
virtual COutputStreamFilter*
|
|
||||||
createOutput(IOutputStream*, bool adoptStream) = 0;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -25,19 +25,13 @@ MAINTAINERCLEANFILES = \
|
||||||
|
|
||||||
noinst_LIBRARIES = libio.a
|
noinst_LIBRARIES = libio.a
|
||||||
libio_a_SOURCES = \
|
libio_a_SOURCES = \
|
||||||
CBufferedInputStream.cpp \
|
|
||||||
CBufferedOutputStream.cpp \
|
|
||||||
CInputStreamFilter.cpp \
|
|
||||||
COutputStreamFilter.cpp \
|
|
||||||
CStreamBuffer.cpp \
|
CStreamBuffer.cpp \
|
||||||
|
CStreamFilter.cpp \
|
||||||
|
IStream.cpp \
|
||||||
XIO.cpp \
|
XIO.cpp \
|
||||||
CBufferedInputStream.h \
|
|
||||||
CBufferedOutputStream.h \
|
|
||||||
CInputStreamFilter.h \
|
|
||||||
COutputStreamFilter.h \
|
|
||||||
CStreamBuffer.h \
|
CStreamBuffer.h \
|
||||||
IInputStream.h \
|
CStreamFilter.h \
|
||||||
IOutputStream.h \
|
IStream.h \
|
||||||
IStreamFilterFactory.h \
|
IStreamFilterFactory.h \
|
||||||
XIO.h \
|
XIO.h \
|
||||||
$(NULL)
|
$(NULL)
|
||||||
|
|
|
@ -34,3 +34,14 @@ XIOEndOfStream::getWhat() const throw()
|
||||||
{
|
{
|
||||||
return format("XIOEndOfStream", "reached end of stream");
|
return format("XIOEndOfStream", "reached end of stream");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//
|
||||||
|
// XIOWouldBlock
|
||||||
|
//
|
||||||
|
|
||||||
|
CString
|
||||||
|
XIOWouldBlock::getWhat() const throw()
|
||||||
|
{
|
||||||
|
return format("XIOWouldBlock", "stream operation would block");
|
||||||
|
}
|
||||||
|
|
|
@ -39,4 +39,10 @@ Thrown when attempting to read beyond the end of a stream.
|
||||||
*/
|
*/
|
||||||
XBASE_SUBCLASS_WHAT(XIOEndOfStream, XIO);
|
XBASE_SUBCLASS_WHAT(XIOEndOfStream, XIO);
|
||||||
|
|
||||||
|
//! I/O would block exception
|
||||||
|
/*!
|
||||||
|
Thrown if an operation on a stream would block.
|
||||||
|
*/
|
||||||
|
XBASE_SUBCLASS_WHAT(XIOWouldBlock, XIO);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -0,0 +1,304 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "CSocketMultiplexer.h"
|
||||||
|
#include "ISocketMultiplexerJob.h"
|
||||||
|
#include "CCondVar.h"
|
||||||
|
#include "CLock.h"
|
||||||
|
#include "CMutex.h"
|
||||||
|
#include "CThread.h"
|
||||||
|
#include "TMethodJob.h"
|
||||||
|
#include "CArch.h"
|
||||||
|
#include "XArch.h"
|
||||||
|
#include "stdvector.h"
|
||||||
|
|
||||||
|
//
|
||||||
|
// CSocketMultiplexer
|
||||||
|
//
|
||||||
|
|
||||||
|
CSocketMultiplexer* CSocketMultiplexer::s_instance = NULL;
|
||||||
|
|
||||||
|
CSocketMultiplexer::CSocketMultiplexer() :
|
||||||
|
m_mutex(new CMutex),
|
||||||
|
m_pollable(new CCondVar<bool>(m_mutex, false)),
|
||||||
|
m_polling(new CCondVar<bool>(m_mutex, false)),
|
||||||
|
m_thread(NULL),
|
||||||
|
m_update(false)
|
||||||
|
{
|
||||||
|
assert(s_instance == NULL);
|
||||||
|
|
||||||
|
// this pointer just has to be unique and not NULL. it will
|
||||||
|
// never be dereferenced. it's used to identify cursor nodes
|
||||||
|
// in the jobs list.
|
||||||
|
m_cursorMark = reinterpret_cast<ISocketMultiplexerJob*>(this);
|
||||||
|
|
||||||
|
// start thread
|
||||||
|
m_thread = new CThread(new TMethodJob<CSocketMultiplexer>(
|
||||||
|
this, &CSocketMultiplexer::serviceThread));
|
||||||
|
|
||||||
|
s_instance = this;
|
||||||
|
}
|
||||||
|
|
||||||
|
CSocketMultiplexer::~CSocketMultiplexer()
|
||||||
|
{
|
||||||
|
m_thread->cancel();
|
||||||
|
m_thread->wait();
|
||||||
|
delete m_thread;
|
||||||
|
delete m_polling;
|
||||||
|
delete m_pollable;
|
||||||
|
delete m_mutex;
|
||||||
|
|
||||||
|
// clean up jobs
|
||||||
|
for (CSocketJobMap::iterator i = m_socketJobMap.begin();
|
||||||
|
i != m_socketJobMap.end(); ++i) {
|
||||||
|
delete *(i->second);
|
||||||
|
}
|
||||||
|
|
||||||
|
s_instance = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
CSocketMultiplexer*
|
||||||
|
CSocketMultiplexer::getInstance()
|
||||||
|
{
|
||||||
|
return s_instance;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CSocketMultiplexer::addSocket(ISocket* socket, ISocketMultiplexerJob* job)
|
||||||
|
{
|
||||||
|
assert(socket != NULL);
|
||||||
|
assert(job != NULL);
|
||||||
|
|
||||||
|
CLock lock(m_mutex);
|
||||||
|
|
||||||
|
// prevent service thread from restarting poll
|
||||||
|
*m_pollable = false;
|
||||||
|
|
||||||
|
// break thread out of poll
|
||||||
|
m_thread->unblock();
|
||||||
|
|
||||||
|
// wait for poll to finish
|
||||||
|
while (*m_polling) {
|
||||||
|
m_polling->wait();
|
||||||
|
}
|
||||||
|
|
||||||
|
// insert/replace job
|
||||||
|
CSocketJobMap::iterator i = m_socketJobMap.find(socket);
|
||||||
|
if (i == m_socketJobMap.end()) {
|
||||||
|
// we *must* put the job at the end so the order of jobs in
|
||||||
|
// the list continue to match the order of jobs in pfds in
|
||||||
|
// serviceThread().
|
||||||
|
CJobCursor j = m_socketJobs.insert(m_socketJobs.end(), job);
|
||||||
|
m_update = true;
|
||||||
|
m_socketJobMap.insert(std::make_pair(socket, j));
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
CJobCursor j = i->second;
|
||||||
|
if (*j != job) {
|
||||||
|
delete *j;
|
||||||
|
*j = job;
|
||||||
|
}
|
||||||
|
m_update = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// there must be at least one socket so we can poll now
|
||||||
|
*m_pollable = true;
|
||||||
|
m_pollable->broadcast();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CSocketMultiplexer::removeSocket(ISocket* socket)
|
||||||
|
{
|
||||||
|
assert(socket != NULL);
|
||||||
|
|
||||||
|
CLock lock(m_mutex);
|
||||||
|
|
||||||
|
// prevent service thread from restarting poll
|
||||||
|
*m_pollable = false;
|
||||||
|
|
||||||
|
// break thread out of poll
|
||||||
|
m_thread->unblock();
|
||||||
|
|
||||||
|
// wait until thread finishes poll
|
||||||
|
while (*m_polling) {
|
||||||
|
m_polling->wait();
|
||||||
|
}
|
||||||
|
|
||||||
|
// remove job. rather than removing it from the map we put NULL
|
||||||
|
// in the list instead so the order of jobs in the list continues
|
||||||
|
// to match the order of jobs in pfds in serviceThread().
|
||||||
|
CSocketJobMap::iterator i = m_socketJobMap.find(socket);
|
||||||
|
if (i != m_socketJobMap.end()) {
|
||||||
|
if (*(i->second) != NULL) {
|
||||||
|
delete *(i->second);
|
||||||
|
*(i->second) = NULL;
|
||||||
|
m_update = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
*m_pollable = true;
|
||||||
|
m_pollable->broadcast();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CSocketMultiplexer::serviceThread(void*)
|
||||||
|
{
|
||||||
|
std::vector<IArchNetwork::CPollEntry> pfds;
|
||||||
|
IArchNetwork::CPollEntry pfd;
|
||||||
|
|
||||||
|
// service the connections
|
||||||
|
for (;;) {
|
||||||
|
{
|
||||||
|
CLock lock(m_mutex);
|
||||||
|
|
||||||
|
// wait until pollable
|
||||||
|
while (!*m_pollable) {
|
||||||
|
m_pollable->wait();
|
||||||
|
}
|
||||||
|
|
||||||
|
// now we're polling
|
||||||
|
*m_polling = true;
|
||||||
|
m_polling->broadcast();
|
||||||
|
}
|
||||||
|
|
||||||
|
// we're now the only thread that can access m_sockets and
|
||||||
|
// m_update because m_polling and m_pollable are both true.
|
||||||
|
// therefore, we don't need to hold the mutex.
|
||||||
|
|
||||||
|
// collect poll entries
|
||||||
|
if (m_update) {
|
||||||
|
m_update = false;
|
||||||
|
pfds.clear();
|
||||||
|
pfds.reserve(m_socketJobMap.size());
|
||||||
|
|
||||||
|
CJobCursor cursor = newCursor();
|
||||||
|
CJobCursor jobCursor = nextCursor(cursor);
|
||||||
|
while (jobCursor != m_socketJobs.end()) {
|
||||||
|
ISocketMultiplexerJob* job = *jobCursor;
|
||||||
|
if (job != NULL) {
|
||||||
|
pfd.m_socket = job->getSocket();
|
||||||
|
pfd.m_events = 0;
|
||||||
|
if (job->isReadable()) {
|
||||||
|
pfd.m_events |= IArchNetwork::kPOLLIN;
|
||||||
|
}
|
||||||
|
if (job->isWritable()) {
|
||||||
|
pfd.m_events |= IArchNetwork::kPOLLOUT;
|
||||||
|
}
|
||||||
|
pfds.push_back(pfd);
|
||||||
|
}
|
||||||
|
jobCursor = nextCursor(cursor);
|
||||||
|
}
|
||||||
|
deleteCursor(cursor);
|
||||||
|
}
|
||||||
|
|
||||||
|
int status;
|
||||||
|
try {
|
||||||
|
// check for status
|
||||||
|
status = ARCH->pollSocket(&pfds[0], pfds.size(), -1);
|
||||||
|
}
|
||||||
|
catch (XArchNetwork&) {
|
||||||
|
// FIXME -- uh oh
|
||||||
|
status = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (status != 0) {
|
||||||
|
// iterate over socket jobs, invoking each and saving the
|
||||||
|
// new job.
|
||||||
|
UInt32 i = 0;
|
||||||
|
CJobCursor cursor = newCursor();
|
||||||
|
CJobCursor jobCursor = nextCursor(cursor);
|
||||||
|
while (i < pfds.size() && jobCursor != m_socketJobs.end()) {
|
||||||
|
if (*jobCursor != NULL) {
|
||||||
|
// get poll state
|
||||||
|
unsigned short revents = pfds[i].m_revents;
|
||||||
|
bool read = ((revents & IArchNetwork::kPOLLIN) != 0);
|
||||||
|
bool write = ((revents & IArchNetwork::kPOLLOUT) != 0);
|
||||||
|
bool error = ((revents & (IArchNetwork::kPOLLERR |
|
||||||
|
IArchNetwork::kPOLLNVAL)) != 0);
|
||||||
|
|
||||||
|
// run job
|
||||||
|
ISocketMultiplexerJob* job = *jobCursor;
|
||||||
|
ISocketMultiplexerJob* newJob = job->run(read, write, error);
|
||||||
|
|
||||||
|
// save job, if different
|
||||||
|
if (newJob != job) {
|
||||||
|
CLock lock(m_mutex);
|
||||||
|
delete job;
|
||||||
|
*jobCursor = newJob;
|
||||||
|
m_update = true;
|
||||||
|
}
|
||||||
|
++i;
|
||||||
|
}
|
||||||
|
|
||||||
|
// next job
|
||||||
|
jobCursor = nextCursor(cursor);
|
||||||
|
}
|
||||||
|
deleteCursor(cursor);
|
||||||
|
}
|
||||||
|
|
||||||
|
// delete any removed socket jobs
|
||||||
|
CLock lock(m_mutex);
|
||||||
|
for (CSocketJobMap::iterator i = m_socketJobMap.begin();
|
||||||
|
i != m_socketJobMap.end();) {
|
||||||
|
if (*(i->second) == NULL) {
|
||||||
|
m_socketJobMap.erase(i++);
|
||||||
|
m_update = true;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
++i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (m_socketJobMap.empty()) {
|
||||||
|
*m_pollable = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// done polling
|
||||||
|
*m_polling = false;
|
||||||
|
m_polling->broadcast();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
CSocketMultiplexer::CJobCursor
|
||||||
|
CSocketMultiplexer::newCursor()
|
||||||
|
{
|
||||||
|
CLock lock(m_mutex);
|
||||||
|
return m_socketJobs.insert(m_socketJobs.begin(), m_cursorMark);
|
||||||
|
}
|
||||||
|
|
||||||
|
CSocketMultiplexer::CJobCursor
|
||||||
|
CSocketMultiplexer::nextCursor(CJobCursor cursor)
|
||||||
|
{
|
||||||
|
CLock lock(m_mutex);
|
||||||
|
ISocketMultiplexerJob* job = NULL;
|
||||||
|
CJobCursor j = m_socketJobs.end();
|
||||||
|
CJobCursor i = cursor;
|
||||||
|
while (++i != m_socketJobs.end()) {
|
||||||
|
if (*i != m_cursorMark) {
|
||||||
|
// found a real job (as opposed to a cursor)
|
||||||
|
j = i;
|
||||||
|
|
||||||
|
// move our cursor just past the job
|
||||||
|
m_socketJobs.splice(++i, m_socketJobs, cursor);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return j;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CSocketMultiplexer::deleteCursor(CJobCursor cursor)
|
||||||
|
{
|
||||||
|
CLock lock(m_mutex);
|
||||||
|
m_socketJobs.erase(cursor);
|
||||||
|
}
|
|
@ -0,0 +1,95 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CSOCKETMULTIPLEXER_H
|
||||||
|
#define CSOCKETMULTIPLEXER_H
|
||||||
|
|
||||||
|
#include "IArchNetwork.h"
|
||||||
|
#include "stdlist.h"
|
||||||
|
#include "stdmap.h"
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
class CCondVar;
|
||||||
|
class CMutex;
|
||||||
|
class CThread;
|
||||||
|
class ISocket;
|
||||||
|
class ISocketMultiplexerJob;
|
||||||
|
|
||||||
|
//! Socket multiplexer
|
||||||
|
/*!
|
||||||
|
A socket multiplexer services multiple sockets simultaneously.
|
||||||
|
*/
|
||||||
|
class CSocketMultiplexer {
|
||||||
|
public:
|
||||||
|
CSocketMultiplexer();
|
||||||
|
~CSocketMultiplexer();
|
||||||
|
|
||||||
|
//! @name manipulators
|
||||||
|
//@{
|
||||||
|
|
||||||
|
void addSocket(ISocket*, ISocketMultiplexerJob*);
|
||||||
|
|
||||||
|
void removeSocket(ISocket*);
|
||||||
|
|
||||||
|
//@}
|
||||||
|
//! @name accessors
|
||||||
|
//@{
|
||||||
|
|
||||||
|
// maybe belongs on ISocketMultiplexer
|
||||||
|
static CSocketMultiplexer*
|
||||||
|
getInstance();
|
||||||
|
|
||||||
|
//@}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// list of jobs. we use a list so we can safely iterate over it
|
||||||
|
// while other threads modify it.
|
||||||
|
typedef std::list<ISocketMultiplexerJob*> CSocketJobs;
|
||||||
|
typedef CSocketJobs::iterator CJobCursor;
|
||||||
|
typedef std::map<ISocket*, CJobCursor> CSocketJobMap;
|
||||||
|
|
||||||
|
// service sockets. the service thread will only access m_sockets
|
||||||
|
// and m_update while m_pollable and m_polling are true. all other
|
||||||
|
// threads must only modify these when m_pollable and m_polling are
|
||||||
|
// false. only the service thread sets m_polling.
|
||||||
|
void serviceThread(void*);
|
||||||
|
|
||||||
|
// create, iterate, and destroy a cursor. a cursor is used to
|
||||||
|
// safely iterate through the job list while other threads modify
|
||||||
|
// the list. it works by inserting a dummy item in the list and
|
||||||
|
// moving that item through the list. the dummy item will never
|
||||||
|
// be removed by other edits so an iterator pointing at the item
|
||||||
|
// remains valid until we remove the dummy item in deleteCursor().
|
||||||
|
// nextCursor() finds the next non-dummy item, moves our dummy
|
||||||
|
// item just past it, and returns an iterator for the non-dummy
|
||||||
|
// item. all cursor calls lock the mutex for their duration.
|
||||||
|
CJobCursor newCursor();
|
||||||
|
CJobCursor nextCursor(CJobCursor);
|
||||||
|
void deleteCursor(CJobCursor);
|
||||||
|
|
||||||
|
private:
|
||||||
|
CMutex* m_mutex;
|
||||||
|
CCondVar<bool>* m_pollable;
|
||||||
|
CCondVar<bool>* m_polling;
|
||||||
|
CThread* m_thread;
|
||||||
|
bool m_update;
|
||||||
|
|
||||||
|
CSocketJobs m_socketJobs;
|
||||||
|
CSocketJobMap m_socketJobMap;
|
||||||
|
ISocketMultiplexerJob* m_cursorMark;
|
||||||
|
|
||||||
|
static CSocketMultiplexer* s_instance;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif
|
|
@ -30,8 +30,7 @@
|
||||||
// CTCPListenSocket
|
// CTCPListenSocket
|
||||||
//
|
//
|
||||||
|
|
||||||
CTCPListenSocket::CTCPListenSocket() :
|
CTCPListenSocket::CTCPListenSocket()
|
||||||
m_target(NULL)
|
|
||||||
{
|
{
|
||||||
m_mutex = new CMutex;
|
m_mutex = new CMutex;
|
||||||
try {
|
try {
|
||||||
|
@ -76,21 +75,6 @@ CTCPListenSocket::bind(const CNetworkAddress& addr)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
IDataSocket*
|
|
||||||
CTCPListenSocket::accept()
|
|
||||||
{
|
|
||||||
try {
|
|
||||||
CSocketMultiplexer::getInstance()->addSocket(this,
|
|
||||||
new TSocketMultiplexerMethodJob<CTCPListenSocket>(
|
|
||||||
this, &CTCPListenSocket::serviceListening,
|
|
||||||
m_socket, true, false));
|
|
||||||
return new CTCPSocket(ARCH->acceptSocket(m_socket, NULL));
|
|
||||||
}
|
|
||||||
catch (XArchNetwork&) {
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
void
|
||||||
CTCPListenSocket::close()
|
CTCPListenSocket::close()
|
||||||
{
|
{
|
||||||
|
@ -108,11 +92,25 @@ CTCPListenSocket::close()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void*
|
||||||
CTCPListenSocket::setEventTarget(void* target)
|
CTCPListenSocket::getEventTarget() const
|
||||||
{
|
{
|
||||||
CLock lock(m_mutex);
|
return const_cast<void*>(reinterpret_cast<const void*>(this));
|
||||||
m_target = target;
|
}
|
||||||
|
|
||||||
|
IDataSocket*
|
||||||
|
CTCPListenSocket::accept()
|
||||||
|
{
|
||||||
|
try {
|
||||||
|
CSocketMultiplexer::getInstance()->addSocket(this,
|
||||||
|
new TSocketMultiplexerMethodJob<CTCPListenSocket>(
|
||||||
|
this, &CTCPListenSocket::serviceListening,
|
||||||
|
m_socket, true, false));
|
||||||
|
return new CTCPSocket(ARCH->acceptSocket(m_socket, NULL));
|
||||||
|
}
|
||||||
|
catch (XArchNetwork&) {
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
ISocketMultiplexerJob*
|
ISocketMultiplexerJob*
|
||||||
|
@ -125,7 +123,7 @@ CTCPListenSocket::serviceListening(ISocketMultiplexerJob* job,
|
||||||
}
|
}
|
||||||
if (read) {
|
if (read) {
|
||||||
CEventQueue::getInstance()->addEvent(
|
CEventQueue::getInstance()->addEvent(
|
||||||
CEvent(getConnectingEvent(), m_target, NULL));
|
CEvent(getConnectingEvent(), this, NULL));
|
||||||
// stop polling on this socket until the client accepts
|
// stop polling on this socket until the client accepts
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
|
@ -33,7 +33,7 @@ public:
|
||||||
// ISocket overrides
|
// ISocket overrides
|
||||||
virtual void bind(const CNetworkAddress&);
|
virtual void bind(const CNetworkAddress&);
|
||||||
virtual void close();
|
virtual void close();
|
||||||
virtual void setEventTarget(void*);
|
virtual void* getEventTarget() const;
|
||||||
|
|
||||||
// IListenSocket overrides
|
// IListenSocket overrides
|
||||||
virtual IDataSocket* accept();
|
virtual IDataSocket* accept();
|
||||||
|
@ -46,7 +46,6 @@ private:
|
||||||
private:
|
private:
|
||||||
CArchSocket m_socket;
|
CArchSocket m_socket;
|
||||||
CMutex* m_mutex;
|
CMutex* m_mutex;
|
||||||
void* m_target;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -16,14 +16,10 @@
|
||||||
#include "CNetworkAddress.h"
|
#include "CNetworkAddress.h"
|
||||||
#include "CSocketMultiplexer.h"
|
#include "CSocketMultiplexer.h"
|
||||||
#include "TSocketMultiplexerMethodJob.h"
|
#include "TSocketMultiplexerMethodJob.h"
|
||||||
#include "CBufferedInputStream.h"
|
|
||||||
#include "CBufferedOutputStream.h"
|
|
||||||
#include "XSocket.h"
|
#include "XSocket.h"
|
||||||
#include "XIO.h"
|
|
||||||
#include "CLock.h"
|
#include "CLock.h"
|
||||||
#include "CMutex.h"
|
|
||||||
#include "CEventQueue.h"
|
#include "CEventQueue.h"
|
||||||
#include "TMethodJob.h"
|
#include "IEventJob.h"
|
||||||
#include "CArch.h"
|
#include "CArch.h"
|
||||||
#include "XArch.h"
|
#include "XArch.h"
|
||||||
|
|
||||||
|
@ -31,7 +27,10 @@
|
||||||
// CTCPSocket
|
// CTCPSocket
|
||||||
//
|
//
|
||||||
|
|
||||||
CTCPSocket::CTCPSocket()
|
CTCPSocket::CTCPSocket() :
|
||||||
|
m_mutex(),
|
||||||
|
m_flushed(&m_mutex, true),
|
||||||
|
m_eventFilter(NULL)
|
||||||
{
|
{
|
||||||
try {
|
try {
|
||||||
m_socket = ARCH->newSocket(IArchNetwork::kINET, IArchNetwork::kSTREAM);
|
m_socket = ARCH->newSocket(IArchNetwork::kINET, IArchNetwork::kSTREAM);
|
||||||
|
@ -39,34 +38,32 @@ CTCPSocket::CTCPSocket()
|
||||||
catch (XArchNetwork& e) {
|
catch (XArchNetwork& e) {
|
||||||
throw XSocketCreate(e.what());
|
throw XSocketCreate(e.what());
|
||||||
}
|
}
|
||||||
|
|
||||||
init();
|
init();
|
||||||
}
|
}
|
||||||
|
|
||||||
CTCPSocket::CTCPSocket(CArchSocket socket) :
|
CTCPSocket::CTCPSocket(CArchSocket socket) :
|
||||||
m_socket(socket)
|
m_mutex(),
|
||||||
|
m_socket(socket),
|
||||||
|
m_flushed(&m_mutex, true),
|
||||||
|
m_eventFilter(NULL)
|
||||||
{
|
{
|
||||||
assert(m_socket != NULL);
|
assert(m_socket != NULL);
|
||||||
|
|
||||||
// socket starts in connected state
|
// socket starts in connected state
|
||||||
init();
|
init();
|
||||||
setState(kReadWrite, true);
|
onConnected();
|
||||||
|
setJob(newJob());
|
||||||
}
|
}
|
||||||
|
|
||||||
CTCPSocket::~CTCPSocket()
|
CTCPSocket::~CTCPSocket()
|
||||||
{
|
{
|
||||||
try {
|
try {
|
||||||
if (m_socket != NULL) {
|
|
||||||
close();
|
close();
|
||||||
}
|
}
|
||||||
}
|
|
||||||
catch (...) {
|
catch (...) {
|
||||||
// ignore
|
// ignore
|
||||||
}
|
}
|
||||||
|
|
||||||
// clean up
|
|
||||||
delete m_input;
|
|
||||||
delete m_output;
|
|
||||||
delete m_mutex;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
@ -86,92 +83,202 @@ CTCPSocket::bind(const CNetworkAddress& addr)
|
||||||
void
|
void
|
||||||
CTCPSocket::close()
|
CTCPSocket::close()
|
||||||
{
|
{
|
||||||
// flush buffers
|
CLock lock(&m_mutex);
|
||||||
m_output->flush();
|
|
||||||
|
|
||||||
// now closed
|
// clear buffers and enter disconnected state
|
||||||
setState(kClosed, true);
|
if (m_connected) {
|
||||||
|
sendSocketEvent(getDisconnectedEvent());
|
||||||
|
}
|
||||||
|
onDisconnected();
|
||||||
|
|
||||||
// close buffers
|
// remove ourself from the multiplexer
|
||||||
try {
|
setJob(NULL);
|
||||||
m_input->close();
|
|
||||||
}
|
|
||||||
catch (...) {
|
|
||||||
// ignore
|
|
||||||
}
|
|
||||||
try {
|
|
||||||
m_output->close();
|
|
||||||
}
|
|
||||||
catch (...) {
|
|
||||||
// ignore
|
|
||||||
}
|
|
||||||
|
|
||||||
// close socket
|
// close the socket
|
||||||
CLock lock(m_mutex);
|
|
||||||
if (m_socket != NULL) {
|
if (m_socket != NULL) {
|
||||||
try {
|
CArchSocket socket = m_socket;
|
||||||
ARCH->closeSocket(m_socket);
|
|
||||||
m_socket = NULL;
|
m_socket = NULL;
|
||||||
|
try {
|
||||||
|
ARCH->closeSocket(socket);
|
||||||
}
|
}
|
||||||
catch (XArchNetwork& e) {
|
catch (XArchNetwork& e) {
|
||||||
throw XSocketIOClose(e.what());
|
// FIXME -- just discard this for now
|
||||||
|
//throw XSocketIOClose(e.what());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void*
|
||||||
|
CTCPSocket::getEventTarget() const
|
||||||
|
{
|
||||||
|
return const_cast<void*>(reinterpret_cast<const void*>(this));
|
||||||
|
}
|
||||||
|
|
||||||
|
UInt32
|
||||||
|
CTCPSocket::read(void* buffer, UInt32 n)
|
||||||
|
{
|
||||||
|
// copy data directly from our input buffer
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
UInt32 size = m_inputBuffer.getSize();
|
||||||
|
if (n > size) {
|
||||||
|
n = size;
|
||||||
|
}
|
||||||
|
if (buffer != NULL) {
|
||||||
|
memcpy(buffer, m_inputBuffer.peek(n), n);
|
||||||
|
}
|
||||||
|
m_inputBuffer.pop(n);
|
||||||
|
|
||||||
|
// if no more data and we cannot read or write then send disconnected
|
||||||
|
if (n > 0 && !m_readable && !m_writable) {
|
||||||
|
sendSocketEvent(getDisconnectedEvent());
|
||||||
|
}
|
||||||
|
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CTCPSocket::write(const void* buffer, UInt32 n)
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
|
||||||
|
// must not have shutdown output
|
||||||
|
if (!m_writable) {
|
||||||
|
sendStreamEvent(getOutputErrorEvent());
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ignore empty writes
|
||||||
|
if (n == 0) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// copy data to the output buffer
|
||||||
|
bool wasEmpty = (m_outputBuffer.getSize() == 0);
|
||||||
|
m_outputBuffer.write(buffer, n);
|
||||||
|
|
||||||
|
// there's data to write
|
||||||
|
m_flushed = false;
|
||||||
|
|
||||||
|
// make sure we're waiting to write
|
||||||
|
if (wasEmpty) {
|
||||||
|
setJob(newJob());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CTCPSocket::setEventTarget(void* target)
|
CTCPSocket::flush()
|
||||||
{
|
{
|
||||||
CLock lock(m_mutex);
|
CLock lock(&m_mutex);
|
||||||
m_target = target;
|
while (m_flushed == false) {
|
||||||
|
m_flushed.wait();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CTCPSocket::shutdownInput()
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
|
||||||
|
// shutdown socket for reading
|
||||||
|
try {
|
||||||
|
ARCH->closeSocketForRead(m_socket);
|
||||||
|
}
|
||||||
|
catch (XArchNetwork&) {
|
||||||
|
// ignore
|
||||||
|
}
|
||||||
|
|
||||||
|
// shutdown buffer for reading
|
||||||
|
if (m_readable) {
|
||||||
|
sendStreamEvent(getInputShutdownEvent());
|
||||||
|
onInputShutdown();
|
||||||
|
setJob(newJob());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CTCPSocket::shutdownOutput()
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
|
||||||
|
// shutdown socket for writing
|
||||||
|
try {
|
||||||
|
ARCH->closeSocketForWrite(m_socket);
|
||||||
|
}
|
||||||
|
catch (XArchNetwork&) {
|
||||||
|
// ignore
|
||||||
|
}
|
||||||
|
|
||||||
|
// shutdown buffer for writing
|
||||||
|
if (m_writable) {
|
||||||
|
sendStreamEvent(getOutputShutdownEvent());
|
||||||
|
onOutputShutdown();
|
||||||
|
setJob(newJob());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CTCPSocket::setEventFilter(IEventJob* filter)
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
m_eventFilter = filter;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool
|
||||||
|
CTCPSocket::isReady() const
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
return (m_inputBuffer.getSize() > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
UInt32
|
||||||
|
CTCPSocket::getSize() const
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
return m_inputBuffer.getSize();
|
||||||
|
}
|
||||||
|
|
||||||
|
IEventJob*
|
||||||
|
CTCPSocket::getEventFilter() const
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
return m_eventFilter;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CTCPSocket::connect(const CNetworkAddress& addr)
|
CTCPSocket::connect(const CNetworkAddress& addr)
|
||||||
{
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
|
||||||
|
// fail on attempts to reconnect
|
||||||
|
if (m_socket == NULL || m_connected) {
|
||||||
|
sendSocketEvent(getConnectionFailedEvent());
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
try {
|
try {
|
||||||
// FIXME -- don't throw if in progress, just return that info
|
// FIXME -- don't throw if in progress, just return that info
|
||||||
ARCH->connectSocket(m_socket, addr.getAddress());
|
ARCH->connectSocket(m_socket, addr.getAddress());
|
||||||
setState(kReadWrite, true);
|
sendSocketEvent(getConnectedEvent());
|
||||||
|
onConnected();
|
||||||
|
setJob(newJob());
|
||||||
}
|
}
|
||||||
catch (XArchNetworkConnecting&) {
|
catch (XArchNetworkConnecting&) {
|
||||||
// connection is in progress
|
// connection is in progress
|
||||||
setState(kConnecting, true);
|
m_writable = true;
|
||||||
|
setJob(newJob());
|
||||||
}
|
}
|
||||||
catch (XArchNetwork& e) {
|
catch (XArchNetwork& e) {
|
||||||
throw XSocketConnect(e.what());
|
throw XSocketConnect(e.what());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
IInputStream*
|
|
||||||
CTCPSocket::getInputStream()
|
|
||||||
{
|
|
||||||
return m_input;
|
|
||||||
}
|
|
||||||
|
|
||||||
IOutputStream*
|
|
||||||
CTCPSocket::getOutputStream()
|
|
||||||
{
|
|
||||||
return m_output;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
void
|
||||||
CTCPSocket::init()
|
CTCPSocket::init()
|
||||||
{
|
{
|
||||||
m_mutex = new CMutex;
|
// default state
|
||||||
m_input = new CBufferedInputStream(m_mutex,
|
m_connected = false;
|
||||||
new TMethodJob<CTCPSocket>(
|
m_readable = false;
|
||||||
this, &CTCPSocket::emptyInput),
|
m_writable = false;
|
||||||
new TMethodJob<CTCPSocket>(
|
|
||||||
this, &CTCPSocket::closeInput));
|
|
||||||
m_output = new CBufferedOutputStream(m_mutex,
|
|
||||||
new TMethodJob<CTCPSocket>(
|
|
||||||
this, &CTCPSocket::fillOutput),
|
|
||||||
new TMethodJob<CTCPSocket>(
|
|
||||||
this, &CTCPSocket::closeOutput));
|
|
||||||
m_state = kUnconnected;
|
|
||||||
m_target = NULL;
|
|
||||||
m_job = NULL;
|
|
||||||
|
|
||||||
// make socket non-blocking
|
// make socket non-blocking
|
||||||
// FIXME -- check for error
|
// FIXME -- check for error
|
||||||
|
@ -196,172 +303,97 @@ CTCPSocket::init()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
ISocketMultiplexerJob*
|
void
|
||||||
CTCPSocket::newMultiplexerJob(JobFunc func, bool readable, bool writable)
|
CTCPSocket::setJob(ISocketMultiplexerJob* job)
|
||||||
{
|
{
|
||||||
|
// multiplexer will delete the old job
|
||||||
|
if (job == NULL) {
|
||||||
|
CSocketMultiplexer::getInstance()->removeSocket(this);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
CSocketMultiplexer::getInstance()->addSocket(this, job);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ISocketMultiplexerJob*
|
||||||
|
CTCPSocket::newJob()
|
||||||
|
{
|
||||||
|
// note -- must have m_mutex locked on entry
|
||||||
|
|
||||||
|
if (m_socket == NULL || !(m_readable || m_writable)) {
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
else if (!m_connected) {
|
||||||
|
assert(!m_readable);
|
||||||
return new TSocketMultiplexerMethodJob<CTCPSocket>(
|
return new TSocketMultiplexerMethodJob<CTCPSocket>(
|
||||||
this, func, m_socket, readable, writable);
|
this, &CTCPSocket::serviceConnecting,
|
||||||
}
|
m_socket, m_readable, m_writable);
|
||||||
|
|
||||||
ISocketMultiplexerJob*
|
|
||||||
CTCPSocket::setState(State state, bool setJob)
|
|
||||||
{
|
|
||||||
if (m_state == state || m_state == kClosed) {
|
|
||||||
return m_job;
|
|
||||||
}
|
|
||||||
|
|
||||||
State oldState = m_state;
|
|
||||||
m_state = state;
|
|
||||||
|
|
||||||
bool read = (m_input->getSize() > 0);
|
|
||||||
bool write = (m_output->getSize() > 0);
|
|
||||||
CEvent::Type eventType = 0;
|
|
||||||
m_job = NULL;
|
|
||||||
switch (m_state) {
|
|
||||||
case kUnconnected:
|
|
||||||
assert(0 && "cannot re-enter unconnected state");
|
|
||||||
break;
|
|
||||||
|
|
||||||
case kConnecting:
|
|
||||||
m_job = newMultiplexerJob(&CTCPSocket::serviceConnecting, false, true);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case kReadWrite:
|
|
||||||
if (oldState == kConnecting) {
|
|
||||||
eventType = IDataSocket::getConnectedEvent();
|
|
||||||
}
|
|
||||||
m_job = newMultiplexerJob(&CTCPSocket::serviceConnected, true, write);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case kReadOnly:
|
|
||||||
if (!write) {
|
|
||||||
eventType = IDataSocket::getShutdownOutputEvent();
|
|
||||||
}
|
|
||||||
if (oldState == kWriteOnly) {
|
|
||||||
goto shutdown;
|
|
||||||
}
|
|
||||||
m_job = newMultiplexerJob(&CTCPSocket::serviceConnected, true, write);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case kWriteOnly:
|
|
||||||
if (!read) {
|
|
||||||
m_input->hangup();
|
|
||||||
eventType = IDataSocket::getShutdownInputEvent();
|
|
||||||
}
|
|
||||||
if (oldState == kReadOnly) {
|
|
||||||
goto shutdown;
|
|
||||||
}
|
|
||||||
m_job = newMultiplexerJob(&CTCPSocket::serviceConnected, false, write);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case kShutdown:
|
|
||||||
shutdown:
|
|
||||||
if (!read && !write) {
|
|
||||||
eventType = ISocket::getDisconnectedEvent();
|
|
||||||
m_state = kClosed;
|
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
m_state = kShutdown;
|
return new TSocketMultiplexerMethodJob<CTCPSocket>(
|
||||||
|
this, &CTCPSocket::serviceConnected,
|
||||||
|
m_socket, m_readable,
|
||||||
|
m_writable && (m_outputBuffer.getSize() > 0));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
break;
|
|
||||||
|
|
||||||
case kClosed:
|
void
|
||||||
m_input->hangup();
|
CTCPSocket::sendSocketEvent(CEvent::Type type)
|
||||||
if (oldState == kConnecting) {
|
{
|
||||||
eventType = IDataSocket::getConnectionFailedEvent();
|
EVENTQUEUE->addEvent(CEvent(type, this, NULL));
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CTCPSocket::sendStreamEvent(CEvent::Type type)
|
||||||
|
{
|
||||||
|
if (m_eventFilter != NULL) {
|
||||||
|
m_eventFilter->run(CEvent(type, this, NULL));
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
eventType = ISocket::getDisconnectedEvent();
|
EVENTQUEUE->addEvent(CEvent(type, this, NULL));
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
// notify
|
|
||||||
if (eventType != 0) {
|
|
||||||
sendEvent(eventType);
|
|
||||||
}
|
|
||||||
|
|
||||||
// cut over to new job. multiplexer will delete the old job.
|
|
||||||
if (setJob) {
|
|
||||||
if (m_job == NULL) {
|
|
||||||
CSocketMultiplexer::getInstance()->removeSocket(this);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
CSocketMultiplexer::getInstance()->addSocket(this, m_job);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return m_job;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CTCPSocket::closeInput(void*)
|
|
||||||
{
|
|
||||||
// note -- m_mutex should already be locked
|
|
||||||
try {
|
|
||||||
ARCH->closeSocketForRead(m_socket);
|
|
||||||
setState(kWriteOnly, true);
|
|
||||||
}
|
|
||||||
catch (XArchNetwork&) {
|
|
||||||
// ignore
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CTCPSocket::closeOutput(void*)
|
CTCPSocket::onConnected()
|
||||||
{
|
{
|
||||||
// note -- m_mutex should already be locked
|
m_connected = true;
|
||||||
try {
|
m_readable = true;
|
||||||
// ARCH->closeSocketForWrite(m_socket);
|
m_writable = true;
|
||||||
setState(kReadOnly, true);
|
|
||||||
}
|
|
||||||
catch (XArchNetwork&) {
|
|
||||||
// ignore
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CTCPSocket::emptyInput(void*)
|
CTCPSocket::onInputShutdown()
|
||||||
{
|
{
|
||||||
// note -- m_mutex should already be locked
|
m_inputBuffer.pop(m_inputBuffer.getSize());
|
||||||
bool write = (m_output->getSize() > 0);
|
m_readable = false;
|
||||||
if (m_state == kWriteOnly && !write) {
|
|
||||||
m_state = kShutdown;
|
|
||||||
}
|
|
||||||
if (m_state == kWriteOnly) {
|
|
||||||
m_job = newMultiplexerJob(&CTCPSocket::serviceConnected, false, write);
|
|
||||||
CSocketMultiplexer::getInstance()->addSocket(this, m_job);
|
|
||||||
m_input->hangup();
|
|
||||||
sendEvent(IDataSocket::getShutdownInputEvent());
|
|
||||||
}
|
|
||||||
else if (m_state == kShutdown) {
|
|
||||||
m_job = NULL;
|
|
||||||
CSocketMultiplexer::getInstance()->removeSocket(this);
|
|
||||||
if (!write) {
|
|
||||||
sendEvent(ISocket::getDisconnectedEvent());
|
|
||||||
m_state = kClosed;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CTCPSocket::fillOutput(void*)
|
CTCPSocket::onOutputShutdown()
|
||||||
{
|
{
|
||||||
// note -- m_mutex should already be locked
|
m_outputBuffer.pop(m_outputBuffer.getSize());
|
||||||
if (m_state == kReadWrite) {
|
m_writable = false;
|
||||||
m_job = newMultiplexerJob(&CTCPSocket::serviceConnected, true, true);
|
|
||||||
CSocketMultiplexer::getInstance()->addSocket(this, m_job);
|
// we're now flushed
|
||||||
}
|
m_flushed = true;
|
||||||
else if (m_state == kWriteOnly) {
|
m_flushed.broadcast();
|
||||||
m_job = newMultiplexerJob(&CTCPSocket::serviceConnected, false, true);
|
|
||||||
CSocketMultiplexer::getInstance()->addSocket(this, m_job);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CTCPSocket::onDisconnected()
|
||||||
|
{
|
||||||
|
// disconnected
|
||||||
|
onInputShutdown();
|
||||||
|
onOutputShutdown();
|
||||||
|
m_connected = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
ISocketMultiplexerJob*
|
ISocketMultiplexerJob*
|
||||||
CTCPSocket::serviceConnecting(ISocketMultiplexerJob* job,
|
CTCPSocket::serviceConnecting(ISocketMultiplexerJob* job,
|
||||||
bool, bool write, bool error)
|
bool, bool write, bool error)
|
||||||
{
|
{
|
||||||
CLock lock(m_mutex);
|
CLock lock(&m_mutex);
|
||||||
|
|
||||||
if (write && !error) {
|
if (write && !error) {
|
||||||
try {
|
try {
|
||||||
|
@ -374,11 +406,15 @@ CTCPSocket::serviceConnecting(ISocketMultiplexerJob* job,
|
||||||
}
|
}
|
||||||
|
|
||||||
if (error) {
|
if (error) {
|
||||||
return setState(kClosed, false);
|
sendSocketEvent(getConnectionFailedEvent());
|
||||||
|
onDisconnected();
|
||||||
|
return newJob();
|
||||||
}
|
}
|
||||||
|
|
||||||
if (write) {
|
if (write) {
|
||||||
return setState(kReadWrite, false);
|
sendSocketEvent(getConnectedEvent());
|
||||||
|
onConnected();
|
||||||
|
return newJob();
|
||||||
}
|
}
|
||||||
|
|
||||||
return job;
|
return job;
|
||||||
|
@ -388,79 +424,99 @@ ISocketMultiplexerJob*
|
||||||
CTCPSocket::serviceConnected(ISocketMultiplexerJob* job,
|
CTCPSocket::serviceConnected(ISocketMultiplexerJob* job,
|
||||||
bool read, bool write, bool error)
|
bool read, bool write, bool error)
|
||||||
{
|
{
|
||||||
CLock lock(m_mutex);
|
CLock lock(&m_mutex);
|
||||||
|
|
||||||
if (error) {
|
if (error) {
|
||||||
return setState(kClosed, false);
|
sendSocketEvent(getDisconnectedEvent());
|
||||||
|
onDisconnected();
|
||||||
|
return newJob();
|
||||||
}
|
}
|
||||||
|
|
||||||
if (write) {
|
bool needNewJob = false;
|
||||||
// get amount of data to write
|
|
||||||
UInt32 n = m_output->getSize();
|
|
||||||
|
|
||||||
// write data
|
if (write) {
|
||||||
try {
|
try {
|
||||||
const void* buffer = m_output->peek(n);
|
// write data
|
||||||
size_t n2 = ARCH->writeSocket(m_socket, buffer, n);
|
UInt32 n = m_outputBuffer.getSize();
|
||||||
|
const void* buffer = m_outputBuffer.peek(n);
|
||||||
|
n = (UInt32)ARCH->writeSocket(m_socket, buffer, n);
|
||||||
|
|
||||||
// discard written data
|
// discard written data
|
||||||
if (n2 > 0) {
|
if (n > 0) {
|
||||||
m_output->pop(n2);
|
m_outputBuffer.pop(n);
|
||||||
|
if (m_outputBuffer.getSize() == 0) {
|
||||||
|
sendStreamEvent(getOutputFlushedEvent());
|
||||||
|
m_flushed = true;
|
||||||
|
m_flushed.broadcast();
|
||||||
|
needNewJob = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (XArchNetworkShutdown&) {
|
||||||
|
// remote read end of stream hungup. our output side
|
||||||
|
// has therefore shutdown.
|
||||||
|
onOutputShutdown();
|
||||||
|
sendStreamEvent(getOutputShutdownEvent());
|
||||||
|
if (!m_readable && m_inputBuffer.getSize() == 0) {
|
||||||
|
sendSocketEvent(getDisconnectedEvent());
|
||||||
|
}
|
||||||
|
needNewJob = true;
|
||||||
|
}
|
||||||
|
catch (XArchNetworkDisconnected&) {
|
||||||
|
// stream hungup
|
||||||
|
onDisconnected();
|
||||||
|
sendSocketEvent(getDisconnectedEvent());
|
||||||
|
needNewJob = true;
|
||||||
|
}
|
||||||
|
catch (XArchNetwork&) {
|
||||||
|
// other write error
|
||||||
|
onDisconnected();
|
||||||
|
sendStreamEvent(getOutputErrorEvent());
|
||||||
|
sendSocketEvent(getDisconnectedEvent());
|
||||||
|
needNewJob = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (read && m_readable) {
|
||||||
|
try {
|
||||||
|
UInt8 buffer[4096];
|
||||||
|
size_t n = ARCH->readSocket(m_socket, buffer, sizeof(buffer));
|
||||||
|
if (n > 0) {
|
||||||
|
bool wasEmpty = (m_inputBuffer.getSize() == 0);
|
||||||
|
|
||||||
|
// slurp up as much as possible
|
||||||
|
do {
|
||||||
|
m_inputBuffer.write(buffer, n);
|
||||||
|
n = ARCH->readSocket(m_socket, buffer, sizeof(buffer));
|
||||||
|
} while (n > 0);
|
||||||
|
|
||||||
|
// send input ready if input buffer was empty
|
||||||
|
if (wasEmpty) {
|
||||||
|
sendStreamEvent(getInputReadyEvent());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
// remote write end of stream hungup. our input side
|
||||||
|
// has therefore shutdown but don't flush our buffer
|
||||||
|
// since there's still data to be read.
|
||||||
|
sendStreamEvent(getInputShutdownEvent());
|
||||||
|
if (!m_writable && m_inputBuffer.getSize() == 0) {
|
||||||
|
sendSocketEvent(getDisconnectedEvent());
|
||||||
|
}
|
||||||
|
m_readable = false;
|
||||||
|
needNewJob = true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
catch (XArchNetworkDisconnected&) {
|
catch (XArchNetworkDisconnected&) {
|
||||||
// stream hungup
|
// stream hungup
|
||||||
return setState(kReadOnly, false);
|
sendSocketEvent(getDisconnectedEvent());
|
||||||
|
onDisconnected();
|
||||||
|
needNewJob = true;
|
||||||
|
}
|
||||||
|
catch (XArchNetwork&) {
|
||||||
|
// ignore other read error
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (read) {
|
return needNewJob ? newJob() : job;
|
||||||
UInt8 buffer[4096];
|
|
||||||
size_t n = ARCH->readSocket(m_socket, buffer, sizeof(buffer));
|
|
||||||
if (n > 0) {
|
|
||||||
// slurp up as much as possible
|
|
||||||
do {
|
|
||||||
m_input->write(buffer, n);
|
|
||||||
try {
|
|
||||||
n = ARCH->readSocket(m_socket, buffer, sizeof(buffer));
|
|
||||||
}
|
|
||||||
catch (XArchNetworkWouldBlock&) {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
} while (n > 0);
|
|
||||||
|
|
||||||
// notify
|
|
||||||
sendEvent(IDataSocket::getInputEvent());
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// stream hungup
|
|
||||||
return setState(kWriteOnly, false);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (write && m_output->getSize() == 0) {
|
|
||||||
if (m_state == kReadOnly) {
|
|
||||||
ARCH->closeSocketForWrite(m_socket);
|
|
||||||
sendEvent(IDataSocket::getShutdownOutputEvent());
|
|
||||||
m_job = newMultiplexerJob(&CTCPSocket::serviceConnected,
|
|
||||||
true, false);
|
|
||||||
job = m_job;
|
|
||||||
}
|
|
||||||
else if (m_state == kReadWrite || m_state == kReadOnly) {
|
|
||||||
m_job = newMultiplexerJob(&CTCPSocket::serviceConnected,
|
|
||||||
true, false);
|
|
||||||
job = m_job;
|
|
||||||
}
|
|
||||||
else if (m_state == kWriteOnly) {
|
|
||||||
m_job = NULL;
|
|
||||||
job = m_job;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return job;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CTCPSocket::sendEvent(CEvent::Type type)
|
|
||||||
{
|
|
||||||
CEventQueue::getInstance()->addEvent(CEvent(type, m_target, NULL));
|
|
||||||
}
|
}
|
||||||
|
|
|
@ -16,14 +16,13 @@
|
||||||
#define CTCPSOCKET_H
|
#define CTCPSOCKET_H
|
||||||
|
|
||||||
#include "IDataSocket.h"
|
#include "IDataSocket.h"
|
||||||
#include "CEvent.h"
|
#include "CStreamBuffer.h"
|
||||||
#include "BasicTypes.h"
|
#include "CCondVar.h"
|
||||||
|
#include "CMutex.h"
|
||||||
#include "IArchNetwork.h"
|
#include "IArchNetwork.h"
|
||||||
|
|
||||||
class CMutex;
|
class CMutex;
|
||||||
class CThread;
|
class CThread;
|
||||||
class CBufferedInputStream;
|
|
||||||
class CBufferedOutputStream;
|
|
||||||
class ISocketMultiplexerJob;
|
class ISocketMultiplexerJob;
|
||||||
|
|
||||||
//! TCP data socket
|
//! TCP data socket
|
||||||
|
@ -39,33 +38,34 @@ public:
|
||||||
// ISocket overrides
|
// ISocket overrides
|
||||||
virtual void bind(const CNetworkAddress&);
|
virtual void bind(const CNetworkAddress&);
|
||||||
virtual void close();
|
virtual void close();
|
||||||
virtual void setEventTarget(void*);
|
virtual void* getEventTarget() const;
|
||||||
|
|
||||||
|
// IStream overrides
|
||||||
|
virtual UInt32 read(void* buffer, UInt32 n);
|
||||||
|
virtual void write(const void* buffer, UInt32 n);
|
||||||
|
virtual void flush();
|
||||||
|
virtual void shutdownInput();
|
||||||
|
virtual void shutdownOutput();
|
||||||
|
virtual void setEventFilter(IEventJob* filter);
|
||||||
|
virtual bool isReady() const;
|
||||||
|
virtual UInt32 getSize() const;
|
||||||
|
virtual IEventJob* getEventFilter() const;
|
||||||
|
|
||||||
// IDataSocket overrides
|
// IDataSocket overrides
|
||||||
virtual void connect(const CNetworkAddress&);
|
virtual void connect(const CNetworkAddress&);
|
||||||
virtual IInputStream* getInputStream();
|
|
||||||
virtual IOutputStream* getOutputStream();
|
|
||||||
|
|
||||||
private:
|
private:
|
||||||
enum State {
|
|
||||||
kUnconnected,
|
|
||||||
kConnecting,
|
|
||||||
kReadWrite,
|
|
||||||
kReadOnly,
|
|
||||||
kWriteOnly,
|
|
||||||
kShutdown,
|
|
||||||
kClosed
|
|
||||||
};
|
|
||||||
|
|
||||||
void init();
|
void init();
|
||||||
|
|
||||||
ISocketMultiplexerJob*
|
void setJob(ISocketMultiplexerJob*);
|
||||||
setState(State, bool setJob);
|
ISocketMultiplexerJob* newJob();
|
||||||
|
void sendSocketEvent(CEvent::Type);
|
||||||
|
void sendStreamEvent(CEvent::Type);
|
||||||
|
|
||||||
void closeInput(void*);
|
void onConnected();
|
||||||
void closeOutput(void*);
|
void onInputShutdown();
|
||||||
void emptyInput(void*);
|
void onOutputShutdown();
|
||||||
void fillOutput(void*);
|
void onDisconnected();
|
||||||
|
|
||||||
ISocketMultiplexerJob*
|
ISocketMultiplexerJob*
|
||||||
serviceConnecting(ISocketMultiplexerJob*,
|
serviceConnecting(ISocketMultiplexerJob*,
|
||||||
|
@ -74,25 +74,16 @@ private:
|
||||||
serviceConnected(ISocketMultiplexerJob*,
|
serviceConnected(ISocketMultiplexerJob*,
|
||||||
bool, bool, bool);
|
bool, bool, bool);
|
||||||
|
|
||||||
typedef ISocketMultiplexerJob* (CTCPSocket::*JobFunc)(
|
|
||||||
ISocketMultiplexerJob*,
|
|
||||||
bool, bool, bool);
|
|
||||||
ISocketMultiplexerJob*
|
|
||||||
newMultiplexerJob(JobFunc,
|
|
||||||
bool readable, bool writable);
|
|
||||||
|
|
||||||
void sendEvent(CEvent::Type);
|
|
||||||
|
|
||||||
private:
|
private:
|
||||||
|
CMutex m_mutex;
|
||||||
CArchSocket m_socket;
|
CArchSocket m_socket;
|
||||||
CBufferedInputStream* m_input;
|
CStreamBuffer m_inputBuffer;
|
||||||
CBufferedOutputStream* m_output;
|
CStreamBuffer m_outputBuffer;
|
||||||
|
CCondVar<bool> m_flushed;
|
||||||
CMutex* m_mutex;
|
bool m_connected;
|
||||||
State m_state;
|
bool m_readable;
|
||||||
void* m_target;
|
bool m_writable;
|
||||||
|
IEventJob* m_eventFilter;
|
||||||
ISocketMultiplexerJob* m_job;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -20,9 +20,6 @@
|
||||||
|
|
||||||
CEvent::Type IDataSocket::s_connectedEvent = CEvent::kUnknown;
|
CEvent::Type IDataSocket::s_connectedEvent = CEvent::kUnknown;
|
||||||
CEvent::Type IDataSocket::s_failedEvent = CEvent::kUnknown;
|
CEvent::Type IDataSocket::s_failedEvent = CEvent::kUnknown;
|
||||||
CEvent::Type IDataSocket::s_inputEvent = CEvent::kUnknown;
|
|
||||||
CEvent::Type IDataSocket::s_shutdownInputEvent = CEvent::kUnknown;
|
|
||||||
CEvent::Type IDataSocket::s_shutdownOutputEvent = CEvent::kUnknown;
|
|
||||||
|
|
||||||
CEvent::Type
|
CEvent::Type
|
||||||
IDataSocket::getConnectedEvent()
|
IDataSocket::getConnectedEvent()
|
||||||
|
@ -35,21 +32,3 @@ IDataSocket::getConnectionFailedEvent()
|
||||||
{
|
{
|
||||||
return CEvent::registerTypeOnce(s_failedEvent);
|
return CEvent::registerTypeOnce(s_failedEvent);
|
||||||
}
|
}
|
||||||
|
|
||||||
CEvent::Type
|
|
||||||
IDataSocket::getInputEvent()
|
|
||||||
{
|
|
||||||
return CEvent::registerTypeOnce(s_inputEvent);
|
|
||||||
}
|
|
||||||
|
|
||||||
CEvent::Type
|
|
||||||
IDataSocket::getShutdownInputEvent()
|
|
||||||
{
|
|
||||||
return CEvent::registerTypeOnce(s_shutdownInputEvent);
|
|
||||||
}
|
|
||||||
|
|
||||||
CEvent::Type
|
|
||||||
IDataSocket::getShutdownOutputEvent()
|
|
||||||
{
|
|
||||||
return CEvent::registerTypeOnce(s_shutdownOutputEvent);
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,6 +1,6 @@
|
||||||
/*
|
/*
|
||||||
* synergy -- mouse and keyboard sharing utility
|
* synergy -- mouse and keyboard sharing utility
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
*
|
*
|
||||||
* This package is free software; you can redistribute it and/or
|
* This package is free software; you can redistribute it and/or
|
||||||
* modify it under the terms of the GNU General Public License
|
* modify it under the terms of the GNU General Public License
|
||||||
|
@ -16,44 +16,27 @@
|
||||||
#define IDATASOCKET_H
|
#define IDATASOCKET_H
|
||||||
|
|
||||||
#include "ISocket.h"
|
#include "ISocket.h"
|
||||||
|
#include "IStream.h"
|
||||||
class IInputStream;
|
|
||||||
class IOutputStream;
|
|
||||||
|
|
||||||
//! Data stream socket interface
|
//! Data stream socket interface
|
||||||
/*!
|
/*!
|
||||||
This interface defines the methods common to all network sockets that
|
This interface defines the methods common to all network sockets that
|
||||||
represent a full-duplex data stream.
|
represent a full-duplex data stream.
|
||||||
*/
|
*/
|
||||||
class IDataSocket : public ISocket {
|
class IDataSocket : public ISocket, public IStream {
|
||||||
public:
|
public:
|
||||||
//! @name manipulators
|
//! @name manipulators
|
||||||
//@{
|
//@{
|
||||||
|
|
||||||
//! Connect socket
|
//! Connect socket
|
||||||
/*!
|
/*!
|
||||||
Attempt to connect to a remote endpoint. This waits until the
|
Attempt to connect to a remote endpoint. This returns immediately
|
||||||
connection is established or fails. If it fails it throws an
|
and sends a connected event when successful or a connection failed
|
||||||
XSocketConnect exception.
|
event when it fails. The stream acts as if shutdown for input and
|
||||||
|
output until the stream connects.
|
||||||
(cancellation point)
|
|
||||||
*/
|
*/
|
||||||
virtual void connect(const CNetworkAddress&) = 0;
|
virtual void connect(const CNetworkAddress&) = 0;
|
||||||
|
|
||||||
//! Get input stream
|
|
||||||
/*!
|
|
||||||
Returns the input stream for reading from the socket. Closing this
|
|
||||||
stream will shutdown the socket for reading.
|
|
||||||
*/
|
|
||||||
virtual IInputStream* getInputStream() = 0;
|
|
||||||
|
|
||||||
//! Get output stream
|
|
||||||
/*!
|
|
||||||
Returns the output stream for writing to the socket. Closing this
|
|
||||||
stream will shutdown the socket for writing.
|
|
||||||
*/
|
|
||||||
virtual IOutputStream* getOutputStream() = 0;
|
|
||||||
|
|
||||||
//@}
|
//@}
|
||||||
//! @name accessors
|
//! @name accessors
|
||||||
//@{
|
//@{
|
||||||
|
@ -72,42 +55,27 @@ public:
|
||||||
*/
|
*/
|
||||||
static CEvent::Type getConnectionFailedEvent();
|
static CEvent::Type getConnectionFailedEvent();
|
||||||
|
|
||||||
//! Get input event type
|
|
||||||
/*!
|
|
||||||
Returns the socket input event type. A socket sends this
|
|
||||||
event when data is available to read from the input stream.
|
|
||||||
*/
|
|
||||||
static CEvent::Type getInputEvent();
|
|
||||||
|
|
||||||
//! Get shutdown input event type
|
|
||||||
/*!
|
|
||||||
Returns the socket shutdown input event type. A socket sends this
|
|
||||||
event when the remote side of the connection has shutdown for
|
|
||||||
writing and there is no more data to read from the socket.
|
|
||||||
*/
|
|
||||||
static CEvent::Type getShutdownInputEvent();
|
|
||||||
|
|
||||||
//! Get shutdown input event type
|
|
||||||
/*!
|
|
||||||
Returns the socket shutdown input event type. A socket sends this
|
|
||||||
event when the remote side of the connection has shutdown for
|
|
||||||
writing and there is no more data to read from the socket.
|
|
||||||
*/
|
|
||||||
static CEvent::Type getShutdownOutputEvent();
|
|
||||||
|
|
||||||
//@}
|
//@}
|
||||||
|
|
||||||
// ISocket overrides
|
// ISocket overrides
|
||||||
virtual void bind(const CNetworkAddress&) = 0;
|
virtual void bind(const CNetworkAddress&) = 0;
|
||||||
virtual void close() = 0;
|
virtual void close() = 0;
|
||||||
virtual void setEventTarget(void*) = 0;
|
virtual void* getEventTarget() const = 0;
|
||||||
|
|
||||||
|
// IStream overrides
|
||||||
|
virtual UInt32 read(void* buffer, UInt32 n) = 0;
|
||||||
|
virtual void write(const void* buffer, UInt32 n) = 0;
|
||||||
|
virtual void flush() = 0;
|
||||||
|
virtual void shutdownInput() = 0;
|
||||||
|
virtual void shutdownOutput() = 0;
|
||||||
|
virtual void setEventFilter(IEventJob* filter) = 0;
|
||||||
|
virtual bool isReady() const = 0;
|
||||||
|
virtual UInt32 getSize() const = 0;
|
||||||
|
virtual IEventJob* getEventFilter() const = 0;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
static CEvent::Type s_connectedEvent;
|
static CEvent::Type s_connectedEvent;
|
||||||
static CEvent::Type s_failedEvent;
|
static CEvent::Type s_failedEvent;
|
||||||
static CEvent::Type s_inputEvent;
|
|
||||||
static CEvent::Type s_shutdownInputEvent;
|
|
||||||
static CEvent::Type s_shutdownOutputEvent;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -53,7 +53,7 @@ public:
|
||||||
// ISocket overrides
|
// ISocket overrides
|
||||||
virtual void bind(const CNetworkAddress&) = 0;
|
virtual void bind(const CNetworkAddress&) = 0;
|
||||||
virtual void close() = 0;
|
virtual void close() = 0;
|
||||||
virtual void setEventTarget(void*) = 0;
|
virtual void* getEventTarget() const = 0;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
static CEvent::Type s_connectingEvent;
|
static CEvent::Type s_connectingEvent;
|
||||||
|
|
|
@ -23,6 +23,7 @@ class CNetworkAddress;
|
||||||
//! Generic socket interface
|
//! Generic socket interface
|
||||||
/*!
|
/*!
|
||||||
This interface defines the methods common to all network sockets.
|
This interface defines the methods common to all network sockets.
|
||||||
|
Generated events use \c this as the target.
|
||||||
*/
|
*/
|
||||||
class ISocket : public IInterface {
|
class ISocket : public IInterface {
|
||||||
public:
|
public:
|
||||||
|
@ -41,21 +42,21 @@ public:
|
||||||
*/
|
*/
|
||||||
virtual void close() = 0;
|
virtual void close() = 0;
|
||||||
|
|
||||||
//! Set the socket's event target
|
|
||||||
/*!
|
|
||||||
Sets the target of any events sent by the socket. The default is NULL.
|
|
||||||
*/
|
|
||||||
virtual void setEventTarget(void*) = 0;
|
|
||||||
|
|
||||||
//@}
|
//@}
|
||||||
//! @name accessors
|
//! @name accessors
|
||||||
//@{
|
//@{
|
||||||
|
|
||||||
|
//! Get event target
|
||||||
|
/*!
|
||||||
|
Returns the event target for events generated by this socket.
|
||||||
|
*/
|
||||||
|
virtual void* getEventTarget() const = 0;
|
||||||
|
|
||||||
//! Get disconnected event type
|
//! Get disconnected event type
|
||||||
/*!
|
/*!
|
||||||
Returns the socket disconnected event type. A socket sends this
|
Returns the socket disconnected event type. A socket sends this
|
||||||
event when the remote side of the socket has disconnected or
|
event when the remote side of the socket has disconnected or
|
||||||
shutdown.
|
shutdown both input and output.
|
||||||
*/
|
*/
|
||||||
static CEvent::Type getDisconnectedEvent();
|
static CEvent::Type getDisconnectedEvent();
|
||||||
|
|
||||||
|
|
|
@ -0,0 +1,75 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef ISOCKETMULTIPLEXERJOB_H
|
||||||
|
#define ISOCKETMULTIPLEXERJOB_H
|
||||||
|
|
||||||
|
#include "IArchNetwork.h"
|
||||||
|
#include "IInterface.h"
|
||||||
|
|
||||||
|
//! Socket multiplexer job
|
||||||
|
/*!
|
||||||
|
A socket multiplexer job handles events on a socket.
|
||||||
|
*/
|
||||||
|
class ISocketMultiplexerJob : public IInterface {
|
||||||
|
public:
|
||||||
|
//! @name manipulators
|
||||||
|
//@{
|
||||||
|
|
||||||
|
//! Handle socket event
|
||||||
|
/*!
|
||||||
|
Called by a socket multiplexer when the socket becomes readable,
|
||||||
|
writable, or has an error. It should return itself if the same
|
||||||
|
job can continue to service events, a new job if the socket must
|
||||||
|
be serviced differently, or NULL if the socket should no longer
|
||||||
|
be serviced. The socket is readable if \p readable is true,
|
||||||
|
writable if \p writable is true, and in error if \p error is
|
||||||
|
true.
|
||||||
|
|
||||||
|
This call must not attempt to directly change the job for this
|
||||||
|
socket by calling \c addSocket() or \c removeSocket() on the
|
||||||
|
multiplexer. It must instead return the new job. It can,
|
||||||
|
however, add or remove jobs for other sockets.
|
||||||
|
*/
|
||||||
|
virtual ISocketMultiplexerJob*
|
||||||
|
run(bool readable, bool writable, bool error) = 0;
|
||||||
|
|
||||||
|
//@}
|
||||||
|
//! @name accessors
|
||||||
|
//@{
|
||||||
|
|
||||||
|
//! Get the socket
|
||||||
|
/*!
|
||||||
|
Return the socket to multiplex
|
||||||
|
*/
|
||||||
|
virtual CArchSocket getSocket() const = 0;
|
||||||
|
|
||||||
|
//! Check for interest in readability
|
||||||
|
/*!
|
||||||
|
Return true if the job is interested in being run if the socket
|
||||||
|
becomes readable.
|
||||||
|
*/
|
||||||
|
virtual bool isReadable() const = 0;
|
||||||
|
|
||||||
|
//! Check for interest in writability
|
||||||
|
/*!
|
||||||
|
Return true if the job is interested in being run if the socket
|
||||||
|
becomes writable.
|
||||||
|
*/
|
||||||
|
virtual bool isWritable() const = 0;
|
||||||
|
|
||||||
|
//@}
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif
|
|
@ -0,0 +1,108 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef TSOCKERMULTIPLEXERMETHODJOB_H
|
||||||
|
#define TSOCKERMULTIPLEXERMETHODJOB_H
|
||||||
|
|
||||||
|
#include "ISocketMultiplexerJob.h"
|
||||||
|
#include "CArch.h"
|
||||||
|
|
||||||
|
//! Use a method as a socket multiplexer job
|
||||||
|
/*!
|
||||||
|
A socket multiplexer job class that invokes a member function.
|
||||||
|
*/
|
||||||
|
template <class T>
|
||||||
|
class TSocketMultiplexerMethodJob : public ISocketMultiplexerJob {
|
||||||
|
public:
|
||||||
|
typedef ISocketMultiplexerJob*
|
||||||
|
(T::*Method)(ISocketMultiplexerJob*, bool, bool, bool);
|
||||||
|
|
||||||
|
//! run() invokes \c object->method(arg)
|
||||||
|
TSocketMultiplexerMethodJob(T* object, Method method,
|
||||||
|
CArchSocket socket, bool readable, bool writeable);
|
||||||
|
virtual ~TSocketMultiplexerMethodJob();
|
||||||
|
|
||||||
|
// IJob overrides
|
||||||
|
virtual ISocketMultiplexerJob*
|
||||||
|
run(bool readable, bool writable, bool error);
|
||||||
|
virtual CArchSocket getSocket() const;
|
||||||
|
virtual bool isReadable() const;
|
||||||
|
virtual bool isWritable() const;
|
||||||
|
|
||||||
|
private:
|
||||||
|
T* m_object;
|
||||||
|
Method m_method;
|
||||||
|
CArchSocket m_socket;
|
||||||
|
bool m_readable;
|
||||||
|
bool m_writable;
|
||||||
|
void* m_arg;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
inline
|
||||||
|
TSocketMultiplexerMethodJob<T>::TSocketMultiplexerMethodJob(T* object,
|
||||||
|
Method method, CArchSocket socket,
|
||||||
|
bool readable, bool writable) :
|
||||||
|
m_object(object),
|
||||||
|
m_method(method),
|
||||||
|
m_socket(ARCH->copySocket(socket)),
|
||||||
|
m_readable(readable),
|
||||||
|
m_writable(writable)
|
||||||
|
{
|
||||||
|
// do nothing
|
||||||
|
}
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
inline
|
||||||
|
TSocketMultiplexerMethodJob<T>::~TSocketMultiplexerMethodJob()
|
||||||
|
{
|
||||||
|
ARCH->closeSocket(m_socket);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
inline
|
||||||
|
ISocketMultiplexerJob*
|
||||||
|
TSocketMultiplexerMethodJob<T>::run(bool read, bool write, bool error)
|
||||||
|
{
|
||||||
|
if (m_object != NULL) {
|
||||||
|
return (m_object->*m_method)(this, read, write, error);
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
inline
|
||||||
|
CArchSocket
|
||||||
|
TSocketMultiplexerMethodJob<T>::getSocket() const
|
||||||
|
{
|
||||||
|
return m_socket;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
inline
|
||||||
|
bool
|
||||||
|
TSocketMultiplexerMethodJob<T>::isReadable() const
|
||||||
|
{
|
||||||
|
return m_readable;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
inline
|
||||||
|
bool
|
||||||
|
TSocketMultiplexerMethodJob<T>::isWritable() const
|
||||||
|
{
|
||||||
|
return m_writable;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
|
@ -13,27 +13,24 @@
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "CClientProxy.h"
|
#include "CClientProxy.h"
|
||||||
#include "IInputStream.h"
|
#include "IStream.h"
|
||||||
#include "IOutputStream.h"
|
|
||||||
|
|
||||||
//
|
//
|
||||||
// CClientProxy
|
// CClientProxy
|
||||||
//
|
//
|
||||||
|
|
||||||
CClientProxy::CClientProxy(IServer* server, const CString& name,
|
CClientProxy::CClientProxy(IServer* server,
|
||||||
IInputStream* input, IOutputStream* output) :
|
const CString& name, IStream* stream) :
|
||||||
m_server(server),
|
m_server(server),
|
||||||
m_name(name),
|
m_name(name),
|
||||||
m_input(input),
|
m_stream(stream)
|
||||||
m_output(output)
|
|
||||||
{
|
{
|
||||||
// do nothing
|
// do nothing
|
||||||
}
|
}
|
||||||
|
|
||||||
CClientProxy::~CClientProxy()
|
CClientProxy::~CClientProxy()
|
||||||
{
|
{
|
||||||
delete m_output;
|
delete m_stream;
|
||||||
delete m_input;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
IServer*
|
IServer*
|
||||||
|
@ -42,16 +39,10 @@ CClientProxy::getServer() const
|
||||||
return m_server;
|
return m_server;
|
||||||
}
|
}
|
||||||
|
|
||||||
IInputStream*
|
IStream*
|
||||||
CClientProxy::getInputStream() const
|
CClientProxy::getStream() const
|
||||||
{
|
{
|
||||||
return m_input;
|
return m_stream;
|
||||||
}
|
|
||||||
|
|
||||||
IOutputStream*
|
|
||||||
CClientProxy::getOutputStream() const
|
|
||||||
{
|
|
||||||
return m_output;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
CString
|
CString
|
||||||
|
|
|
@ -19,8 +19,7 @@
|
||||||
#include "CMutex.h"
|
#include "CMutex.h"
|
||||||
#include "CString.h"
|
#include "CString.h"
|
||||||
|
|
||||||
class IInputStream;
|
class IStream;
|
||||||
class IOutputStream;
|
|
||||||
class IServer;
|
class IServer;
|
||||||
|
|
||||||
//! Generic proxy for client
|
//! Generic proxy for client
|
||||||
|
@ -29,9 +28,7 @@ public:
|
||||||
/*!
|
/*!
|
||||||
\c name is the name of the client.
|
\c name is the name of the client.
|
||||||
*/
|
*/
|
||||||
CClientProxy(IServer* server, const CString& name,
|
CClientProxy(IServer* server, const CString& name, IStream* adoptedStream);
|
||||||
IInputStream* adoptedInput,
|
|
||||||
IOutputStream* adoptedOutput);
|
|
||||||
~CClientProxy();
|
~CClientProxy();
|
||||||
|
|
||||||
//! @name accessors
|
//! @name accessors
|
||||||
|
@ -43,17 +40,11 @@ public:
|
||||||
*/
|
*/
|
||||||
IServer* getServer() const;
|
IServer* getServer() const;
|
||||||
|
|
||||||
//! Get input stream
|
//! Get stream
|
||||||
/*!
|
/*!
|
||||||
Returns the input stream passed to the c'tor.
|
Returns the stream passed to the c'tor.
|
||||||
*/
|
*/
|
||||||
IInputStream* getInputStream() const;
|
IStream* getStream() const;
|
||||||
|
|
||||||
//! Get output stream
|
|
||||||
/*!
|
|
||||||
Returns the output stream passed to the c'tor.
|
|
||||||
*/
|
|
||||||
IOutputStream* getOutputStream() const;
|
|
||||||
|
|
||||||
//@}
|
//@}
|
||||||
|
|
||||||
|
@ -98,8 +89,7 @@ private:
|
||||||
CMutex m_mutex;
|
CMutex m_mutex;
|
||||||
IServer* m_server;
|
IServer* m_server;
|
||||||
CString m_name;
|
CString m_name;
|
||||||
IInputStream* m_input;
|
IStream* m_stream;
|
||||||
IOutputStream* m_output;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -17,46 +17,189 @@
|
||||||
#include "CClipboard.h"
|
#include "CClipboard.h"
|
||||||
#include "CProtocolUtil.h"
|
#include "CProtocolUtil.h"
|
||||||
#include "XSynergy.h"
|
#include "XSynergy.h"
|
||||||
#include "IInputStream.h"
|
#include "IStream.h"
|
||||||
#include "IOutputStream.h"
|
|
||||||
#include "CLock.h"
|
#include "CLock.h"
|
||||||
#include "CThread.h"
|
|
||||||
#include "CLog.h"
|
#include "CLog.h"
|
||||||
#include "CStopwatch.h"
|
#include "IEventQueue.h"
|
||||||
|
#include "TMethodEventJob.h"
|
||||||
#include <cstring>
|
#include <cstring>
|
||||||
|
|
||||||
//
|
//
|
||||||
// CClientProxy1_0
|
// CClientProxy1_0
|
||||||
//
|
//
|
||||||
|
|
||||||
CClientProxy1_0::CClientProxy1_0(IServer* server, const CString& name,
|
CClientProxy1_0::CClientProxy1_0(IServer* server,
|
||||||
IInputStream* input, IOutputStream* output) :
|
const CString& name, IStream* stream) :
|
||||||
CClientProxy(server, name, input, output),
|
CClientProxy(server, name, stream),
|
||||||
m_heartRate(kHeartRate),
|
m_heartbeatAlarm(kHeartRate * kHeartBeatsUntilDeath),
|
||||||
m_heartDeath(kHeartRate * kHeartBeatsUntilDeath)
|
m_heartbeatTimer(NULL)
|
||||||
{
|
{
|
||||||
for (UInt32 i = 0; i < kClipboardEnd; ++i) {
|
for (UInt32 i = 0; i < kClipboardEnd; ++i) {
|
||||||
m_clipboardDirty[i] = true;
|
m_clipboardDirty[i] = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// install event handlers
|
||||||
|
EVENTQUEUE->adoptHandler(IStream::getInputReadyEvent(),
|
||||||
|
stream->getEventTarget(),
|
||||||
|
new TMethodEventJob<CClientProxy1_0>(this,
|
||||||
|
&CClientProxy1_0::handleData, NULL));
|
||||||
|
EVENTQUEUE->adoptHandler(IStream::getOutputErrorEvent(),
|
||||||
|
stream->getEventTarget(),
|
||||||
|
new TMethodEventJob<CClientProxy1_0>(this,
|
||||||
|
&CClientProxy1_0::handleWriteError, NULL));
|
||||||
|
EVENTQUEUE->adoptHandler(IStream::getInputShutdownEvent(),
|
||||||
|
stream->getEventTarget(),
|
||||||
|
new TMethodEventJob<CClientProxy1_0>(this,
|
||||||
|
&CClientProxy1_0::handleDisconnect, NULL));
|
||||||
|
EVENTQUEUE->adoptHandler(IStream::getOutputShutdownEvent(),
|
||||||
|
stream->getEventTarget(),
|
||||||
|
new TMethodEventJob<CClientProxy1_0>(this,
|
||||||
|
&CClientProxy1_0::handleWriteError, NULL));
|
||||||
|
EVENTQUEUE->adoptHandler(CEvent::kTimer, this,
|
||||||
|
new TMethodEventJob<CClientProxy1_0>(this,
|
||||||
|
&CClientProxy1_0::handleFlatline, NULL));
|
||||||
|
|
||||||
|
// FIXME -- open() replacement must install initial heartbeat timer
|
||||||
}
|
}
|
||||||
|
|
||||||
CClientProxy1_0::~CClientProxy1_0()
|
CClientProxy1_0::~CClientProxy1_0()
|
||||||
{
|
{
|
||||||
// do nothing
|
removeHandlers();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CClientProxy1_0::disconnect()
|
||||||
|
{
|
||||||
|
CLock lock(getMutex());
|
||||||
|
removeHandlers();
|
||||||
|
// FIXME -- send disconnect event (server should be listening for this)
|
||||||
|
getStream()->flush();
|
||||||
|
getStream()->close();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CClientProxy1_0::removeHandlers()
|
||||||
|
{
|
||||||
|
// uninstall event handlers
|
||||||
|
EVENTQUEUE->removeHandler(IStream::getInputReadyEvent(),
|
||||||
|
getStream()->getEventTarget());
|
||||||
|
EVENTQUEUE->removeHandler(IStream::getOutputErrorEvent(),
|
||||||
|
getStream()->getEventTarget());
|
||||||
|
EVENTQUEUE->removeHandler(IStream::getInputShutdownEvent(),
|
||||||
|
getStream()->getEventTarget());
|
||||||
|
EVENTQUEUE->removeHandler(IStream::getOutputShutdownEvent(),
|
||||||
|
getStream()->getEventTarget());
|
||||||
|
EVENTQUEUE->removeHandler(CEvent::kTimer, this);
|
||||||
|
|
||||||
|
// remove timer
|
||||||
|
removeHeartbeatTimer();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CClientProxy1_0::addHeartbeatTimer()
|
||||||
|
{
|
||||||
|
CLock lock(getMutex());
|
||||||
|
if (m_heartbeatAlarm > 0.0) {
|
||||||
|
m_heartbeatTimer = EVENTQUEUE->newOneShotTimer(m_heartbeatAlarm, this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CClientProxy1_0::removeHeartbeatTimer()
|
||||||
|
{
|
||||||
|
CLock lock(getMutex());
|
||||||
|
if (m_heartbeatTimer != NULL) {
|
||||||
|
EVENTQUEUE->deleteTimer(m_heartbeatTimer);
|
||||||
|
m_heartbeatTimer = NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CClientProxy1_0::handleData(const CEvent&, void*)
|
||||||
|
{
|
||||||
|
// handle messages until there are no more. first read message code.
|
||||||
|
UInt8 code[4];
|
||||||
|
UInt32 n = getStream()->read(code, 4);
|
||||||
|
while (n != 0) {
|
||||||
|
// verify we got an entire code
|
||||||
|
if (n != 4) {
|
||||||
|
LOG((CLOG_ERR "incomplete message from \"%s\": %d bytes", getName().c_str(), n));
|
||||||
|
disconnect();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// parse message
|
||||||
|
LOG((CLOG_DEBUG2 "msg from \"%s\": %c%c%c%c", getName().c_str(), code[0], code[1], code[2], code[3]));
|
||||||
|
if (!parseMessage(code)) {
|
||||||
|
LOG((CLOG_ERR "invalid message from client \"%s\"", getName().c_str()));
|
||||||
|
disconnect();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// next message
|
||||||
|
n = getStream()->read(code, 4);
|
||||||
|
}
|
||||||
|
|
||||||
|
// restart heartbeat timer
|
||||||
|
removeHeartbeatTimer();
|
||||||
|
addHeartbeatTimer();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool
|
||||||
|
CClientProxy1_0::parseMessage(const UInt8* code)
|
||||||
|
{
|
||||||
|
if (memcmp(code, kMsgDInfo, 4) == 0) {
|
||||||
|
return recvInfo(true);
|
||||||
|
}
|
||||||
|
else if (memcmp(code, kMsgCNoop, 4) == 0) {
|
||||||
|
// discard no-ops
|
||||||
|
LOG((CLOG_DEBUG2 "no-op from", getName().c_str()));
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
else if (memcmp(code, kMsgCClipboard, 4) == 0) {
|
||||||
|
return recvGrabClipboard();
|
||||||
|
}
|
||||||
|
else if (memcmp(code, kMsgDClipboard, 4) == 0) {
|
||||||
|
return recvClipboard();
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CClientProxy1_0::handleDisconnect(const CEvent&, void*)
|
||||||
|
{
|
||||||
|
LOG((CLOG_NOTE "client \"%s\" disconnected", getName().c_str()));
|
||||||
|
disconnect();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CClientProxy1_0::handleWriteError(const CEvent&, void*)
|
||||||
|
{
|
||||||
|
LOG((CLOG_ERR "error writing to client \"%s\"", getName().c_str()));
|
||||||
|
disconnect();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CClientProxy1_0::handleFlatline(const CEvent&, void*)
|
||||||
|
{
|
||||||
|
// didn't get a heartbeat fast enough. assume client is dead.
|
||||||
|
LOG((CLOG_NOTE "client \"%s\" is dead", getName().c_str()));
|
||||||
|
disconnect();
|
||||||
|
}
|
||||||
|
|
||||||
|
// FIXME -- replace this
|
||||||
void
|
void
|
||||||
CClientProxy1_0::open()
|
CClientProxy1_0::open()
|
||||||
{
|
{
|
||||||
// send request
|
// send request
|
||||||
LOG((CLOG_DEBUG1 "querying client \"%s\" info", getName().c_str()));
|
LOG((CLOG_DEBUG1 "querying client \"%s\" info", getName().c_str()));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgQInfo);
|
CProtocolUtil::writef(getStream(), kMsgQInfo);
|
||||||
getOutputStream()->flush();
|
getStream()->flush();
|
||||||
|
|
||||||
// wait for and verify reply
|
// wait for and verify reply
|
||||||
UInt8 code[4];
|
UInt8 code[4];
|
||||||
for (;;) {
|
for (;;) {
|
||||||
UInt32 n = getInputStream()->read(code, 4, -1.0);
|
UInt32 n = getStream()->read(code, 4);
|
||||||
if (n == 4) {
|
if (n == 4) {
|
||||||
if (memcmp(code, kMsgCNoop, 4) == 0) {
|
if (memcmp(code, kMsgCNoop, 4) == 0) {
|
||||||
// discard heartbeats
|
// discard heartbeats
|
||||||
|
@ -73,79 +216,15 @@ CClientProxy1_0::open()
|
||||||
recvInfo(false);
|
recvInfo(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
// FIXME -- replace this
|
||||||
CClientProxy1_0::mainLoop()
|
|
||||||
{
|
|
||||||
// handle messages until the client hangs up or stops sending heartbeats
|
|
||||||
CStopwatch heartTimer;
|
|
||||||
for (;;) {
|
|
||||||
CThread::testCancel();
|
|
||||||
|
|
||||||
// wait for a message
|
|
||||||
UInt8 code[4];
|
|
||||||
UInt32 n = getInputStream()->read(code, 4, m_heartRate);
|
|
||||||
CThread::testCancel();
|
|
||||||
|
|
||||||
// check if client hungup
|
|
||||||
if (n == 0) {
|
|
||||||
LOG((CLOG_NOTE "client \"%s\" disconnected", getName().c_str()));
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// check if client has stopped sending heartbeats
|
|
||||||
if (n == (UInt32)-1) {
|
|
||||||
if (m_heartDeath >= 0.0 && heartTimer.getTime() > m_heartDeath) {
|
|
||||||
LOG((CLOG_NOTE "client \"%s\" is dead", getName().c_str()));
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// got a message so reset heartbeat monitor
|
|
||||||
heartTimer.reset();
|
|
||||||
|
|
||||||
// verify we got an entire code
|
|
||||||
if (n != 4) {
|
|
||||||
LOG((CLOG_ERR "incomplete message from \"%s\": %d bytes", getName().c_str(), n));
|
|
||||||
|
|
||||||
// client sent an incomplete message
|
|
||||||
throw XBadClient();
|
|
||||||
}
|
|
||||||
|
|
||||||
// parse message
|
|
||||||
LOG((CLOG_DEBUG2 "msg from \"%s\": %c%c%c%c", getName().c_str(), code[0], code[1], code[2], code[3]));
|
|
||||||
if (memcmp(code, kMsgDInfo, 4) == 0) {
|
|
||||||
recvInfo(true);
|
|
||||||
}
|
|
||||||
else if (memcmp(code, kMsgCNoop, 4) == 0) {
|
|
||||||
// discard no-ops
|
|
||||||
LOG((CLOG_DEBUG2 "no-op from", getName().c_str()));
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
else if (memcmp(code, kMsgCClipboard, 4) == 0) {
|
|
||||||
recvGrabClipboard();
|
|
||||||
}
|
|
||||||
else if (memcmp(code, kMsgDClipboard, 4) == 0) {
|
|
||||||
recvClipboard();
|
|
||||||
}
|
|
||||||
// note -- more message handlers go here
|
|
||||||
else {
|
|
||||||
LOG((CLOG_ERR "invalid message from client \"%s\"", getName().c_str()));
|
|
||||||
|
|
||||||
// unknown message
|
|
||||||
throw XBadClient();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_0::close()
|
CClientProxy1_0::close()
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send close to \"%s\"", getName().c_str()));
|
LOG((CLOG_DEBUG1 "send close to \"%s\"", getName().c_str()));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgCClose);
|
CProtocolUtil::writef(getStream(), kMsgCClose);
|
||||||
|
|
||||||
// force the close to be sent before we return
|
// force the close to be sent before we return
|
||||||
getOutputStream()->flush();
|
getStream()->flush();
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
@ -153,7 +232,7 @@ CClientProxy1_0::enter(SInt32 xAbs, SInt32 yAbs,
|
||||||
UInt32 seqNum, KeyModifierMask mask, bool)
|
UInt32 seqNum, KeyModifierMask mask, bool)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send enter to \"%s\", %d,%d %d %04x", getName().c_str(), xAbs, yAbs, seqNum, mask));
|
LOG((CLOG_DEBUG1 "send enter to \"%s\", %d,%d %d %04x", getName().c_str(), xAbs, yAbs, seqNum, mask));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgCEnter,
|
CProtocolUtil::writef(getStream(), kMsgCEnter,
|
||||||
xAbs, yAbs, seqNum, mask);
|
xAbs, yAbs, seqNum, mask);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -161,7 +240,7 @@ bool
|
||||||
CClientProxy1_0::leave()
|
CClientProxy1_0::leave()
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send leave to \"%s\"", getName().c_str()));
|
LOG((CLOG_DEBUG1 "send leave to \"%s\"", getName().c_str()));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgCLeave);
|
CProtocolUtil::writef(getStream(), kMsgCLeave);
|
||||||
|
|
||||||
// we can never prevent the user from leaving
|
// we can never prevent the user from leaving
|
||||||
return true;
|
return true;
|
||||||
|
@ -177,7 +256,7 @@ CClientProxy1_0::setClipboard(ClipboardID id, const CString& data)
|
||||||
m_clipboardDirty[id] = false;
|
m_clipboardDirty[id] = false;
|
||||||
|
|
||||||
LOG((CLOG_DEBUG "send clipboard %d to \"%s\" size=%d", id, getName().c_str(), data.size()));
|
LOG((CLOG_DEBUG "send clipboard %d to \"%s\" size=%d", id, getName().c_str(), data.size()));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDClipboard, id, 0, &data);
|
CProtocolUtil::writef(getStream(), kMsgDClipboard, id, 0, &data);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -185,7 +264,7 @@ void
|
||||||
CClientProxy1_0::grabClipboard(ClipboardID id)
|
CClientProxy1_0::grabClipboard(ClipboardID id)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG "send grab clipboard %d to \"%s\"", id, getName().c_str()));
|
LOG((CLOG_DEBUG "send grab clipboard %d to \"%s\"", id, getName().c_str()));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgCClipboard, id, 0);
|
CProtocolUtil::writef(getStream(), kMsgCClipboard, id, 0);
|
||||||
|
|
||||||
// this clipboard is now dirty
|
// this clipboard is now dirty
|
||||||
CLock lock(getMutex());
|
CLock lock(getMutex());
|
||||||
|
@ -203,7 +282,7 @@ void
|
||||||
CClientProxy1_0::keyDown(KeyID key, KeyModifierMask mask, KeyButton)
|
CClientProxy1_0::keyDown(KeyID key, KeyModifierMask mask, KeyButton)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send key down to \"%s\" id=%d, mask=0x%04x", getName().c_str(), key, mask));
|
LOG((CLOG_DEBUG1 "send key down to \"%s\" id=%d, mask=0x%04x", getName().c_str(), key, mask));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDKeyDown1_0, key, mask);
|
CProtocolUtil::writef(getStream(), kMsgDKeyDown1_0, key, mask);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
@ -211,78 +290,81 @@ CClientProxy1_0::keyRepeat(KeyID key, KeyModifierMask mask,
|
||||||
SInt32 count, KeyButton)
|
SInt32 count, KeyButton)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send key repeat to \"%s\" id=%d, mask=0x%04x, count=%d", getName().c_str(), key, mask, count));
|
LOG((CLOG_DEBUG1 "send key repeat to \"%s\" id=%d, mask=0x%04x, count=%d", getName().c_str(), key, mask, count));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDKeyRepeat1_0, key, mask, count);
|
CProtocolUtil::writef(getStream(), kMsgDKeyRepeat1_0, key, mask, count);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_0::keyUp(KeyID key, KeyModifierMask mask, KeyButton)
|
CClientProxy1_0::keyUp(KeyID key, KeyModifierMask mask, KeyButton)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send key up to \"%s\" id=%d, mask=0x%04x", getName().c_str(), key, mask));
|
LOG((CLOG_DEBUG1 "send key up to \"%s\" id=%d, mask=0x%04x", getName().c_str(), key, mask));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDKeyUp1_0, key, mask);
|
CProtocolUtil::writef(getStream(), kMsgDKeyUp1_0, key, mask);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_0::mouseDown(ButtonID button)
|
CClientProxy1_0::mouseDown(ButtonID button)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send mouse down to \"%s\" id=%d", getName().c_str(), button));
|
LOG((CLOG_DEBUG1 "send mouse down to \"%s\" id=%d", getName().c_str(), button));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDMouseDown, button);
|
CProtocolUtil::writef(getStream(), kMsgDMouseDown, button);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_0::mouseUp(ButtonID button)
|
CClientProxy1_0::mouseUp(ButtonID button)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send mouse up to \"%s\" id=%d", getName().c_str(), button));
|
LOG((CLOG_DEBUG1 "send mouse up to \"%s\" id=%d", getName().c_str(), button));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDMouseUp, button);
|
CProtocolUtil::writef(getStream(), kMsgDMouseUp, button);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_0::mouseMove(SInt32 xAbs, SInt32 yAbs)
|
CClientProxy1_0::mouseMove(SInt32 xAbs, SInt32 yAbs)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG2 "send mouse move to \"%s\" %d,%d", getName().c_str(), xAbs, yAbs));
|
LOG((CLOG_DEBUG2 "send mouse move to \"%s\" %d,%d", getName().c_str(), xAbs, yAbs));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDMouseMove, xAbs, yAbs);
|
CProtocolUtil::writef(getStream(), kMsgDMouseMove, xAbs, yAbs);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_0::mouseWheel(SInt32 delta)
|
CClientProxy1_0::mouseWheel(SInt32 delta)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG2 "send mouse wheel to \"%s\" %+d", getName().c_str(), delta));
|
LOG((CLOG_DEBUG2 "send mouse wheel to \"%s\" %+d", getName().c_str(), delta));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDMouseWheel, delta);
|
CProtocolUtil::writef(getStream(), kMsgDMouseWheel, delta);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_0::screensaver(bool on)
|
CClientProxy1_0::screensaver(bool on)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send screen saver to \"%s\" on=%d", getName().c_str(), on ? 1 : 0));
|
LOG((CLOG_DEBUG1 "send screen saver to \"%s\" on=%d", getName().c_str(), on ? 1 : 0));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgCScreenSaver, on ? 1 : 0);
|
CProtocolUtil::writef(getStream(), kMsgCScreenSaver, on ? 1 : 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_0::resetOptions()
|
CClientProxy1_0::resetOptions()
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send reset options to \"%s\"", getName().c_str()));
|
LOG((CLOG_DEBUG1 "send reset options to \"%s\"", getName().c_str()));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgCResetOptions);
|
CProtocolUtil::writef(getStream(), kMsgCResetOptions);
|
||||||
|
|
||||||
// reset heart rate and death
|
// reset heart rate and death
|
||||||
CLock lock(getMutex());
|
CLock lock(getMutex());
|
||||||
m_heartRate = kHeartRate;
|
m_heartbeatAlarm = kHeartRate * kHeartBeatsUntilDeath;
|
||||||
m_heartDeath = kHeartRate * kHeartBeatsUntilDeath;
|
removeHeartbeatTimer();
|
||||||
|
addHeartbeatTimer();
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_0::setOptions(const COptionsList& options)
|
CClientProxy1_0::setOptions(const COptionsList& options)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send set options to \"%s\" size=%d", getName().c_str(), options.size()));
|
LOG((CLOG_DEBUG1 "send set options to \"%s\" size=%d", getName().c_str(), options.size()));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDSetOptions, &options);
|
CProtocolUtil::writef(getStream(), kMsgDSetOptions, &options);
|
||||||
|
|
||||||
// check options
|
// check options
|
||||||
CLock lock(getMutex());
|
CLock lock(getMutex());
|
||||||
for (UInt32 i = 0, n = options.size(); i < n; i += 2) {
|
for (UInt32 i = 0, n = options.size(); i < n; i += 2) {
|
||||||
if (options[i] == kOptionHeartbeat) {
|
if (options[i] == kOptionHeartbeat) {
|
||||||
m_heartRate = 1.0e-3 * static_cast<double>(options[i + 1]);
|
double rate = 1.0e-3 * static_cast<double>(options[i + 1]);
|
||||||
if (m_heartRate <= 0.0) {
|
if (rate <= 0.0) {
|
||||||
m_heartRate = -1.0;
|
rate = -1.0;
|
||||||
}
|
}
|
||||||
m_heartDeath = m_heartRate * kHeartBeatsUntilDeath;
|
m_heartbeatAlarm = rate * kHeartBeatsUntilDeath;
|
||||||
|
removeHeartbeatTimer();
|
||||||
|
addHeartbeatTimer();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -318,7 +400,7 @@ CClientProxy1_0::getCursorCenter(SInt32& x, SInt32& y) const
|
||||||
y = m_info.m_my;
|
y = m_info.m_my;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
bool
|
||||||
CClientProxy1_0::recvInfo(bool notify)
|
CClientProxy1_0::recvInfo(bool notify)
|
||||||
{
|
{
|
||||||
{
|
{
|
||||||
|
@ -326,16 +408,18 @@ CClientProxy1_0::recvInfo(bool notify)
|
||||||
|
|
||||||
// parse the message
|
// parse the message
|
||||||
SInt16 x, y, w, h, zoneSize, mx, my;
|
SInt16 x, y, w, h, zoneSize, mx, my;
|
||||||
CProtocolUtil::readf(getInputStream(), kMsgDInfo + 4,
|
if (!CProtocolUtil::readf(getStream(), kMsgDInfo + 4,
|
||||||
&x, &y, &w, &h, &zoneSize, &mx, &my);
|
&x, &y, &w, &h, &zoneSize, &mx, &my)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
LOG((CLOG_DEBUG "received client \"%s\" info shape=%d,%d %dx%d, zone=%d, pos=%d,%d", getName().c_str(), x, y, w, h, zoneSize, mx, my));
|
LOG((CLOG_DEBUG "received client \"%s\" info shape=%d,%d %dx%d, zone=%d, pos=%d,%d", getName().c_str(), x, y, w, h, zoneSize, mx, my));
|
||||||
|
|
||||||
// validate
|
// validate
|
||||||
if (w <= 0 || h <= 0 || zoneSize < 0) {
|
if (w <= 0 || h <= 0 || zoneSize < 0) {
|
||||||
throw XBadClient();
|
return false;
|
||||||
}
|
}
|
||||||
if (mx < x || my < y || mx >= x + w || my >= y + h) {
|
if (mx < x || my < y || mx >= x + w || my >= y + h) {
|
||||||
throw XBadClient();
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
// save
|
// save
|
||||||
|
@ -355,44 +439,52 @@ CClientProxy1_0::recvInfo(bool notify)
|
||||||
|
|
||||||
// acknowledge receipt
|
// acknowledge receipt
|
||||||
LOG((CLOG_DEBUG1 "send info ack to \"%s\"", getName().c_str()));
|
LOG((CLOG_DEBUG1 "send info ack to \"%s\"", getName().c_str()));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgCInfoAck);
|
CProtocolUtil::writef(getStream(), kMsgCInfoAck);
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
bool
|
||||||
CClientProxy1_0::recvClipboard()
|
CClientProxy1_0::recvClipboard()
|
||||||
{
|
{
|
||||||
// parse message
|
// parse message
|
||||||
ClipboardID id;
|
ClipboardID id;
|
||||||
UInt32 seqNum;
|
UInt32 seqNum;
|
||||||
CString data;
|
CString data;
|
||||||
CProtocolUtil::readf(getInputStream(), kMsgDClipboard + 4, &id, &seqNum, &data);
|
if (!CProtocolUtil::readf(getStream(),
|
||||||
|
kMsgDClipboard + 4, &id, &seqNum, &data)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
LOG((CLOG_DEBUG "received client \"%s\" clipboard %d seqnum=%d, size=%d", getName().c_str(), id, seqNum, data.size()));
|
LOG((CLOG_DEBUG "received client \"%s\" clipboard %d seqnum=%d, size=%d", getName().c_str(), id, seqNum, data.size()));
|
||||||
|
|
||||||
// validate
|
// validate
|
||||||
if (id >= kClipboardEnd) {
|
if (id >= kClipboardEnd) {
|
||||||
throw XBadClient();
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
// send update. this calls us back to reset our clipboard dirty flag
|
// send update. this calls us back to reset our clipboard dirty flag
|
||||||
// so don't hold a lock during the call.
|
// so don't hold a lock during the call.
|
||||||
getServer()->onClipboardChanged(id, seqNum, data);
|
getServer()->onClipboardChanged(id, seqNum, data);
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
bool
|
||||||
CClientProxy1_0::recvGrabClipboard()
|
CClientProxy1_0::recvGrabClipboard()
|
||||||
{
|
{
|
||||||
// parse message
|
// parse message
|
||||||
ClipboardID id;
|
ClipboardID id;
|
||||||
UInt32 seqNum;
|
UInt32 seqNum;
|
||||||
CProtocolUtil::readf(getInputStream(), kMsgCClipboard + 4, &id, &seqNum);
|
if (!CProtocolUtil::readf(getStream(), kMsgCClipboard + 4, &id, &seqNum)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
LOG((CLOG_DEBUG "received client \"%s\" grabbed clipboard %d seqnum=%d", getName().c_str(), id, seqNum));
|
LOG((CLOG_DEBUG "received client \"%s\" grabbed clipboard %d seqnum=%d", getName().c_str(), id, seqNum));
|
||||||
|
|
||||||
// validate
|
// validate
|
||||||
if (id >= kClipboardEnd) {
|
if (id >= kClipboardEnd) {
|
||||||
throw XBadClient();
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
// send update. this calls us back to reset our clipboard dirty flag
|
// send update. this calls us back to reset our clipboard dirty flag
|
||||||
// so don't hold a lock during the call.
|
// so don't hold a lock during the call.
|
||||||
getServer()->onGrabClipboard(getName(), id, seqNum);
|
getServer()->onGrabClipboard(getName(), id, seqNum);
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
|
@ -18,12 +18,14 @@
|
||||||
#include "CClientProxy.h"
|
#include "CClientProxy.h"
|
||||||
#include "ProtocolTypes.h"
|
#include "ProtocolTypes.h"
|
||||||
|
|
||||||
|
class CEvent;
|
||||||
|
class CEventQueueTimer;
|
||||||
|
|
||||||
//! Proxy for client implementing protocol version 1.0
|
//! Proxy for client implementing protocol version 1.0
|
||||||
class CClientProxy1_0 : public CClientProxy {
|
class CClientProxy1_0 : public CClientProxy {
|
||||||
public:
|
public:
|
||||||
CClientProxy1_0(IServer* server, const CString& name,
|
CClientProxy1_0(IServer* server, const CString& name,
|
||||||
IInputStream* adoptedInput,
|
IStream* adoptedStream);
|
||||||
IOutputStream* adoptedOutput);
|
|
||||||
~CClientProxy1_0();
|
~CClientProxy1_0();
|
||||||
|
|
||||||
// IClient overrides
|
// IClient overrides
|
||||||
|
@ -54,16 +56,29 @@ public:
|
||||||
virtual void getCursorPos(SInt32& x, SInt32& y) const;
|
virtual void getCursorPos(SInt32& x, SInt32& y) const;
|
||||||
virtual void getCursorCenter(SInt32& x, SInt32& y) const;
|
virtual void getCursorCenter(SInt32& x, SInt32& y) const;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
virtual bool parseMessage(const UInt8* code);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
void recvInfo(bool notify);
|
void disconnect();
|
||||||
void recvClipboard();
|
void removeHandlers();
|
||||||
void recvGrabClipboard();
|
void addHeartbeatTimer();
|
||||||
|
void removeHeartbeatTimer();
|
||||||
|
|
||||||
|
void handleData(const CEvent&, void*);
|
||||||
|
void handleDisconnect(const CEvent&, void*);
|
||||||
|
void handleWriteError(const CEvent&, void*);
|
||||||
|
void handleFlatline(const CEvent&, void*);
|
||||||
|
|
||||||
|
bool recvInfo(bool notify);
|
||||||
|
bool recvClipboard();
|
||||||
|
bool recvGrabClipboard();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
CClientInfo m_info;
|
CClientInfo m_info;
|
||||||
bool m_clipboardDirty[kClipboardEnd];
|
bool m_clipboardDirty[kClipboardEnd];
|
||||||
double m_heartRate;
|
double m_heartbeatAlarm;
|
||||||
double m_heartDeath;
|
CEventQueueTimer* m_heartbeatTimer;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -21,9 +21,9 @@
|
||||||
// CClientProxy1_1
|
// CClientProxy1_1
|
||||||
//
|
//
|
||||||
|
|
||||||
CClientProxy1_1::CClientProxy1_1(IServer* server, const CString& name,
|
CClientProxy1_1::CClientProxy1_1(IServer* server,
|
||||||
IInputStream* input, IOutputStream* output) :
|
const CString& name, IStream* stream) :
|
||||||
CClientProxy1_0(server, name, input, output)
|
CClientProxy1_0(server, name, stream)
|
||||||
{
|
{
|
||||||
// do nothing
|
// do nothing
|
||||||
}
|
}
|
||||||
|
@ -37,7 +37,7 @@ void
|
||||||
CClientProxy1_1::keyDown(KeyID key, KeyModifierMask mask, KeyButton button)
|
CClientProxy1_1::keyDown(KeyID key, KeyModifierMask mask, KeyButton button)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send key down to \"%s\" id=%d, mask=0x%04x, button=0x%04x", getName().c_str(), key, mask, button));
|
LOG((CLOG_DEBUG1 "send key down to \"%s\" id=%d, mask=0x%04x, button=0x%04x", getName().c_str(), key, mask, button));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDKeyDown, key, mask, button);
|
CProtocolUtil::writef(getStream(), kMsgDKeyDown, key, mask, button);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
@ -45,12 +45,12 @@ CClientProxy1_1::keyRepeat(KeyID key, KeyModifierMask mask,
|
||||||
SInt32 count, KeyButton button)
|
SInt32 count, KeyButton button)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send key repeat to \"%s\" id=%d, mask=0x%04x, count=%d, button=0x%04x", getName().c_str(), key, mask, count, button));
|
LOG((CLOG_DEBUG1 "send key repeat to \"%s\" id=%d, mask=0x%04x, count=%d, button=0x%04x", getName().c_str(), key, mask, count, button));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDKeyRepeat, key, mask, count, button);
|
CProtocolUtil::writef(getStream(), kMsgDKeyRepeat, key, mask, count, button);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CClientProxy1_1::keyUp(KeyID key, KeyModifierMask mask, KeyButton button)
|
CClientProxy1_1::keyUp(KeyID key, KeyModifierMask mask, KeyButton button)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "send key up to \"%s\" id=%d, mask=0x%04x, button=0x%04x", getName().c_str(), key, mask, button));
|
LOG((CLOG_DEBUG1 "send key up to \"%s\" id=%d, mask=0x%04x, button=0x%04x", getName().c_str(), key, mask, button));
|
||||||
CProtocolUtil::writef(getOutputStream(), kMsgDKeyUp, key, mask, button);
|
CProtocolUtil::writef(getStream(), kMsgDKeyUp, key, mask, button);
|
||||||
}
|
}
|
||||||
|
|
|
@ -21,8 +21,7 @@
|
||||||
class CClientProxy1_1 : public CClientProxy1_0 {
|
class CClientProxy1_1 : public CClientProxy1_0 {
|
||||||
public:
|
public:
|
||||||
CClientProxy1_1(IServer* server, const CString& name,
|
CClientProxy1_1(IServer* server, const CString& name,
|
||||||
IInputStream* adoptedInput,
|
IStream* adoptedStream);
|
||||||
IOutputStream* adoptedOutput);
|
|
||||||
~CClientProxy1_1();
|
~CClientProxy1_1();
|
||||||
|
|
||||||
// IClient overrides
|
// IClient overrides
|
||||||
|
|
|
@ -239,12 +239,6 @@ CConfig::setSynergyAddress(const CNetworkAddress& addr)
|
||||||
m_synergyAddress = addr;
|
m_synergyAddress = addr;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
|
||||||
CConfig::setHTTPAddress(const CNetworkAddress& addr)
|
|
||||||
{
|
|
||||||
m_httpAddress = addr;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool
|
bool
|
||||||
CConfig::addOption(const CString& name, OptionID option, OptionValue value)
|
CConfig::addOption(const CString& name, OptionID option, OptionValue value)
|
||||||
{
|
{
|
||||||
|
@ -430,12 +424,6 @@ CConfig::getSynergyAddress() const
|
||||||
return m_synergyAddress;
|
return m_synergyAddress;
|
||||||
}
|
}
|
||||||
|
|
||||||
const CNetworkAddress&
|
|
||||||
CConfig::getHTTPAddress() const
|
|
||||||
{
|
|
||||||
return m_httpAddress;
|
|
||||||
}
|
|
||||||
|
|
||||||
const CConfig::CScreenOptions*
|
const CConfig::CScreenOptions*
|
||||||
CConfig::getOptions(const CString& name) const
|
CConfig::getOptions(const CString& name) const
|
||||||
{
|
{
|
||||||
|
@ -462,9 +450,6 @@ CConfig::operator==(const CConfig& x) const
|
||||||
if (m_synergyAddress != x.m_synergyAddress) {
|
if (m_synergyAddress != x.m_synergyAddress) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
if (m_httpAddress != x.m_httpAddress) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
*/
|
*/
|
||||||
if (m_map.size() != x.m_map.size()) {
|
if (m_map.size() != x.m_map.size()) {
|
||||||
return false;
|
return false;
|
||||||
|
@ -782,14 +767,6 @@ CConfig::readSectionOptions(std::istream& s)
|
||||||
throw XConfigRead("invalid address argument");
|
throw XConfigRead("invalid address argument");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (name == "http") {
|
|
||||||
try {
|
|
||||||
m_httpAddress = CNetworkAddress(value, kDefaultPort + 1);
|
|
||||||
}
|
|
||||||
catch (XSocketAddress&) {
|
|
||||||
throw XConfigRead("invalid http argument");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else if (name == "heartbeat") {
|
else if (name == "heartbeat") {
|
||||||
addOption("", kOptionHeartbeat, parseInt(value));
|
addOption("", kOptionHeartbeat, parseInt(value));
|
||||||
}
|
}
|
||||||
|
@ -1063,10 +1040,6 @@ operator<<(std::ostream& s, const CConfig& config)
|
||||||
s << "\taddress = " <<
|
s << "\taddress = " <<
|
||||||
config.m_synergyAddress.getHostname().c_str() << std::endl;
|
config.m_synergyAddress.getHostname().c_str() << std::endl;
|
||||||
}
|
}
|
||||||
if (config.m_httpAddress.isValid()) {
|
|
||||||
s << "\thttp = " <<
|
|
||||||
config.m_httpAddress.getHostname().c_str() << std::endl;
|
|
||||||
}
|
|
||||||
s << "end" << std::endl;
|
s << "end" << std::endl;
|
||||||
|
|
||||||
// screens section
|
// screens section
|
||||||
|
|
|
@ -175,13 +175,6 @@ public:
|
||||||
*/
|
*/
|
||||||
void setSynergyAddress(const CNetworkAddress&);
|
void setSynergyAddress(const CNetworkAddress&);
|
||||||
|
|
||||||
//! Set HTTP server address
|
|
||||||
/*!
|
|
||||||
Set the HTTP listen addresses. There is no default address so
|
|
||||||
this must be called to run an HTTP server using this configuration.
|
|
||||||
*/
|
|
||||||
void setHTTPAddress(const CNetworkAddress&);
|
|
||||||
|
|
||||||
//! Add a screen option
|
//! Add a screen option
|
||||||
/*!
|
/*!
|
||||||
Adds an option and its value to the named screen. Replaces the
|
Adds an option and its value to the named screen. Replaces the
|
||||||
|
@ -255,8 +248,6 @@ public:
|
||||||
|
|
||||||
//! Get the server address
|
//! Get the server address
|
||||||
const CNetworkAddress& getSynergyAddress() const;
|
const CNetworkAddress& getSynergyAddress() const;
|
||||||
//! Get the HTTP server address
|
|
||||||
const CNetworkAddress& getHTTPAddress() const;
|
|
||||||
|
|
||||||
//! Get the screen options
|
//! Get the screen options
|
||||||
/*!
|
/*!
|
||||||
|
@ -308,7 +299,6 @@ private:
|
||||||
CCellMap m_map;
|
CCellMap m_map;
|
||||||
CNameMap m_nameToCanonicalName;
|
CNameMap m_nameToCanonicalName;
|
||||||
CNetworkAddress m_synergyAddress;
|
CNetworkAddress m_synergyAddress;
|
||||||
CNetworkAddress m_httpAddress;
|
|
||||||
CScreenOptions m_globalOptions;
|
CScreenOptions m_globalOptions;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
|
@ -1,799 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "CHTTPServer.h"
|
|
||||||
#include "CConfig.h"
|
|
||||||
#include "CHTTPProtocol.h"
|
|
||||||
#include "CServer.h"
|
|
||||||
#include "XHTTP.h"
|
|
||||||
#include "IDataSocket.h"
|
|
||||||
#include "XThread.h"
|
|
||||||
#include "CLog.h"
|
|
||||||
#include "stdset.h"
|
|
||||||
#include "stdsstream.h"
|
|
||||||
|
|
||||||
//
|
|
||||||
// CHTTPServer
|
|
||||||
//
|
|
||||||
|
|
||||||
// maximum size of an HTTP request. this should be large enough to
|
|
||||||
// handle any reasonable request but small enough to prevent a
|
|
||||||
// malicious client from causing us to use too much memory.
|
|
||||||
const UInt32 CHTTPServer::s_maxRequestSize = 32768;
|
|
||||||
|
|
||||||
CHTTPServer::CHTTPServer(
|
|
||||||
CServer* server) :
|
|
||||||
m_server(server)
|
|
||||||
{
|
|
||||||
// do nothing
|
|
||||||
}
|
|
||||||
|
|
||||||
CHTTPServer::~CHTTPServer()
|
|
||||||
{
|
|
||||||
// do nothing
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::processRequest(IDataSocket* socket)
|
|
||||||
{
|
|
||||||
assert(socket != NULL);
|
|
||||||
|
|
||||||
CHTTPRequest* request = NULL;
|
|
||||||
try {
|
|
||||||
// parse request
|
|
||||||
request = CHTTPProtocol::readRequest(
|
|
||||||
socket->getInputStream(), s_maxRequestSize);
|
|
||||||
if (request == NULL) {
|
|
||||||
throw XHTTP(400);
|
|
||||||
}
|
|
||||||
|
|
||||||
// if absolute uri then strip off scheme and host
|
|
||||||
if (request->m_uri[0] != '/') {
|
|
||||||
CString::size_type n = request->m_uri.find('/');
|
|
||||||
if (n == CString::npos) {
|
|
||||||
throw XHTTP(404);
|
|
||||||
}
|
|
||||||
request->m_uri = request->m_uri.substr(n);
|
|
||||||
}
|
|
||||||
|
|
||||||
// prepare reply
|
|
||||||
CHTTPReply reply;
|
|
||||||
reply.m_majorVersion = request->m_majorVersion;
|
|
||||||
reply.m_minorVersion = request->m_minorVersion;
|
|
||||||
reply.m_status = 200;
|
|
||||||
reply.m_reason = "OK";
|
|
||||||
reply.m_method = request->m_method;
|
|
||||||
|
|
||||||
// process
|
|
||||||
doProcessRequest(*request, reply);
|
|
||||||
|
|
||||||
// send reply
|
|
||||||
CHTTPProtocol::reply(socket->getOutputStream(), reply);
|
|
||||||
LOG((CLOG_INFO "HTTP reply %d for %s %s", reply.m_status, request->m_method.c_str(), request->m_uri.c_str()));
|
|
||||||
|
|
||||||
// clean up
|
|
||||||
delete request;
|
|
||||||
}
|
|
||||||
catch (XHTTP& e) {
|
|
||||||
LOG((CLOG_WARN "returning HTTP error %d %s for %s", e.getStatus(), e.getReason().c_str(), (request != NULL) ? request->m_uri.c_str() : "<unknown>"));
|
|
||||||
|
|
||||||
// clean up
|
|
||||||
delete request;
|
|
||||||
|
|
||||||
// return error
|
|
||||||
CHTTPReply reply;
|
|
||||||
reply.m_majorVersion = 1;
|
|
||||||
reply.m_minorVersion = 0;
|
|
||||||
reply.m_status = e.getStatus();
|
|
||||||
reply.m_reason = e.getReason();
|
|
||||||
reply.m_method = "GET";
|
|
||||||
// FIXME -- use a nicer error page
|
|
||||||
reply.m_headers.push_back(std::make_pair(CString("Content-Type"),
|
|
||||||
CString("text/plain")));
|
|
||||||
reply.m_body = e.getReason();
|
|
||||||
e.addHeaders(reply);
|
|
||||||
CHTTPProtocol::reply(socket->getOutputStream(), reply);
|
|
||||||
}
|
|
||||||
catch (...) {
|
|
||||||
// ignore other exceptions
|
|
||||||
RETHROW_XTHREAD
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::doProcessRequest(CHTTPRequest& request, CHTTPReply& reply)
|
|
||||||
{
|
|
||||||
// switch based on uri
|
|
||||||
if (request.m_uri == "/editmap") {
|
|
||||||
if (request.m_method == "GET" || request.m_method == "HEAD") {
|
|
||||||
doProcessGetEditMap(request, reply);
|
|
||||||
reply.m_headers.push_back(std::make_pair(
|
|
||||||
CString("Content-Type"),
|
|
||||||
CString("text/html")));
|
|
||||||
}
|
|
||||||
else if (request.m_method == "POST") {
|
|
||||||
doProcessPostEditMap(request, reply);
|
|
||||||
reply.m_headers.push_back(std::make_pair(
|
|
||||||
CString("Content-Type"),
|
|
||||||
CString("text/html")));
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw XHTTPAllow("GET, HEAD, POST");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// unknown page
|
|
||||||
throw XHTTP(404);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::doProcessGetEditMap(CHTTPRequest& /*request*/, CHTTPReply& reply)
|
|
||||||
{
|
|
||||||
static const char* s_editMapProlog1 =
|
|
||||||
"<html>\r\n"
|
|
||||||
"<head>\r\n"
|
|
||||||
" <title>Synergy -- Edit Screens</title>\r\n"
|
|
||||||
"</head>\r\n"
|
|
||||||
"<body>\r\n"
|
|
||||||
" <form method=\"POST\" action=\"editmap\" "
|
|
||||||
"enctype=\"multipart/form-data\">\r\n"
|
|
||||||
" <input type=hidden name=\"size\" value=\"";
|
|
||||||
static const char* s_editMapProlog2 =
|
|
||||||
"\">\r\n";
|
|
||||||
static const char* s_editMapEpilog =
|
|
||||||
" <input type=submit name=\"submit\">\r\n"
|
|
||||||
" <input type=reset>\r\n"
|
|
||||||
" <br>\r\n"
|
|
||||||
" </form>\r\n"
|
|
||||||
"</body>\r\n"
|
|
||||||
"</html>\r\n";
|
|
||||||
static const char* s_editMapTableProlog =
|
|
||||||
"<table border=\"1\" cellspacing=\"0\" cellpadding=\"0\"><tr><td>"
|
|
||||||
" <table border=\"0\" cellspacing=\"2\" cellpadding=\"6\">\r\n";
|
|
||||||
static const char* s_editMapTableEpilog =
|
|
||||||
" </table>"
|
|
||||||
"</td></tr></table>\r\n";
|
|
||||||
static const char* s_editMapRowProlog =
|
|
||||||
"<tr align=\"center\" valign=\"top\">\r\n";
|
|
||||||
static const char* s_editMapRowEpilog =
|
|
||||||
"</tr>\r\n";
|
|
||||||
static const char* s_editMapScreenDummy =
|
|
||||||
"<td>";
|
|
||||||
static const char* s_editMapScreenPrimary =
|
|
||||||
"<td bgcolor=\"#2222288\"><input type=\"text\" readonly value=\"";
|
|
||||||
static const char* s_editMapScreenLive =
|
|
||||||
"<td bgcolor=\"#cccccc\"><input type=\"text\" value=\"";
|
|
||||||
static const char* s_editMapScreenDead =
|
|
||||||
"<td><input type=\"text\" value=\"";
|
|
||||||
static const char* s_editMapScreenLiveDead1 =
|
|
||||||
"\" size=\"16\" maxlength=\"64\" name=\"";
|
|
||||||
static const char* s_editMapScreenLiveDead2 =
|
|
||||||
"\">";
|
|
||||||
static const char* s_editMapScreenEnd =
|
|
||||||
"</td>\r\n";
|
|
||||||
|
|
||||||
std::ostringstream s;
|
|
||||||
|
|
||||||
// convert screen map into a temporary screen map
|
|
||||||
CScreenArray screens;
|
|
||||||
{
|
|
||||||
CConfig config;
|
|
||||||
m_server->getConfig(&config);
|
|
||||||
screens.convertFrom(config);
|
|
||||||
// FIXME -- note to user if config couldn't be exactly represented
|
|
||||||
}
|
|
||||||
|
|
||||||
// insert blank columns and rows around array (to allow the user
|
|
||||||
// to insert new screens)
|
|
||||||
screens.insertColumn(0);
|
|
||||||
screens.insertColumn(screens.getWidth());
|
|
||||||
screens.insertRow(0);
|
|
||||||
screens.insertRow(screens.getHeight());
|
|
||||||
|
|
||||||
// get array size
|
|
||||||
const SInt32 w = screens.getWidth();
|
|
||||||
const SInt32 h = screens.getHeight();
|
|
||||||
|
|
||||||
// construct reply
|
|
||||||
reply.m_body += s_editMapProlog1;
|
|
||||||
s << w << "x" << h;
|
|
||||||
reply.m_body += s.str();
|
|
||||||
reply.m_body += s_editMapProlog2;
|
|
||||||
|
|
||||||
// add screen map for editing
|
|
||||||
const CString primaryName = m_server->getPrimaryScreenName();
|
|
||||||
reply.m_body += s_editMapTableProlog;
|
|
||||||
for (SInt32 y = 0; y < h; ++y) {
|
|
||||||
reply.m_body += s_editMapRowProlog;
|
|
||||||
for (SInt32 x = 0; x < w; ++x) {
|
|
||||||
s.str("");
|
|
||||||
if (!screens.isAllowed(x, y) && screens.get(x, y) != primaryName) {
|
|
||||||
s << s_editMapScreenDummy;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if (!screens.isSet(x, y)) {
|
|
||||||
s << s_editMapScreenDead;
|
|
||||||
}
|
|
||||||
else if (screens.get(x, y) == primaryName) {
|
|
||||||
s << s_editMapScreenPrimary;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
s << s_editMapScreenLive;
|
|
||||||
}
|
|
||||||
s << screens.get(x, y) <<
|
|
||||||
s_editMapScreenLiveDead1 <<
|
|
||||||
"n" << x << "x" << y <<
|
|
||||||
s_editMapScreenLiveDead2;
|
|
||||||
}
|
|
||||||
s << s_editMapScreenEnd;
|
|
||||||
reply.m_body += s.str();
|
|
||||||
}
|
|
||||||
reply.m_body += s_editMapRowEpilog;
|
|
||||||
}
|
|
||||||
reply.m_body += s_editMapTableEpilog;
|
|
||||||
|
|
||||||
reply.m_body += s_editMapEpilog;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::doProcessPostEditMap(CHTTPRequest& request, CHTTPReply& reply)
|
|
||||||
{
|
|
||||||
typedef std::vector<CString> ScreenArray;
|
|
||||||
typedef std::set<CString> ScreenSet;
|
|
||||||
|
|
||||||
// parse the result
|
|
||||||
CHTTPProtocol::CFormParts parts;
|
|
||||||
if (!CHTTPProtocol::parseFormData(request, parts)) {
|
|
||||||
LOG((CLOG_WARN "editmap: cannot parse form data"));
|
|
||||||
throw XHTTP(400);
|
|
||||||
}
|
|
||||||
|
|
||||||
try {
|
|
||||||
std::ostringstream s;
|
|
||||||
|
|
||||||
// convert post data into a temporary screen map. also check
|
|
||||||
// that no screen name is invalid or used more than once.
|
|
||||||
SInt32 w, h;
|
|
||||||
CHTTPProtocol::CFormParts::iterator index = parts.find("size");
|
|
||||||
if (index == parts.end() ||
|
|
||||||
!parseXY(index->second, w, h) ||
|
|
||||||
w <= 0 || h <= 0) {
|
|
||||||
LOG((CLOG_WARN "editmap: cannot parse size or size is invalid"));
|
|
||||||
throw XHTTP(400);
|
|
||||||
}
|
|
||||||
ScreenSet screenNames;
|
|
||||||
CScreenArray screens;
|
|
||||||
screens.resize(w, h);
|
|
||||||
for (SInt32 y = 0; y < h; ++y) {
|
|
||||||
for (SInt32 x = 0; x < w; ++x) {
|
|
||||||
// find part
|
|
||||||
s.str("");
|
|
||||||
s << "n" << x << "x" << y;
|
|
||||||
index = parts.find(s.str());
|
|
||||||
if (index == parts.end()) {
|
|
||||||
// FIXME -- screen is missing. error?
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// skip blank names
|
|
||||||
const CString& name = index->second;
|
|
||||||
if (name.empty()) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// check name. name must be legal and must not have
|
|
||||||
// already been seen.
|
|
||||||
if (screenNames.count(name)) {
|
|
||||||
// FIXME -- better error message
|
|
||||||
LOG((CLOG_WARN "editmap: duplicate name %s", name.c_str()));
|
|
||||||
throw XHTTP(400);
|
|
||||||
}
|
|
||||||
// FIXME -- check that name is legal
|
|
||||||
|
|
||||||
// save name. if we've already seen the name then
|
|
||||||
// report an error.
|
|
||||||
screens.set(x, y, name);
|
|
||||||
screenNames.insert(name);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// if new map is invalid then return error. map is invalid if:
|
|
||||||
// there are no screens, or
|
|
||||||
// the screens are not 4-connected.
|
|
||||||
if (screenNames.empty()) {
|
|
||||||
// no screens
|
|
||||||
// FIXME -- need better no screens
|
|
||||||
LOG((CLOG_WARN "editmap: no screens"));
|
|
||||||
throw XHTTP(400);
|
|
||||||
}
|
|
||||||
if (!screens.isValid()) {
|
|
||||||
// FIXME -- need better unconnected screens error
|
|
||||||
LOG((CLOG_WARN "editmap: unconnected screens"));
|
|
||||||
throw XHTTP(400);
|
|
||||||
}
|
|
||||||
|
|
||||||
// convert temporary screen map into a regular map
|
|
||||||
CConfig config;
|
|
||||||
m_server->getConfig(&config);
|
|
||||||
screens.convertTo(config);
|
|
||||||
|
|
||||||
// set new screen map on server
|
|
||||||
m_server->setConfig(config);
|
|
||||||
|
|
||||||
// now reply with current map
|
|
||||||
doProcessGetEditMap(request, reply);
|
|
||||||
}
|
|
||||||
catch (XHTTP&) {
|
|
||||||
// FIXME -- construct a more meaningful error?
|
|
||||||
throw;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bool
|
|
||||||
CHTTPServer::parseXY(const CString& xy, SInt32& x, SInt32& y)
|
|
||||||
{
|
|
||||||
std::istringstream s(xy);
|
|
||||||
char delimiter;
|
|
||||||
s >> x;
|
|
||||||
s.get(delimiter);
|
|
||||||
s >> y;
|
|
||||||
return (!!s && delimiter == 'x');
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//
|
|
||||||
// CHTTPServer::CScreenArray
|
|
||||||
//
|
|
||||||
|
|
||||||
CHTTPServer::CScreenArray::CScreenArray() :
|
|
||||||
m_w(0),
|
|
||||||
m_h(0)
|
|
||||||
{
|
|
||||||
// do nothing
|
|
||||||
}
|
|
||||||
|
|
||||||
CHTTPServer::CScreenArray::~CScreenArray()
|
|
||||||
{
|
|
||||||
// do nothing
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::resize(SInt32 w, SInt32 h)
|
|
||||||
{
|
|
||||||
m_screens.clear();
|
|
||||||
m_screens.resize(w * h);
|
|
||||||
m_w = w;
|
|
||||||
m_h = h;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::insertRow(SInt32 i)
|
|
||||||
{
|
|
||||||
assert(i >= 0 && i <= m_h);
|
|
||||||
|
|
||||||
CNames newScreens;
|
|
||||||
newScreens.resize(m_w * (m_h + 1));
|
|
||||||
|
|
||||||
for (SInt32 y = 0; y < i; ++y) {
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
newScreens[x + y * m_w] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for (SInt32 y = i; y < m_h; ++y) {
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
newScreens[x + (y + 1) * m_w] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
m_screens.swap(newScreens);
|
|
||||||
++m_h;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::insertColumn(SInt32 i)
|
|
||||||
{
|
|
||||||
assert(i >= 0 && i <= m_w);
|
|
||||||
|
|
||||||
CNames newScreens;
|
|
||||||
newScreens.resize((m_w + 1) * m_h);
|
|
||||||
|
|
||||||
for (SInt32 y = 0; y < m_h; ++y) {
|
|
||||||
for (SInt32 x = 0; x < i; ++x) {
|
|
||||||
newScreens[x + y * (m_w + 1)] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
for (SInt32 x = i; x < m_w; ++x) {
|
|
||||||
newScreens[(x + 1) + y * (m_w + 1)] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
m_screens.swap(newScreens);
|
|
||||||
++m_w;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::eraseRow(SInt32 i)
|
|
||||||
{
|
|
||||||
assert(i >= 0 && i < m_h);
|
|
||||||
|
|
||||||
CNames newScreens;
|
|
||||||
newScreens.resize(m_w * (m_h - 1));
|
|
||||||
|
|
||||||
for (SInt32 y = 0; y < i; ++y) {
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
newScreens[x + y * m_w] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for (SInt32 y = i + 1; y < m_h; ++y) {
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
newScreens[x + (y - 1) * m_w] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
m_screens.swap(newScreens);
|
|
||||||
--m_h;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::eraseColumn(SInt32 i)
|
|
||||||
{
|
|
||||||
assert(i >= 0 && i < m_w);
|
|
||||||
|
|
||||||
CNames newScreens;
|
|
||||||
newScreens.resize((m_w - 1) * m_h);
|
|
||||||
|
|
||||||
for (SInt32 y = 0; y < m_h; ++y) {
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
newScreens[x + y * (m_w - 1)] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
for (SInt32 x = i + 1; x < m_w; ++x) {
|
|
||||||
newScreens[(x - 1) + y * (m_w - 1)] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
m_screens.swap(newScreens);
|
|
||||||
--m_w;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::rotateRows(SInt32 i)
|
|
||||||
{
|
|
||||||
// nothing to do if no rows
|
|
||||||
if (m_h == 0) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// convert to canonical form
|
|
||||||
if (i < 0) {
|
|
||||||
i = m_h - ((-i) % m_h);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
i %= m_h;
|
|
||||||
}
|
|
||||||
if (i == 0 || i == m_h) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
while (i > 0) {
|
|
||||||
// rotate one row
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
CString tmp = m_screens[x];
|
|
||||||
for (SInt32 y = 1; y < m_h; ++y) {
|
|
||||||
m_screens[x + (y - 1) * m_w] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
m_screens[x + (m_h - 1) * m_w] = tmp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::rotateColumns(SInt32 i)
|
|
||||||
{
|
|
||||||
// nothing to do if no columns
|
|
||||||
if (m_h == 0) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// convert to canonical form
|
|
||||||
if (i < 0) {
|
|
||||||
i = m_w - ((-i) % m_w);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
i %= m_w;
|
|
||||||
}
|
|
||||||
if (i == 0 || i == m_w) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
while (i > 0) {
|
|
||||||
// rotate one column
|
|
||||||
for (SInt32 y = 0; y < m_h; ++y) {
|
|
||||||
CString tmp = m_screens[0 + y * m_w];
|
|
||||||
for (SInt32 x = 1; x < m_w; ++x) {
|
|
||||||
m_screens[x - 1 + y * m_w] = m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
m_screens[m_w - 1 + y * m_w] = tmp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::remove(SInt32 x, SInt32 y)
|
|
||||||
{
|
|
||||||
set(x, y, CString());
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::set(SInt32 x, SInt32 y, const CString& name)
|
|
||||||
{
|
|
||||||
assert(x >= 0 && x < m_w);
|
|
||||||
assert(y >= 0 && y < m_h);
|
|
||||||
|
|
||||||
m_screens[x + y * m_w] = name;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool
|
|
||||||
CHTTPServer::CScreenArray::isAllowed(SInt32 x, SInt32 y) const
|
|
||||||
{
|
|
||||||
assert(x >= 0 && x < m_w);
|
|
||||||
assert(y >= 0 && y < m_h);
|
|
||||||
|
|
||||||
if (x > 0 && !m_screens[(x - 1) + y * m_w].empty()) {
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
if (x < m_w - 1 && !m_screens[(x + 1) + y * m_w].empty()) {
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
if (y > 0 && !m_screens[x + (y - 1) * m_w].empty()) {
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
if (y < m_h - 1 && !m_screens[x + (y + 1) * m_w].empty()) {
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool
|
|
||||||
CHTTPServer::CScreenArray::isSet(SInt32 x, SInt32 y) const
|
|
||||||
{
|
|
||||||
assert(x >= 0 && x < m_w);
|
|
||||||
assert(y >= 0 && y < m_h);
|
|
||||||
|
|
||||||
return !m_screens[x + y * m_w].empty();
|
|
||||||
}
|
|
||||||
|
|
||||||
CString
|
|
||||||
CHTTPServer::CScreenArray::get(SInt32 x, SInt32 y) const
|
|
||||||
{
|
|
||||||
assert(x >= 0 && x < m_w);
|
|
||||||
assert(y >= 0 && y < m_h);
|
|
||||||
|
|
||||||
return m_screens[x + y * m_w];
|
|
||||||
}
|
|
||||||
|
|
||||||
bool
|
|
||||||
CHTTPServer::CScreenArray::find(const CString& name,
|
|
||||||
SInt32& xOut, SInt32& yOut) const
|
|
||||||
{
|
|
||||||
for (SInt32 y = 0; y < m_h; ++y) {
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
if (m_screens[x + y * m_w] == name) {
|
|
||||||
xOut = x;
|
|
||||||
yOut = y;
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool
|
|
||||||
CHTTPServer::CScreenArray::isValid() const
|
|
||||||
{
|
|
||||||
SInt32 count = 0, isolated = 0;
|
|
||||||
for (SInt32 y = 0; y < m_h; ++y) {
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
if (isSet(x, y)) {
|
|
||||||
++count;
|
|
||||||
if (!isAllowed(x, y)) {
|
|
||||||
++isolated;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return (count <= 1 || isolated == 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool
|
|
||||||
CHTTPServer::CScreenArray::convertFrom(const CConfig& config)
|
|
||||||
{
|
|
||||||
typedef std::set<CString> ScreenSet;
|
|
||||||
|
|
||||||
// insert the first screen
|
|
||||||
CConfig::const_iterator index = config.begin();
|
|
||||||
if (index == config.end()) {
|
|
||||||
// no screens
|
|
||||||
resize(0, 0);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
CString name = *index;
|
|
||||||
resize(1, 1);
|
|
||||||
set(0, 0, name);
|
|
||||||
|
|
||||||
// flood fill state
|
|
||||||
CNames screenStack;
|
|
||||||
ScreenSet doneSet;
|
|
||||||
|
|
||||||
// put all but the first screen on the stack
|
|
||||||
// note -- if all screens are 4-connected then we can skip this
|
|
||||||
while (++index != config.end()) {
|
|
||||||
screenStack.push_back(*index);
|
|
||||||
}
|
|
||||||
|
|
||||||
// put the first screen on the stack last so we process it first
|
|
||||||
screenStack.push_back(name);
|
|
||||||
|
|
||||||
// perform a flood fill using the stack as the seeds
|
|
||||||
while (!screenStack.empty()) {
|
|
||||||
// get next screen from stack
|
|
||||||
CString name = screenStack.back();
|
|
||||||
screenStack.pop_back();
|
|
||||||
|
|
||||||
// skip screen if we've seen it before
|
|
||||||
if (doneSet.count(name) > 0) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// add this screen to doneSet so we don't process it again
|
|
||||||
doneSet.insert(name);
|
|
||||||
|
|
||||||
// find the screen. if it's not found then not all of the
|
|
||||||
// screens are 4-connected. discard disconnected screens.
|
|
||||||
SInt32 x, y;
|
|
||||||
if (!find(name, x, y)) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// insert the screen's neighbors
|
|
||||||
// FIXME -- handle edge wrapping
|
|
||||||
CString neighbor;
|
|
||||||
neighbor = config.getNeighbor(name, kLeft);
|
|
||||||
if (!neighbor.empty() && doneSet.count(neighbor) == 0) {
|
|
||||||
// insert left neighbor, adding a column if necessary
|
|
||||||
if (x == 0 || get(x - 1, y) != neighbor) {
|
|
||||||
++x;
|
|
||||||
insertColumn(x - 1);
|
|
||||||
set(x - 1, y, neighbor);
|
|
||||||
}
|
|
||||||
screenStack.push_back(neighbor);
|
|
||||||
}
|
|
||||||
neighbor = config.getNeighbor(name, kRight);
|
|
||||||
if (!neighbor.empty() && doneSet.count(neighbor) == 0) {
|
|
||||||
// insert right neighbor, adding a column if necessary
|
|
||||||
if (x == m_w - 1 || get(x + 1, y) != neighbor) {
|
|
||||||
insertColumn(x + 1);
|
|
||||||
set(x + 1, y, neighbor);
|
|
||||||
}
|
|
||||||
screenStack.push_back(neighbor);
|
|
||||||
}
|
|
||||||
neighbor = config.getNeighbor(name, kTop);
|
|
||||||
if (!neighbor.empty() && doneSet.count(neighbor) == 0) {
|
|
||||||
// insert top neighbor, adding a row if necessary
|
|
||||||
if (y == 0 || get(x, y - 1) != neighbor) {
|
|
||||||
++y;
|
|
||||||
insertRow(y - 1);
|
|
||||||
set(x, y - 1, neighbor);
|
|
||||||
}
|
|
||||||
screenStack.push_back(neighbor);
|
|
||||||
}
|
|
||||||
neighbor = config.getNeighbor(name, kBottom);
|
|
||||||
if (!neighbor.empty() && doneSet.count(neighbor) == 0) {
|
|
||||||
// insert bottom neighbor, adding a row if necessary
|
|
||||||
if (y == m_h - 1 || get(x, y + 1) != neighbor) {
|
|
||||||
insertRow(y + 1);
|
|
||||||
set(x, y + 1, neighbor);
|
|
||||||
}
|
|
||||||
screenStack.push_back(neighbor);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// check symmetry
|
|
||||||
// FIXME -- handle edge wrapping
|
|
||||||
for (index = config.begin(); index != config.end(); ++index) {
|
|
||||||
const CString& name = *index;
|
|
||||||
SInt32 x, y;
|
|
||||||
if (!find(name, x, y)) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
CString neighbor;
|
|
||||||
neighbor = config.getNeighbor(name, kLeft);
|
|
||||||
if ((x == 0 && !neighbor.empty()) ||
|
|
||||||
(x > 0 && get(x - 1, y) != neighbor)) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
neighbor = config.getNeighbor(name, kRight);
|
|
||||||
if ((x == m_w - 1 && !neighbor.empty()) ||
|
|
||||||
(x < m_w - 1 && get(x + 1, y) != neighbor)) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
neighbor = config.getNeighbor(name, kTop);
|
|
||||||
if ((y == 0 && !neighbor.empty()) ||
|
|
||||||
(y > 0 && get(x, y - 1) != neighbor)) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
neighbor = config.getNeighbor(name, kBottom);
|
|
||||||
if ((y == m_h - 1 && !neighbor.empty()) ||
|
|
||||||
(y < m_h - 1 && get(x, y + 1) != neighbor)) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CHTTPServer::CScreenArray::convertTo(CConfig& config) const
|
|
||||||
{
|
|
||||||
config.removeAllScreens();
|
|
||||||
|
|
||||||
// add screens and find smallest box containing all screens
|
|
||||||
SInt32 x0 = m_w, x1 = 0, y0 = m_h, y1 = 0;
|
|
||||||
for (SInt32 y = 0; y < m_h; ++y) {
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
if (isSet(x, y)) {
|
|
||||||
config.addScreen(get(x, y));
|
|
||||||
if (x < x0) {
|
|
||||||
x0 = x;
|
|
||||||
}
|
|
||||||
if (x > x1) {
|
|
||||||
x1 = x;
|
|
||||||
}
|
|
||||||
if (y < y0) {
|
|
||||||
y0 = y;
|
|
||||||
}
|
|
||||||
if (y > y1) {
|
|
||||||
y1 = y;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// make connections between screens
|
|
||||||
// FIXME -- add support for wrapping
|
|
||||||
// FIXME -- mark topmost and leftmost screens
|
|
||||||
for (SInt32 y = 0; y < m_h; ++y) {
|
|
||||||
for (SInt32 x = 0; x < m_w; ++x) {
|
|
||||||
if (!isSet(x, y)) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if (x > x0 && isSet(x - 1, y)) {
|
|
||||||
config.connect(get(x, y), kLeft, get(x - 1, y));
|
|
||||||
}
|
|
||||||
if (x < x1 && isSet(x + 1, y)) {
|
|
||||||
config.connect(get(x, y), kRight, get(x + 1, y));
|
|
||||||
}
|
|
||||||
if (y > y0 && isSet(x, y - 1)) {
|
|
||||||
config.connect(get(x, y), kTop, get(x, y - 1));
|
|
||||||
}
|
|
||||||
if (y < y1 && isSet(x, y + 1)) {
|
|
||||||
config.connect(get(x, y), kBottom, get(x, y + 1));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,142 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef CHTTPSERVER_H
|
|
||||||
#define CHTTPSERVER_H
|
|
||||||
|
|
||||||
#include "CString.h"
|
|
||||||
#include "BasicTypes.h"
|
|
||||||
#include "stdvector.h"
|
|
||||||
|
|
||||||
class CServer;
|
|
||||||
class CConfig;
|
|
||||||
class CHTTPRequest;
|
|
||||||
class CHTTPReply;
|
|
||||||
class IDataSocket;
|
|
||||||
|
|
||||||
//! Simple HTTP server
|
|
||||||
/*!
|
|
||||||
This class implements a simple HTTP server for interacting with the
|
|
||||||
synergy server.
|
|
||||||
*/
|
|
||||||
class CHTTPServer {
|
|
||||||
public:
|
|
||||||
CHTTPServer(CServer*);
|
|
||||||
virtual ~CHTTPServer();
|
|
||||||
|
|
||||||
//! @name manipulators
|
|
||||||
//@{
|
|
||||||
|
|
||||||
//! Process HTTP request
|
|
||||||
/*!
|
|
||||||
Synchronously processes an HTTP request on the given socket.
|
|
||||||
*/
|
|
||||||
void processRequest(IDataSocket*);
|
|
||||||
|
|
||||||
//@}
|
|
||||||
|
|
||||||
protected:
|
|
||||||
//! Process HTTP request
|
|
||||||
/*!
|
|
||||||
Processes a successfully read HTTP request. The reply is partially
|
|
||||||
filled in (version, method, status (200) and reason (OK)). This
|
|
||||||
method checks the URI and handles the request, filling in the rest
|
|
||||||
of the reply. If the request cannot be satisfied it throws an
|
|
||||||
appropriate XHTTP exception.
|
|
||||||
*/
|
|
||||||
virtual void doProcessRequest(CHTTPRequest&, CHTTPReply&);
|
|
||||||
|
|
||||||
//! Process request for map
|
|
||||||
virtual void doProcessGetEditMap(CHTTPRequest&, CHTTPReply&);
|
|
||||||
|
|
||||||
//! Process request for changing map
|
|
||||||
virtual void doProcessPostEditMap(CHTTPRequest&, CHTTPReply&);
|
|
||||||
|
|
||||||
//! Parse coordinate string
|
|
||||||
static bool parseXY(const CString&, SInt32& x, SInt32& y);
|
|
||||||
|
|
||||||
//! Screen map helper
|
|
||||||
/*!
|
|
||||||
This class represents the screen map as a resizable array. It's
|
|
||||||
used to handle map requests.
|
|
||||||
*/
|
|
||||||
class CScreenArray {
|
|
||||||
public:
|
|
||||||
CScreenArray();
|
|
||||||
~CScreenArray();
|
|
||||||
|
|
||||||
// resize the array. this also clears all the elements.
|
|
||||||
void resize(SInt32 w, SInt32 h);
|
|
||||||
|
|
||||||
// insert/remove a row/column. all elements in a new row/column
|
|
||||||
// are unset.
|
|
||||||
void insertRow(SInt32 insertedBeforeRow);
|
|
||||||
void insertColumn(SInt32 insertedBeforeColumn);
|
|
||||||
void eraseRow(SInt32 row);
|
|
||||||
void eraseColumn(SInt32 column);
|
|
||||||
|
|
||||||
// rotate rows or columns
|
|
||||||
void rotateRows(SInt32 rowsDown);
|
|
||||||
void rotateColumns(SInt32 columnsDown);
|
|
||||||
|
|
||||||
// remove/set a screen name. setting an empty name is the
|
|
||||||
// same as removing a name. names are not checked for
|
|
||||||
// validity.
|
|
||||||
void remove(SInt32 x, SInt32 y);
|
|
||||||
void set(SInt32 x, SInt32 y, const CString&);
|
|
||||||
|
|
||||||
// convert a CConfig to a CScreenArray. returns true iff
|
|
||||||
// all connections are symmetric and therefore exactly
|
|
||||||
// representable by a CScreenArray.
|
|
||||||
bool convertFrom(const CConfig&);
|
|
||||||
|
|
||||||
// accessors
|
|
||||||
|
|
||||||
// get the array size
|
|
||||||
SInt32 getWidth() const { return m_w; }
|
|
||||||
SInt32 getHeight() const { return m_h; }
|
|
||||||
|
|
||||||
// returns true iff the cell has a 4-connected neighbor
|
|
||||||
bool isAllowed(SInt32 x, SInt32 y) const;
|
|
||||||
|
|
||||||
// returns true iff the cell has a (non-empty) name
|
|
||||||
bool isSet(SInt32 x, SInt32 y) const;
|
|
||||||
|
|
||||||
// get a screen name
|
|
||||||
CString get(SInt32 x, SInt32 y) const;
|
|
||||||
|
|
||||||
// find a screen by name. returns true iff found.
|
|
||||||
bool find(const CString&, SInt32& x, SInt32& y) const;
|
|
||||||
|
|
||||||
// return true iff the overall array is valid. that means
|
|
||||||
// just zero or one screen or all screens are 4-connected
|
|
||||||
// to other screens.
|
|
||||||
bool isValid() const;
|
|
||||||
|
|
||||||
// convert this to a CConfig
|
|
||||||
void convertTo(CConfig&) const;
|
|
||||||
|
|
||||||
private:
|
|
||||||
typedef std::vector<CString> CNames;
|
|
||||||
|
|
||||||
SInt32 m_w, m_h;
|
|
||||||
CNames m_screens;
|
|
||||||
};
|
|
||||||
|
|
||||||
private:
|
|
||||||
CServer* m_server;
|
|
||||||
static const UInt32 s_maxRequestSize;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -13,7 +13,6 @@
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "CServer.h"
|
#include "CServer.h"
|
||||||
#include "CHTTPServer.h"
|
|
||||||
#include "CPrimaryClient.h"
|
#include "CPrimaryClient.h"
|
||||||
#include "IScreenFactory.h"
|
#include "IScreenFactory.h"
|
||||||
#include "CInputPacketStream.h"
|
#include "CInputPacketStream.h"
|
||||||
|
@ -45,8 +44,6 @@
|
||||||
// CServer
|
// CServer
|
||||||
//
|
//
|
||||||
|
|
||||||
const SInt32 CServer::s_httpMaxSimultaneousRequests = 3;
|
|
||||||
|
|
||||||
CServer::CServer(const CString& serverName) :
|
CServer::CServer(const CString& serverName) :
|
||||||
m_name(serverName),
|
m_name(serverName),
|
||||||
m_error(false),
|
m_error(false),
|
||||||
|
@ -59,8 +56,6 @@ CServer::CServer(const CString& serverName) :
|
||||||
m_primaryClient(NULL),
|
m_primaryClient(NULL),
|
||||||
m_seqNum(0),
|
m_seqNum(0),
|
||||||
m_activeSaver(NULL),
|
m_activeSaver(NULL),
|
||||||
m_httpServer(NULL),
|
|
||||||
m_httpAvailable(&m_mutex, s_httpMaxSimultaneousRequests),
|
|
||||||
m_switchDir(kNoDirection),
|
m_switchDir(kNoDirection),
|
||||||
m_switchScreen(NULL),
|
m_switchScreen(NULL),
|
||||||
m_switchWaitDelay(0.0),
|
m_switchWaitDelay(0.0),
|
||||||
|
@ -118,18 +113,15 @@ CServer::mainLoop()
|
||||||
setStatus(kNotRunning);
|
setStatus(kNotRunning);
|
||||||
LOG((CLOG_NOTE "starting server"));
|
LOG((CLOG_NOTE "starting server"));
|
||||||
|
|
||||||
|
// FIXME -- started here
|
||||||
|
createClientListener();
|
||||||
|
// FIXME -- finished here
|
||||||
|
|
||||||
// start listening for new clients
|
// start listening for new clients
|
||||||
m_acceptClientThread = new CThread(startThread(
|
m_acceptClientThread = new CThread(startThread(
|
||||||
new TMethodJob<CServer>(this,
|
new TMethodJob<CServer>(this,
|
||||||
&CServer::acceptClients)));
|
&CServer::acceptClients)));
|
||||||
|
|
||||||
// start listening for HTTP requests
|
|
||||||
if (m_config.getHTTPAddress().isValid()) {
|
|
||||||
m_httpServer = new CHTTPServer(this);
|
|
||||||
startThread(new TMethodJob<CServer>(this,
|
|
||||||
&CServer::acceptHTTPClients));
|
|
||||||
}
|
|
||||||
|
|
||||||
// handle events
|
// handle events
|
||||||
m_primaryClient->mainLoop();
|
m_primaryClient->mainLoop();
|
||||||
|
|
||||||
|
@ -144,8 +136,6 @@ CServer::mainLoop()
|
||||||
// bucket.
|
// bucket.
|
||||||
#define FINALLY do { \
|
#define FINALLY do { \
|
||||||
stopThreads(); \
|
stopThreads(); \
|
||||||
delete m_httpServer; \
|
|
||||||
m_httpServer = NULL; \
|
|
||||||
runStatusJobs(); \
|
runStatusJobs(); \
|
||||||
} while (false)
|
} while (false)
|
||||||
FINALLY;
|
FINALLY;
|
||||||
|
@ -360,6 +350,16 @@ CServer::getConfig(CConfig* config) const
|
||||||
*config = m_config;
|
*config = m_config;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
CString
|
||||||
|
CServer::getCanonicalName(const CString& name) const
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
if (m_config.isScreen(name)) {
|
||||||
|
return m_config.getCanonicalName(name);
|
||||||
|
}
|
||||||
|
return name;
|
||||||
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CServer::runStatusJobs() const
|
CServer::runStatusJobs() const
|
||||||
{
|
{
|
||||||
|
@ -411,11 +411,6 @@ CServer::onError()
|
||||||
// threads may be unable to proceed until this thread returns.
|
// threads may be unable to proceed until this thread returns.
|
||||||
stopThreads(3.0);
|
stopThreads(3.0);
|
||||||
|
|
||||||
// done with the HTTP server
|
|
||||||
CLock lock(&m_mutex);
|
|
||||||
delete m_httpServer;
|
|
||||||
m_httpServer = NULL;
|
|
||||||
|
|
||||||
// note -- we do not attempt to close down the primary screen
|
// note -- we do not attempt to close down the primary screen
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1673,23 +1668,6 @@ CServer::handshakeClient(IDataSocket* socket)
|
||||||
{
|
{
|
||||||
LOG((CLOG_DEBUG1 "negotiating with new client"));
|
LOG((CLOG_DEBUG1 "negotiating with new client"));
|
||||||
|
|
||||||
// get the input and output streams
|
|
||||||
IInputStream* input = socket->getInputStream();
|
|
||||||
IOutputStream* output = socket->getOutputStream();
|
|
||||||
bool own = false;
|
|
||||||
|
|
||||||
// attach filters
|
|
||||||
if (m_streamFilterFactory != NULL) {
|
|
||||||
input = m_streamFilterFactory->createInput(input, own);
|
|
||||||
output = m_streamFilterFactory->createOutput(output, own);
|
|
||||||
own = true;
|
|
||||||
}
|
|
||||||
|
|
||||||
// attach the packetizing filters
|
|
||||||
input = new CInputPacketStream(input, own);
|
|
||||||
output = new COutputPacketStream(output, own);
|
|
||||||
own = true;
|
|
||||||
|
|
||||||
CClientProxy* proxy = NULL;
|
CClientProxy* proxy = NULL;
|
||||||
CString name("<unknown>");
|
CString name("<unknown>");
|
||||||
try {
|
try {
|
||||||
|
@ -1810,111 +1788,6 @@ CServer::handshakeClient(IDataSocket* socket)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
|
||||||
CServer::acceptHTTPClients(void*)
|
|
||||||
{
|
|
||||||
LOG((CLOG_DEBUG1 "starting to wait for HTTP clients"));
|
|
||||||
|
|
||||||
IListenSocket* listen = NULL;
|
|
||||||
try {
|
|
||||||
// create socket listener
|
|
||||||
listen = new CTCPListenSocket;
|
|
||||||
|
|
||||||
// bind to the desired port. keep retrying if we can't bind
|
|
||||||
// the address immediately.
|
|
||||||
CStopwatch timer;
|
|
||||||
for (;;) {
|
|
||||||
try {
|
|
||||||
LOG((CLOG_DEBUG1 "binding HTTP listen socket"));
|
|
||||||
listen->bind(m_config.getHTTPAddress());
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
catch (XSocketBind& e) {
|
|
||||||
LOG((CLOG_DEBUG1 "bind HTTP failed: %s", e.what()));
|
|
||||||
|
|
||||||
// give up if we've waited too long
|
|
||||||
if (timer.getTime() >= m_bindTimeout) {
|
|
||||||
LOG((CLOG_DEBUG1 "waited too long to bind HTTP, giving up"));
|
|
||||||
throw;
|
|
||||||
}
|
|
||||||
|
|
||||||
// wait a bit before retrying
|
|
||||||
ARCH->sleep(5.0);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// accept connections and begin processing them
|
|
||||||
LOG((CLOG_DEBUG1 "waiting for HTTP connections"));
|
|
||||||
for (;;) {
|
|
||||||
// limit the number of HTTP requests being handled at once
|
|
||||||
{
|
|
||||||
CLock lock(&m_httpAvailable);
|
|
||||||
while (m_httpAvailable == 0) {
|
|
||||||
m_httpAvailable.wait();
|
|
||||||
}
|
|
||||||
assert(m_httpAvailable > 0);
|
|
||||||
m_httpAvailable = m_httpAvailable - 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// accept connection
|
|
||||||
CThread::testCancel();
|
|
||||||
IDataSocket* socket = listen->accept();
|
|
||||||
LOG((CLOG_NOTE "accepted HTTP connection"));
|
|
||||||
CThread::testCancel();
|
|
||||||
|
|
||||||
// handle HTTP request
|
|
||||||
startThread(new TMethodJob<CServer>(
|
|
||||||
this, &CServer::processHTTPRequest, socket));
|
|
||||||
}
|
|
||||||
|
|
||||||
// clean up
|
|
||||||
delete listen;
|
|
||||||
}
|
|
||||||
catch (XBase& e) {
|
|
||||||
LOG((CLOG_ERR "cannot listen for HTTP clients: %s", e.what()));
|
|
||||||
delete listen;
|
|
||||||
exitMainLoopWithError();
|
|
||||||
}
|
|
||||||
catch (...) {
|
|
||||||
delete listen;
|
|
||||||
throw;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CServer::processHTTPRequest(void* vsocket)
|
|
||||||
{
|
|
||||||
IDataSocket* socket = reinterpret_cast<IDataSocket*>(vsocket);
|
|
||||||
try {
|
|
||||||
// process the request and force delivery
|
|
||||||
m_httpServer->processRequest(socket);
|
|
||||||
socket->getOutputStream()->flush();
|
|
||||||
|
|
||||||
// wait a moment to give the client a chance to hangup first
|
|
||||||
ARCH->sleep(3.0);
|
|
||||||
|
|
||||||
// clean up
|
|
||||||
socket->close();
|
|
||||||
delete socket;
|
|
||||||
|
|
||||||
// increment available HTTP handlers
|
|
||||||
{
|
|
||||||
CLock lock(&m_httpAvailable);
|
|
||||||
m_httpAvailable = m_httpAvailable + 1;
|
|
||||||
m_httpAvailable.signal();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
catch (...) {
|
|
||||||
delete socket;
|
|
||||||
{
|
|
||||||
CLock lock(&m_httpAvailable);
|
|
||||||
m_httpAvailable = m_httpAvailable + 1;
|
|
||||||
m_httpAvailable.signal();
|
|
||||||
}
|
|
||||||
throw;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
void
|
||||||
CServer::sendOptions(IClient* client) const
|
CServer::sendOptions(IClient* client) const
|
||||||
{
|
{
|
||||||
|
@ -2141,3 +2014,259 @@ CServer::CClipboardInfo::CClipboardInfo() :
|
||||||
{
|
{
|
||||||
// do nothing
|
// do nothing
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// --- transitional ---
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
CServer::clientConnecting(const CEvent&, void*)
|
||||||
|
{
|
||||||
|
// accept client connection
|
||||||
|
IDataSocket* socket = m_listen->accept();
|
||||||
|
if (socket == NULL) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG((CLOG_NOTE "accepted client connection"));
|
||||||
|
|
||||||
|
// filter socket's streams then wrap the result in a new socket
|
||||||
|
IInputStream* input = socket->getInputStream();
|
||||||
|
IOutputStream* output = socket->getOutputStream();
|
||||||
|
bool own = false;
|
||||||
|
if (m_streamFilterFactory != NULL) {
|
||||||
|
input = m_streamFilterFactory->createInput(input, own);
|
||||||
|
output = m_streamFilterFactory->createOutput(output, own);
|
||||||
|
own = true;
|
||||||
|
}
|
||||||
|
input = new CInputPacketStream(input, own);
|
||||||
|
output = new COutputPacketStream(output, own);
|
||||||
|
socket = new CDataSocket(socket,
|
||||||
|
new CInputOutputStream(input, output, true));
|
||||||
|
|
||||||
|
// FIXME -- may want to move these event handlers (but not the
|
||||||
|
// handshake timer?) and the handshake into a new proxy object.
|
||||||
|
// we save this proxy as a provisional connection. it calls
|
||||||
|
// back to us (or maybe sends an event) to notify of failure or
|
||||||
|
// success. failure is socket failure or protocol error.
|
||||||
|
// success returns a new proxy of the appropriate version. we
|
||||||
|
// need to verify the validity of the client's name then remove
|
||||||
|
// the provisional connection and install a true connection.
|
||||||
|
// if we keep the timer then when it expires we just remove and
|
||||||
|
// delete the provisional connection. if we install a true
|
||||||
|
// connection then we remove the timer.
|
||||||
|
CProvisionalClient* client;
|
||||||
|
try {
|
||||||
|
client = new CProvisionalClient(this, socket);
|
||||||
|
}
|
||||||
|
catch (XBase&) {
|
||||||
|
delete socket;
|
||||||
|
// handle error
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// start timer for handshake
|
||||||
|
CEventQueueTimer* timer = EVENTQUEUE->newOneShotTimer(30.0, client);
|
||||||
|
|
||||||
|
// add client to client map
|
||||||
|
m_provisional.insert(client, timer);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CServer::recvClientHello(const CEvent&, void* vsocket)
|
||||||
|
{
|
||||||
|
IDataSocket* socket = reinterpret_cast<IDataSocket*>(vsocket);
|
||||||
|
|
||||||
|
LOG((CLOG_DEBUG1 "parsing hello reply"));
|
||||||
|
|
||||||
|
CClientProxy* proxy = NULL;
|
||||||
|
CString name("<unknown>");
|
||||||
|
try {
|
||||||
|
// limit the maximum length of the hello
|
||||||
|
UInt32 n = socket->getInputStream()->getSize();
|
||||||
|
if (n > kMaxHelloLength) {
|
||||||
|
LOG((CLOG_DEBUG1 "hello reply too long"));
|
||||||
|
throw XBadClient();
|
||||||
|
}
|
||||||
|
|
||||||
|
// parse the reply to hello
|
||||||
|
SInt16 major, minor;
|
||||||
|
CProtocolUtil::readf(socket->getInputStream(), kMsgHelloBack,
|
||||||
|
&major, &minor, &name);
|
||||||
|
|
||||||
|
// disallow invalid version numbers
|
||||||
|
if (major <= 0 || minor < 0) {
|
||||||
|
throw XIncompatibleClient(major, minor);
|
||||||
|
}
|
||||||
|
|
||||||
|
// convert name to canonical form (if any)
|
||||||
|
// FIXME -- need lock?
|
||||||
|
if (m_config.isScreen(name)) {
|
||||||
|
name = m_config.getCanonicalName(name);
|
||||||
|
}
|
||||||
|
|
||||||
|
// create client proxy for highest version supported by the client
|
||||||
|
LOG((CLOG_DEBUG1 "creating proxy for client \"%s\" version %d.%d", name.c_str(), major, minor));
|
||||||
|
if (major == 1) {
|
||||||
|
switch (minor) {
|
||||||
|
case 0:
|
||||||
|
// FIXME -- should pass socket, not input and output
|
||||||
|
proxy = new CClientProxy1_0(this, name, input, output);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 1:
|
||||||
|
// FIXME -- should pass socket, not input and output
|
||||||
|
proxy = new CClientProxy1_1(this, name, input, output);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// hangup (with error) if version isn't supported
|
||||||
|
if (proxy == NULL) {
|
||||||
|
throw XIncompatibleClient(major, minor);
|
||||||
|
}
|
||||||
|
|
||||||
|
// the proxy now owns the socket
|
||||||
|
socket = NULL;
|
||||||
|
|
||||||
|
// add provisional client connection. this also checks if
|
||||||
|
// the client's name is okay (i.e. in the map and not in use).
|
||||||
|
addProvisionalClient(proxy);
|
||||||
|
|
||||||
|
// negotiate
|
||||||
|
// FIXME
|
||||||
|
|
||||||
|
// request the client's info and install a handler for it. note
|
||||||
|
// that the handshake timer is still going.
|
||||||
|
EVENTQUEUE->adoptHandler(IInputStream::getInputReadyEvent(),
|
||||||
|
socket->getInputStream(),
|
||||||
|
new TMethodEventJob<CServer>(this,
|
||||||
|
&CServer::recvClientInfo, socket));
|
||||||
|
LOG((CLOG_DEBUG1 "request info for client \"%s\"", name.c_str()));
|
||||||
|
// FIXME -- maybe should send this request some other way.
|
||||||
|
// could have the proxy itself handle the input. that makes sense
|
||||||
|
// but will have to check if that'll work. for one thing, the proxy
|
||||||
|
// will have to inform this object of any errors. it takes this
|
||||||
|
// object as a parameter so it probably can do that.
|
||||||
|
/*
|
||||||
|
proxy->open();
|
||||||
|
*/
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
catch (XDuplicateClient& e) {
|
||||||
|
// client has duplicate name
|
||||||
|
LOG((CLOG_WARN "a client with name \"%s\" is already connected", e.getName().c_str()));
|
||||||
|
CProtocolUtil::writefNoError(proxy->getOutputStream(), kMsgEBusy);
|
||||||
|
}
|
||||||
|
catch (XUnknownClient& e) {
|
||||||
|
// client has unknown name
|
||||||
|
LOG((CLOG_WARN "a client with name \"%s\" is not in the map", e.getName().c_str()));
|
||||||
|
CProtocolUtil::writefNoError(proxy->getOutputStream(), kMsgEUnknown);
|
||||||
|
}
|
||||||
|
catch (XIncompatibleClient& e) {
|
||||||
|
// client is incompatible
|
||||||
|
LOG((CLOG_WARN "client \"%s\" has incompatible version %d.%d)", name.c_str(), e.getMajor(), e.getMinor()));
|
||||||
|
CProtocolUtil::writefNoError(socket->getOutputStream(),
|
||||||
|
kMsgEIncompatible,
|
||||||
|
kProtocolMajorVersion, kProtocolMinorVersion);
|
||||||
|
}
|
||||||
|
catch (XBadClient&) {
|
||||||
|
// client not behaving
|
||||||
|
LOG((CLOG_WARN "protocol error from client \"%s\"", name.c_str()));
|
||||||
|
CProtocolUtil::writefNoError(socket->getOutputStream(), kMsgEBad);
|
||||||
|
}
|
||||||
|
catch (XIO&) {
|
||||||
|
// client not behaving
|
||||||
|
LOG((CLOG_WARN "protocol error from client \"%s\"", name.c_str()));
|
||||||
|
CProtocolUtil::writefNoError(socket->getOutputStream(), kMsgEBad);
|
||||||
|
}
|
||||||
|
catch (XBase& e) {
|
||||||
|
// misc error
|
||||||
|
LOG((CLOG_WARN "error communicating with client \"%s\": %s", name.c_str(), e.what()));
|
||||||
|
}
|
||||||
|
|
||||||
|
// FIXME -- really clean up, including event handlers and timer.
|
||||||
|
// should have a method for this.
|
||||||
|
delete proxy;
|
||||||
|
delete socket;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CServer::recvClientInfo(const CEvent&, void* vsocket)
|
||||||
|
{
|
||||||
|
// FIXME -- get client's info and proxy becomes first class citizen.
|
||||||
|
// adopt new input handler aimed at clientInput. remove timer.
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CServer::clientTimeout(const CEvent&, void* vsocket)
|
||||||
|
{
|
||||||
|
// FIXME -- client failed to connect fast enough. if client is
|
||||||
|
// already first class then just ignore this (that should never
|
||||||
|
// happen though because timer events are synthesized in the
|
||||||
|
// getEvent() so there can't be a race, so don't fuss over
|
||||||
|
// checking).
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CServer::clientInput(const CEvent&, void* vsocket)
|
||||||
|
{
|
||||||
|
// FIXME -- client has sent a message
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CServer::clientDisconnected(const CEvent&, void* vsocket)
|
||||||
|
{
|
||||||
|
// FIXME -- handle disconnection of client
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CServer::createClientListener()
|
||||||
|
{
|
||||||
|
LOG((CLOG_DEBUG1 "creating socket to listen for clients"));
|
||||||
|
|
||||||
|
assert(m_socketFactory != NULL);
|
||||||
|
IListenSocket* listen = NULL;
|
||||||
|
try {
|
||||||
|
// create socket
|
||||||
|
listen = m_socketFactory->createListen();
|
||||||
|
|
||||||
|
// setup event handler
|
||||||
|
EVENTQUEUE->adoptHandler(IListenSocket::getConnectingEvent(), listen,
|
||||||
|
new TMethodEventJob<CServer>(this,
|
||||||
|
&CServer::clientConnecting));
|
||||||
|
|
||||||
|
// bind listen address
|
||||||
|
LOG((CLOG_DEBUG1 "binding listen socket"));
|
||||||
|
listen->bind(m_config.getSynergyAddress());
|
||||||
|
}
|
||||||
|
catch (XSocketAddressInUse& e) {
|
||||||
|
if (listen != NULL) {
|
||||||
|
EVENTQUEUE->removeHandler(
|
||||||
|
IListenSocket::getConnectingEvent(), listen);
|
||||||
|
delete listen;
|
||||||
|
}
|
||||||
|
setStatus(kError, e.what());
|
||||||
|
LOG((CLOG_WARN "bind failed: %s", e.what()));
|
||||||
|
// FIXME -- throw retry in X seconds object. the caller should
|
||||||
|
// catch this and optionally wait X seconds and try again.
|
||||||
|
// alternatively we could install a timer and retry automatically.
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
catch (...) {
|
||||||
|
if (listen != NULL) {
|
||||||
|
EVENTQUEUE->removeHandler(
|
||||||
|
IListenSocket::getConnectingEvent(), listen);
|
||||||
|
delete listen;
|
||||||
|
}
|
||||||
|
/* FIXME -- set some status and log error
|
||||||
|
setStatus(kNotRunning);
|
||||||
|
setStatus(kError, e.what());
|
||||||
|
LOG((CLOG_ERR "cannot listen for clients: %s", e.what()));
|
||||||
|
*/
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
|
||||||
|
m_listen = listen;
|
||||||
|
setStatus(kRunning);
|
||||||
|
LOG((CLOG_DEBUG1 "waiting for client connections"));
|
||||||
|
}
|
||||||
|
|
|
@ -29,7 +29,6 @@
|
||||||
#include "stdvector.h"
|
#include "stdvector.h"
|
||||||
|
|
||||||
class CClientProxy;
|
class CClientProxy;
|
||||||
class CHTTPServer;
|
|
||||||
class CPrimaryClient;
|
class CPrimaryClient;
|
||||||
class IClient;
|
class IClient;
|
||||||
class IDataSocket;
|
class IDataSocket;
|
||||||
|
@ -151,6 +150,12 @@ public:
|
||||||
*/
|
*/
|
||||||
void getConfig(CConfig*) const;
|
void getConfig(CConfig*) const;
|
||||||
|
|
||||||
|
//! Get canonical screen name
|
||||||
|
/*!
|
||||||
|
Returns the canonical version of a screen name.
|
||||||
|
*/
|
||||||
|
CString getCanonicalName(const CString& name) const;
|
||||||
|
|
||||||
//! Get name
|
//! Get name
|
||||||
/*!
|
/*!
|
||||||
Returns the server's name passed to the c'tor
|
Returns the server's name passed to the c'tor
|
||||||
|
@ -295,12 +300,6 @@ private:
|
||||||
void runClient(void*);
|
void runClient(void*);
|
||||||
CClientProxy* handshakeClient(IDataSocket*);
|
CClientProxy* handshakeClient(IDataSocket*);
|
||||||
|
|
||||||
// thread method to accept incoming HTTP connections
|
|
||||||
void acceptHTTPClients(void*);
|
|
||||||
|
|
||||||
// thread method to process HTTP requests
|
|
||||||
void processHTTPRequest(void*);
|
|
||||||
|
|
||||||
// connection list maintenance
|
// connection list maintenance
|
||||||
void addConnection(IClient*);
|
void addConnection(IClient*);
|
||||||
void removeConnection(const CString& name);
|
void removeConnection(const CString& name);
|
||||||
|
@ -381,11 +380,6 @@ private:
|
||||||
IClient* m_activeSaver;
|
IClient* m_activeSaver;
|
||||||
SInt32 m_xSaver, m_ySaver;
|
SInt32 m_xSaver, m_ySaver;
|
||||||
|
|
||||||
// HTTP request processing stuff
|
|
||||||
CHTTPServer* m_httpServer;
|
|
||||||
CCondVar<SInt32> m_httpAvailable;
|
|
||||||
static const SInt32 s_httpMaxSimultaneousRequests;
|
|
||||||
|
|
||||||
// common state for screen switch tests. all tests are always
|
// common state for screen switch tests. all tests are always
|
||||||
// trying to reach the same screen in the same direction.
|
// trying to reach the same screen in the same direction.
|
||||||
EDirection m_switchDir;
|
EDirection m_switchDir;
|
||||||
|
@ -408,6 +402,15 @@ private:
|
||||||
CJobList m_statusJobs;
|
CJobList m_statusJobs;
|
||||||
EStatus m_status;
|
EStatus m_status;
|
||||||
CString m_statusMessage;
|
CString m_statusMessage;
|
||||||
|
|
||||||
|
//---
|
||||||
|
/*
|
||||||
|
IListenSocket* m_listen;
|
||||||
|
|
||||||
|
typedef std::map<CProvisionalClient*,
|
||||||
|
CEventQueueTimer*> CProvisionalClients;
|
||||||
|
CProvisionalClients m_provisional;
|
||||||
|
*/
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -29,15 +29,15 @@ libserver_a_SOURCES = \
|
||||||
CClientProxy1_0.cpp \
|
CClientProxy1_0.cpp \
|
||||||
CClientProxy1_1.cpp \
|
CClientProxy1_1.cpp \
|
||||||
CConfig.cpp \
|
CConfig.cpp \
|
||||||
CHTTPServer.cpp \
|
|
||||||
CPrimaryClient.cpp \
|
CPrimaryClient.cpp \
|
||||||
|
CProvisionalClient.cpp \
|
||||||
CServer.cpp \
|
CServer.cpp \
|
||||||
CClientProxy.h \
|
CClientProxy.h \
|
||||||
CClientProxy1_0.h \
|
CClientProxy1_0.h \
|
||||||
CClientProxy1_1.h \
|
CClientProxy1_1.h \
|
||||||
CConfig.h \
|
CConfig.h \
|
||||||
CHTTPServer.h \
|
|
||||||
CPrimaryClient.h \
|
CPrimaryClient.h \
|
||||||
|
CProvisionalClient.h \
|
||||||
CServer.h \
|
CServer.h \
|
||||||
$(NULL)
|
$(NULL)
|
||||||
INCLUDES = \
|
INCLUDES = \
|
||||||
|
@ -46,7 +46,6 @@ INCLUDES = \
|
||||||
-I$(VDEPTH)/lib/base \
|
-I$(VDEPTH)/lib/base \
|
||||||
-I$(VDEPTH)/lib/mt \
|
-I$(VDEPTH)/lib/mt \
|
||||||
-I$(VDEPTH)/lib/io \
|
-I$(VDEPTH)/lib/io \
|
||||||
-I$(VDEPTH)/lib/http \
|
|
||||||
-I$(VDEPTH)/lib/net \
|
-I$(VDEPTH)/lib/net \
|
||||||
-I$(VDEPTH)/lib/synergy \
|
-I$(VDEPTH)/lib/synergy \
|
||||||
-I$(VDEPTH)/lib/platform \
|
-I$(VDEPTH)/lib/platform \
|
||||||
|
|
|
@ -1,181 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "CInputPacketStream.h"
|
|
||||||
#include "CLock.h"
|
|
||||||
#include "CStopwatch.h"
|
|
||||||
|
|
||||||
//
|
|
||||||
// CInputPacketStream
|
|
||||||
//
|
|
||||||
|
|
||||||
CInputPacketStream::CInputPacketStream(IInputStream* stream, bool adopt) :
|
|
||||||
CInputStreamFilter(stream, adopt),
|
|
||||||
m_mutex(),
|
|
||||||
m_size(0),
|
|
||||||
m_buffer(&m_mutex, NULL)
|
|
||||||
{
|
|
||||||
// do nothing
|
|
||||||
}
|
|
||||||
|
|
||||||
CInputPacketStream::~CInputPacketStream()
|
|
||||||
{
|
|
||||||
// do nothing
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
CInputPacketStream::close()
|
|
||||||
{
|
|
||||||
getStream()->close();
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
CInputPacketStream::read(void* buffer, UInt32 n, double timeout)
|
|
||||||
{
|
|
||||||
CLock lock(&m_mutex);
|
|
||||||
|
|
||||||
// wait for entire message to be read. return if stream
|
|
||||||
// hungup or timeout.
|
|
||||||
switch (waitForFullMessage(timeout)) {
|
|
||||||
case kData:
|
|
||||||
break;
|
|
||||||
|
|
||||||
case kHungup:
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
case kTimedout:
|
|
||||||
return (UInt32)-1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// limit number of bytes to read to the number of bytes left in the
|
|
||||||
// current message.
|
|
||||||
if (n > m_size) {
|
|
||||||
n = m_size;
|
|
||||||
}
|
|
||||||
|
|
||||||
// now read from our buffer
|
|
||||||
n = m_buffer.readNoLock(buffer, n, -1.0);
|
|
||||||
assert(n <= m_size);
|
|
||||||
m_size -= n;
|
|
||||||
|
|
||||||
return n;
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
CInputPacketStream::getSize() const
|
|
||||||
{
|
|
||||||
CLock lock(&m_mutex);
|
|
||||||
return getSizeNoLock();
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
CInputPacketStream::getSizeNoLock() const
|
|
||||||
{
|
|
||||||
CStopwatch timer(true);
|
|
||||||
while (!hasFullMessage() && getStream()->getSize() > 0) {
|
|
||||||
// read more data
|
|
||||||
if (getMoreMessage(-1.0) != kData) {
|
|
||||||
// stream hungup
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return m_size;
|
|
||||||
}
|
|
||||||
|
|
||||||
CInputPacketStream::EResult
|
|
||||||
CInputPacketStream::waitForFullMessage(double timeout) const
|
|
||||||
{
|
|
||||||
CStopwatch timer(true);
|
|
||||||
while (!hasFullMessage()) {
|
|
||||||
// compute remaining timeout
|
|
||||||
double t = timeout - timer.getTime();
|
|
||||||
if (timeout >= 0.0 && t <= 0.0) {
|
|
||||||
// timeout
|
|
||||||
return kTimedout;
|
|
||||||
}
|
|
||||||
|
|
||||||
// read more data
|
|
||||||
switch (getMoreMessage(t)) {
|
|
||||||
case kData:
|
|
||||||
break;
|
|
||||||
|
|
||||||
case kHungup:
|
|
||||||
// stream hungup
|
|
||||||
return kHungup;
|
|
||||||
|
|
||||||
case kTimedout:
|
|
||||||
// stream timed out
|
|
||||||
return kTimedout;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return kData;
|
|
||||||
}
|
|
||||||
|
|
||||||
CInputPacketStream::EResult
|
|
||||||
CInputPacketStream::getMoreMessage(double timeout) const
|
|
||||||
{
|
|
||||||
// read more data
|
|
||||||
char buffer[4096];
|
|
||||||
UInt32 n = getStream()->read(buffer, sizeof(buffer), timeout);
|
|
||||||
|
|
||||||
// return if stream timed out
|
|
||||||
if (n == (UInt32)-1) {
|
|
||||||
return kTimedout;
|
|
||||||
}
|
|
||||||
|
|
||||||
// return if stream hungup
|
|
||||||
if (n == 0) {
|
|
||||||
m_buffer.hangup();
|
|
||||||
return kHungup;
|
|
||||||
}
|
|
||||||
|
|
||||||
// append to our buffer
|
|
||||||
m_buffer.write(buffer, n);
|
|
||||||
|
|
||||||
return kData;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool
|
|
||||||
CInputPacketStream::hasFullMessage() const
|
|
||||||
{
|
|
||||||
// get payload length if we don't have it yet
|
|
||||||
if (m_size == 0) {
|
|
||||||
// check if length field has been read yet
|
|
||||||
if (m_buffer.getSizeNoLock() < 4) {
|
|
||||||
// not enough data for payload length
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
// save payload length
|
|
||||||
UInt8 buffer[4];
|
|
||||||
UInt32 n = m_buffer.readNoLock(buffer, sizeof(buffer), -1.0);
|
|
||||||
assert(n == 4);
|
|
||||||
m_size = ((UInt32)buffer[0] << 24) |
|
|
||||||
((UInt32)buffer[1] << 16) |
|
|
||||||
((UInt32)buffer[2] << 8) |
|
|
||||||
(UInt32)buffer[3];
|
|
||||||
|
|
||||||
// if payload length is zero then discard null message
|
|
||||||
if (m_size == 0) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
assert(m_size > 0);
|
|
||||||
|
|
||||||
// we have the full message when we have at least m_size bytes in
|
|
||||||
// the buffer
|
|
||||||
return (m_buffer.getSizeNoLock() >= m_size);
|
|
||||||
}
|
|
|
@ -1,51 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef CINPUTPACKETSTREAM_H
|
|
||||||
#define CINPUTPACKETSTREAM_H
|
|
||||||
|
|
||||||
#include "CInputStreamFilter.h"
|
|
||||||
#include "CBufferedInputStream.h"
|
|
||||||
#include "CMutex.h"
|
|
||||||
|
|
||||||
//! Packetizing input stream filter
|
|
||||||
/*!
|
|
||||||
Filters an input stream to extract packet by packet.
|
|
||||||
*/
|
|
||||||
class CInputPacketStream : public CInputStreamFilter {
|
|
||||||
public:
|
|
||||||
CInputPacketStream(IInputStream*, bool adoptStream = true);
|
|
||||||
~CInputPacketStream();
|
|
||||||
|
|
||||||
// IInputStream overrides
|
|
||||||
virtual void close();
|
|
||||||
virtual UInt32 read(void*, UInt32 maxCount, double timeout);
|
|
||||||
virtual UInt32 getSize() const;
|
|
||||||
|
|
||||||
private:
|
|
||||||
enum EResult { kData, kHungup, kTimedout };
|
|
||||||
|
|
||||||
UInt32 getSizeNoLock() const;
|
|
||||||
EResult waitForFullMessage(double timeout) const;
|
|
||||||
EResult getMoreMessage(double timeout) const;
|
|
||||||
bool hasFullMessage() const;
|
|
||||||
|
|
||||||
private:
|
|
||||||
CMutex m_mutex;
|
|
||||||
mutable UInt32 m_size;
|
|
||||||
mutable CBufferedInputStream m_buffer;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
|
@ -1,72 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "COutputPacketStream.h"
|
|
||||||
|
|
||||||
//
|
|
||||||
// COuputPacketStream
|
|
||||||
//
|
|
||||||
|
|
||||||
COutputPacketStream::COutputPacketStream(IOutputStream* stream, bool adopt) :
|
|
||||||
COutputStreamFilter(stream, adopt)
|
|
||||||
{
|
|
||||||
// do nothing
|
|
||||||
}
|
|
||||||
|
|
||||||
COutputPacketStream::~COutputPacketStream()
|
|
||||||
{
|
|
||||||
// do nothing
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
COutputPacketStream::close()
|
|
||||||
{
|
|
||||||
getStream()->close();
|
|
||||||
}
|
|
||||||
|
|
||||||
UInt32
|
|
||||||
COutputPacketStream::write(const void* buffer, UInt32 count)
|
|
||||||
{
|
|
||||||
// write the length of the payload
|
|
||||||
UInt8 length[4];
|
|
||||||
length[0] = (UInt8)((count >> 24) & 0xff);
|
|
||||||
length[1] = (UInt8)((count >> 16) & 0xff);
|
|
||||||
length[2] = (UInt8)((count >> 8) & 0xff);
|
|
||||||
length[3] = (UInt8)( count & 0xff);
|
|
||||||
UInt32 count2 = sizeof(length);
|
|
||||||
const UInt8* cbuffer = length;
|
|
||||||
while (count2 > 0) {
|
|
||||||
UInt32 n = getStream()->write(cbuffer, count2);
|
|
||||||
cbuffer += n;
|
|
||||||
count2 -= n;
|
|
||||||
}
|
|
||||||
|
|
||||||
// write the payload
|
|
||||||
count2 = count;
|
|
||||||
cbuffer = reinterpret_cast<const UInt8*>(buffer);
|
|
||||||
while (count2 > 0) {
|
|
||||||
UInt32 n = getStream()->write(cbuffer, count2);
|
|
||||||
cbuffer += n;
|
|
||||||
count2 -= n;
|
|
||||||
}
|
|
||||||
|
|
||||||
return count;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
COutputPacketStream::flush()
|
|
||||||
{
|
|
||||||
getStream()->flush();
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,36 +0,0 @@
|
||||||
/*
|
|
||||||
* synergy -- mouse and keyboard sharing utility
|
|
||||||
* Copyright (C) 2002 Chris Schoeneman
|
|
||||||
*
|
|
||||||
* This package is free software; you can redistribute it and/or
|
|
||||||
* modify it under the terms of the GNU General Public License
|
|
||||||
* found in the file COPYING that should have accompanied this file.
|
|
||||||
*
|
|
||||||
* This package is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef COUTPUTPACKETSTREAM_H
|
|
||||||
#define COUTPUTPACKETSTREAM_H
|
|
||||||
|
|
||||||
#include "COutputStreamFilter.h"
|
|
||||||
|
|
||||||
//! Packetizing output stream filter
|
|
||||||
/*!
|
|
||||||
Filters an output stream to create packets that include message
|
|
||||||
boundaries. Each write() is considered a single packet.
|
|
||||||
*/
|
|
||||||
class COutputPacketStream : public COutputStreamFilter {
|
|
||||||
public:
|
|
||||||
COutputPacketStream(IOutputStream*, bool adoptStream = true);
|
|
||||||
~COutputPacketStream();
|
|
||||||
|
|
||||||
// IOutputStream overrides
|
|
||||||
virtual void close();
|
|
||||||
virtual UInt32 write(const void*, UInt32 count);
|
|
||||||
virtual void flush();
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -0,0 +1,221 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "CPacketStreamFilter.h"
|
||||||
|
#include "IEventQueue.h"
|
||||||
|
#include "CLock.h"
|
||||||
|
#include "TMethodEventJob.h"
|
||||||
|
|
||||||
|
//
|
||||||
|
// CPacketStreamFilter
|
||||||
|
//
|
||||||
|
|
||||||
|
CPacketStreamFilter::CPacketStreamFilter(IStream* stream, bool adoptStream) :
|
||||||
|
CStreamFilter(stream, adoptStream),
|
||||||
|
m_size(0),
|
||||||
|
m_eventFilter(NULL),
|
||||||
|
m_inputShutdown(false)
|
||||||
|
{
|
||||||
|
// install event filter
|
||||||
|
getStream()->setEventFilter(new TMethodEventJob<CPacketStreamFilter>(
|
||||||
|
this, &CPacketStreamFilter::filterEvent, NULL));
|
||||||
|
}
|
||||||
|
|
||||||
|
CPacketStreamFilter::~CPacketStreamFilter()
|
||||||
|
{
|
||||||
|
delete getStream()->getEventFilter();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CPacketStreamFilter::close()
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
m_size = 0;
|
||||||
|
m_buffer.pop(m_buffer.getSize());
|
||||||
|
CStreamFilter::close();
|
||||||
|
}
|
||||||
|
|
||||||
|
UInt32
|
||||||
|
CPacketStreamFilter::read(void* buffer, UInt32 n)
|
||||||
|
{
|
||||||
|
if (n == 0) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
|
||||||
|
// if not enough data yet then give up
|
||||||
|
if (!isReadyNoLock()) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
// read no more than what's left in the buffered packet
|
||||||
|
if (n > m_size) {
|
||||||
|
n = m_size;
|
||||||
|
}
|
||||||
|
|
||||||
|
// read it
|
||||||
|
if (buffer != NULL) {
|
||||||
|
memcpy(buffer, m_buffer.peek(n), n);
|
||||||
|
}
|
||||||
|
m_buffer.pop(n);
|
||||||
|
m_size -= n;
|
||||||
|
|
||||||
|
// get next packet's size if we've finished with this packet and
|
||||||
|
// there's enough data to do so.
|
||||||
|
readPacketSize();
|
||||||
|
|
||||||
|
if (m_inputShutdown && m_size == 0) {
|
||||||
|
sendEvent(CEvent(getInputShutdownEvent(), getEventTarget(), NULL));
|
||||||
|
}
|
||||||
|
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CPacketStreamFilter::write(const void* buffer, UInt32 count)
|
||||||
|
{
|
||||||
|
// write the length of the payload
|
||||||
|
UInt8 length[4];
|
||||||
|
length[0] = (UInt8)((count >> 24) & 0xff);
|
||||||
|
length[1] = (UInt8)((count >> 16) & 0xff);
|
||||||
|
length[2] = (UInt8)((count >> 8) & 0xff);
|
||||||
|
length[3] = (UInt8)( count & 0xff);
|
||||||
|
getStream()->write(length, sizeof(length));
|
||||||
|
|
||||||
|
// write the payload
|
||||||
|
getStream()->write(buffer, count);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CPacketStreamFilter::shutdownInput()
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
m_size = 0;
|
||||||
|
m_buffer.pop(m_buffer.getSize());
|
||||||
|
CStreamFilter::shutdownInput();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CPacketStreamFilter::setEventFilter(IEventJob* filter)
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
m_eventFilter = filter;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool
|
||||||
|
CPacketStreamFilter::isReady() const
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
return isReadyNoLock();
|
||||||
|
}
|
||||||
|
|
||||||
|
UInt32
|
||||||
|
CPacketStreamFilter::getSize() const
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
return isReadyNoLock() ? m_size : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
IEventJob*
|
||||||
|
CPacketStreamFilter::getEventFilter() const
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
return m_eventFilter;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool
|
||||||
|
CPacketStreamFilter::isReadyNoLock() const
|
||||||
|
{
|
||||||
|
return (m_size != 0 && m_buffer.getSize() >= m_size);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CPacketStreamFilter::readPacketSize()
|
||||||
|
{
|
||||||
|
// note -- m_mutex must be locked on entry
|
||||||
|
|
||||||
|
if (m_size == 0 && m_buffer.getSize() >= 4) {
|
||||||
|
UInt8 buffer[4];
|
||||||
|
memcpy(buffer, m_buffer.peek(sizeof(buffer)), sizeof(buffer));
|
||||||
|
m_buffer.pop(sizeof(buffer));
|
||||||
|
m_size = ((UInt32)buffer[0] << 24) |
|
||||||
|
((UInt32)buffer[1] << 16) |
|
||||||
|
((UInt32)buffer[2] << 8) |
|
||||||
|
(UInt32)buffer[3];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CPacketStreamFilter::readMore()
|
||||||
|
{
|
||||||
|
// note -- m_mutex must be locked on entry
|
||||||
|
|
||||||
|
// note if we have whole packet
|
||||||
|
bool wasReady = isReadyNoLock();
|
||||||
|
|
||||||
|
// read more data
|
||||||
|
char buffer[4096];
|
||||||
|
UInt32 n = getStream()->read(buffer, sizeof(buffer));
|
||||||
|
while (n > 0) {
|
||||||
|
m_buffer.write(buffer, n);
|
||||||
|
n = getStream()->read(buffer, sizeof(buffer));
|
||||||
|
}
|
||||||
|
|
||||||
|
// if we don't yet have the next packet size then get it,
|
||||||
|
// if possible.
|
||||||
|
readPacketSize();
|
||||||
|
|
||||||
|
// note if we now have a whole packet
|
||||||
|
bool isReady = isReadyNoLock();
|
||||||
|
|
||||||
|
// if we weren't ready before but now we are then send a
|
||||||
|
// input ready event apparently from the filtered stream.
|
||||||
|
if (wasReady != isReady) {
|
||||||
|
sendEvent(CEvent(getInputReadyEvent(), getEventTarget(), NULL));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CPacketStreamFilter::sendEvent(const CEvent& event)
|
||||||
|
{
|
||||||
|
if (m_eventFilter != NULL) {
|
||||||
|
m_eventFilter->run(event);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
EVENTQUEUE->addEvent(event);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CPacketStreamFilter::filterEvent(const CEvent& event, void*)
|
||||||
|
{
|
||||||
|
CLock lock(&m_mutex);
|
||||||
|
|
||||||
|
if (event.getType() == getInputReadyEvent()) {
|
||||||
|
readMore();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
else if (event.getType() == getInputShutdownEvent()) {
|
||||||
|
// discard this if we have buffered data
|
||||||
|
m_inputShutdown = true;
|
||||||
|
if (m_size == 0) {
|
||||||
|
sendEvent(CEvent(getInputShutdownEvent(), getEventTarget(), NULL));
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// pass event
|
||||||
|
sendEvent(event);
|
||||||
|
}
|
|
@ -0,0 +1,57 @@
|
||||||
|
/*
|
||||||
|
* synergy -- mouse and keyboard sharing utility
|
||||||
|
* Copyright (C) 2004 Chris Schoeneman
|
||||||
|
*
|
||||||
|
* This package is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License
|
||||||
|
* found in the file COPYING that should have accompanied this file.
|
||||||
|
*
|
||||||
|
* This package is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CPACKETSTREAMFILTER_H
|
||||||
|
#define CPACKETSTREAMFILTER_H
|
||||||
|
|
||||||
|
#include "CStreamFilter.h"
|
||||||
|
#include "CStreamBuffer.h"
|
||||||
|
#include "CMutex.h"
|
||||||
|
|
||||||
|
//! Packetizing stream filter
|
||||||
|
/*!
|
||||||
|
Filters a stream to read and write packets.
|
||||||
|
*/
|
||||||
|
class CPacketStreamFilter : public CStreamFilter {
|
||||||
|
public:
|
||||||
|
CPacketStreamFilter(IStream* stream, bool adoptStream = true);
|
||||||
|
~CPacketStreamFilter();
|
||||||
|
|
||||||
|
// IStream overrides
|
||||||
|
virtual void close();
|
||||||
|
virtual UInt32 read(void* buffer, UInt32 n);
|
||||||
|
virtual void write(const void* buffer, UInt32 n);
|
||||||
|
virtual void shutdownInput();
|
||||||
|
virtual void setEventFilter(IEventJob* filter);
|
||||||
|
virtual bool isReady() const;
|
||||||
|
virtual UInt32 getSize() const;
|
||||||
|
virtual IEventJob* getEventFilter() const;
|
||||||
|
|
||||||
|
private:
|
||||||
|
bool isReadyNoLock() const;
|
||||||
|
void readPacketSize();
|
||||||
|
|
||||||
|
void readMore();
|
||||||
|
void sendEvent(const CEvent&);
|
||||||
|
void filterEvent(const CEvent&, void*);
|
||||||
|
|
||||||
|
private:
|
||||||
|
CMutex m_mutex;
|
||||||
|
UInt32 m_size;
|
||||||
|
CStreamBuffer m_buffer;
|
||||||
|
IEventJob* m_eventFilter;
|
||||||
|
bool m_inputShutdown;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif
|
|
@ -13,8 +13,7 @@
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "CProtocolUtil.h"
|
#include "CProtocolUtil.h"
|
||||||
#include "IInputStream.h"
|
#include "IStream.h"
|
||||||
#include "IOutputStream.h"
|
|
||||||
#include "CLog.h"
|
#include "CLog.h"
|
||||||
#include "stdvector.h"
|
#include "stdvector.h"
|
||||||
#include <cctype>
|
#include <cctype>
|
||||||
|
@ -25,51 +24,77 @@
|
||||||
//
|
//
|
||||||
|
|
||||||
void
|
void
|
||||||
CProtocolUtil::writef(IOutputStream* stream, const char* fmt, ...)
|
CProtocolUtil::writef(IStream* stream, const char* fmt, ...)
|
||||||
{
|
{
|
||||||
assert(stream != NULL);
|
assert(stream != NULL);
|
||||||
assert(fmt != NULL);
|
assert(fmt != NULL);
|
||||||
LOG((CLOG_DEBUG2 "writef(%s)", fmt));
|
LOG((CLOG_DEBUG2 "writef(%s)", fmt));
|
||||||
|
|
||||||
va_list args;
|
va_list args;
|
||||||
|
|
||||||
// determine total size to write
|
|
||||||
va_start(args, fmt);
|
va_start(args, fmt);
|
||||||
UInt32 count = getLength(fmt, args);
|
UInt32 size = getLength(fmt, args);
|
||||||
va_end(args);
|
va_end(args);
|
||||||
|
|
||||||
// done if nothing to write
|
|
||||||
if (count == 0) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// fill buffer
|
|
||||||
UInt8* buffer = new UInt8[count];
|
|
||||||
va_start(args, fmt);
|
va_start(args, fmt);
|
||||||
writef(buffer, fmt, args);
|
vwritef(stream, fmt, size, args);
|
||||||
va_end(args);
|
va_end(args);
|
||||||
|
|
||||||
// write buffer
|
|
||||||
UInt8* scan = buffer;
|
|
||||||
while (count > 0) {
|
|
||||||
const UInt32 n = stream->write(scan, count);
|
|
||||||
LOG((CLOG_DEBUG2 "wrote %d of %d bytes", n, count));
|
|
||||||
count -= n;
|
|
||||||
scan += n;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
delete[] buffer;
|
bool
|
||||||
}
|
CProtocolUtil::readf(IStream* stream, const char* fmt, ...)
|
||||||
|
|
||||||
void
|
|
||||||
CProtocolUtil::readf(IInputStream* stream, const char* fmt, ...)
|
|
||||||
{
|
{
|
||||||
assert(stream != NULL);
|
assert(stream != NULL);
|
||||||
assert(fmt != NULL);
|
assert(fmt != NULL);
|
||||||
LOG((CLOG_DEBUG2 "readf(%s)", fmt));
|
LOG((CLOG_DEBUG2 "readf(%s)", fmt));
|
||||||
|
|
||||||
|
bool result;
|
||||||
va_list args;
|
va_list args;
|
||||||
va_start(args, fmt);
|
va_start(args, fmt);
|
||||||
|
try {
|
||||||
|
vreadf(stream, fmt, args);
|
||||||
|
result = true;
|
||||||
|
}
|
||||||
|
catch (XIO&) {
|
||||||
|
result = false;
|
||||||
|
}
|
||||||
|
va_end(args);
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CProtocolUtil::vwritef(IStream* stream,
|
||||||
|
const char* fmt, UInt32 size, va_list args)
|
||||||
|
{
|
||||||
|
assert(stream != NULL);
|
||||||
|
assert(fmt != NULL);
|
||||||
|
|
||||||
|
// done if nothing to write
|
||||||
|
if (size == 0) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// fill buffer
|
||||||
|
// FIXME -- can we use alloca?
|
||||||
|
UInt8* buffer = new UInt8[size];
|
||||||
|
writef(buffer, fmt, args);
|
||||||
|
|
||||||
|
try {
|
||||||
|
// write buffer
|
||||||
|
stream->write(buffer, size);
|
||||||
|
LOG((CLOG_DEBUG2 "wrote %d bytes", size));
|
||||||
|
|
||||||
|
delete[] buffer;
|
||||||
|
}
|
||||||
|
catch (XBase&) {
|
||||||
|
delete[] buffer;
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool
|
||||||
|
CProtocolUtil::vreadf(IStream* stream, const char* fmt, va_list args)
|
||||||
|
{
|
||||||
|
assert(stream != NULL);
|
||||||
|
assert(fmt != NULL);
|
||||||
|
|
||||||
// begin scanning
|
// begin scanning
|
||||||
while (*fmt) {
|
while (*fmt) {
|
||||||
|
@ -242,8 +267,6 @@ CProtocolUtil::readf(IInputStream* stream, const char* fmt, ...)
|
||||||
++fmt;
|
++fmt;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
va_end(args);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
UInt32
|
UInt32
|
||||||
|
@ -485,7 +508,7 @@ CProtocolUtil::eatLength(const char** pfmt)
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CProtocolUtil::read(IInputStream* stream, void* vbuffer, UInt32 count)
|
CProtocolUtil::read(IStream* stream, void* vbuffer, UInt32 count)
|
||||||
{
|
{
|
||||||
assert(stream != NULL);
|
assert(stream != NULL);
|
||||||
assert(vbuffer != NULL);
|
assert(vbuffer != NULL);
|
||||||
|
@ -493,7 +516,7 @@ CProtocolUtil::read(IInputStream* stream, void* vbuffer, UInt32 count)
|
||||||
UInt8* buffer = reinterpret_cast<UInt8*>(vbuffer);
|
UInt8* buffer = reinterpret_cast<UInt8*>(vbuffer);
|
||||||
while (count > 0) {
|
while (count > 0) {
|
||||||
// read more
|
// read more
|
||||||
UInt32 n = stream->read(buffer, count, -1.0);
|
UInt32 n = stream->read(buffer, count);
|
||||||
|
|
||||||
// bail if stream has hungup
|
// bail if stream has hungup
|
||||||
if (n == 0) {
|
if (n == 0) {
|
||||||
|
|
|
@ -19,8 +19,7 @@
|
||||||
#include "XIO.h"
|
#include "XIO.h"
|
||||||
#include <stdarg.h>
|
#include <stdarg.h>
|
||||||
|
|
||||||
class IInputStream;
|
class IStream;
|
||||||
class IOutputStream;
|
|
||||||
|
|
||||||
//! Synergy protocol utilities
|
//! Synergy protocol utilities
|
||||||
/*!
|
/*!
|
||||||
|
@ -47,13 +46,14 @@ public:
|
||||||
- \%s -- converts CString* to stream of bytes
|
- \%s -- converts CString* to stream of bytes
|
||||||
- \%S -- converts integer N and const UInt8* to stream of N bytes
|
- \%S -- converts integer N and const UInt8* to stream of N bytes
|
||||||
*/
|
*/
|
||||||
static void writef(IOutputStream*,
|
static void writef(IStream*,
|
||||||
const char* fmt, ...);
|
const char* fmt, ...);
|
||||||
|
|
||||||
//! Read formatted data
|
//! Read formatted data
|
||||||
/*!
|
/*!
|
||||||
Read formatted binary data from a buffer. This performs the
|
Read formatted binary data from a buffer. This performs the
|
||||||
reverse operation of writef().
|
reverse operation of writef(). Returns true if the entire
|
||||||
|
format was successfully parsed, false otherwise.
|
||||||
|
|
||||||
Format specifiers are:
|
Format specifiers are:
|
||||||
- \%\% -- read (and discard) a literal `\%'
|
- \%\% -- read (and discard) a literal `\%'
|
||||||
|
@ -65,14 +65,19 @@ public:
|
||||||
- \%4I -- reads NBO 4 byte integers; arg is std::vector<UInt32>*
|
- \%4I -- reads NBO 4 byte integers; arg is std::vector<UInt32>*
|
||||||
- \%s -- reads bytes; argument must be a CString*, \b not a char*
|
- \%s -- reads bytes; argument must be a CString*, \b not a char*
|
||||||
*/
|
*/
|
||||||
static void readf(IInputStream*,
|
static bool readf(IStream*,
|
||||||
const char* fmt, ...);
|
const char* fmt, ...);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
|
static void vwritef(IStream*,
|
||||||
|
const char* fmt, UInt32 size, va_list);
|
||||||
|
static bool vreadf(IStream*,
|
||||||
|
const char* fmt, va_list);
|
||||||
|
|
||||||
static UInt32 getLength(const char* fmt, va_list);
|
static UInt32 getLength(const char* fmt, va_list);
|
||||||
static void writef(void*, const char* fmt, va_list);
|
static void writef(void*, const char* fmt, va_list);
|
||||||
static UInt32 eatLength(const char** fmt);
|
static UInt32 eatLength(const char** fmt);
|
||||||
static void read(IInputStream*, void*, UInt32);
|
static void read(IStream*, void*, UInt32);
|
||||||
};
|
};
|
||||||
|
|
||||||
//! Mismatched read exception
|
//! Mismatched read exception
|
||||||
|
|
|
@ -26,15 +26,13 @@ MAINTAINERCLEANFILES = \
|
||||||
noinst_LIBRARIES = libsynergy.a
|
noinst_LIBRARIES = libsynergy.a
|
||||||
libsynergy_a_SOURCES = \
|
libsynergy_a_SOURCES = \
|
||||||
CClipboard.cpp \
|
CClipboard.cpp \
|
||||||
CInputPacketStream.cpp \
|
CPacketStreamFilter.cpp \
|
||||||
COutputPacketStream.cpp \
|
|
||||||
CProtocolUtil.cpp \
|
CProtocolUtil.cpp \
|
||||||
CScreen.cpp \
|
CScreen.cpp \
|
||||||
XScreen.cpp \
|
XScreen.cpp \
|
||||||
XSynergy.cpp \
|
XSynergy.cpp \
|
||||||
CClipboard.h \
|
CClipboard.h \
|
||||||
CInputPacketStream.h \
|
CPacketStreamFilter.h \
|
||||||
COutputPacketStream.h \
|
|
||||||
CProtocolUtil.h \
|
CProtocolUtil.h \
|
||||||
CScreen.h \
|
CScreen.h \
|
||||||
ClipboardTypes.h \
|
ClipboardTypes.h \
|
||||||
|
|
Loading…
Reference in New Issue