2001-10-08 19:24:46 +00:00
|
|
|
#include "CClient.h"
|
2001-11-19 00:33:36 +00:00
|
|
|
#include "CString.h"
|
2002-05-31 14:25:26 +00:00
|
|
|
#include "CLog.h"
|
2002-06-08 21:48:00 +00:00
|
|
|
#include "CCondVar.h"
|
|
|
|
#include "CLock.h"
|
2002-05-31 14:25:26 +00:00
|
|
|
#include "CMutex.h"
|
2001-11-19 00:33:36 +00:00
|
|
|
#include "CNetwork.h"
|
2001-10-08 19:24:46 +00:00
|
|
|
#include "CNetworkAddress.h"
|
2002-06-04 12:26:23 +00:00
|
|
|
#include "CPlatform.h"
|
2001-10-14 18:29:43 +00:00
|
|
|
#include "CThread.h"
|
2002-06-02 18:49:35 +00:00
|
|
|
#include "XThread.h"
|
2002-06-04 11:06:26 +00:00
|
|
|
#include "ProtocolTypes.h"
|
|
|
|
#include "Version.h"
|
2002-06-01 19:26:11 +00:00
|
|
|
#include <assert.h>
|
2001-10-08 19:24:46 +00:00
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
// platform dependent name of a daemon
|
|
|
|
#if defined(CONFIG_PLATFORM_WIN32)
|
|
|
|
#define DAEMON "service"
|
|
|
|
#define DAEMON_NAME "Synergy Client"
|
|
|
|
#elif defined(CONFIG_PLATFORM_UNIX)
|
|
|
|
#define DAEMON "daemon"
|
|
|
|
#define DAEMON_NAME "synergy"
|
|
|
|
#endif
|
|
|
|
|
2002-06-04 11:06:26 +00:00
|
|
|
//
|
|
|
|
// program arguments
|
|
|
|
//
|
|
|
|
|
|
|
|
static const char* pname = NULL;
|
|
|
|
static bool s_restartable = true;
|
|
|
|
static bool s_daemon = true;
|
2002-06-08 21:48:00 +00:00
|
|
|
static bool s_install = false;
|
|
|
|
static bool s_uninstall = false;
|
2002-06-04 11:06:26 +00:00
|
|
|
static const char* s_logFilter = NULL;
|
|
|
|
static const char* s_serverName = NULL;
|
|
|
|
|
|
|
|
|
2002-05-31 14:25:26 +00:00
|
|
|
//
|
|
|
|
// logging thread safety
|
|
|
|
//
|
|
|
|
|
|
|
|
static CMutex* s_logMutex = NULL;
|
|
|
|
|
|
|
|
static void logLock(bool lock)
|
|
|
|
{
|
|
|
|
assert(s_logMutex != NULL);
|
|
|
|
|
|
|
|
if (lock) {
|
|
|
|
s_logMutex->lock();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
s_logMutex->unlock();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
2002-06-08 21:48:00 +00:00
|
|
|
// platform independent main
|
2002-05-31 14:25:26 +00:00
|
|
|
//
|
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
static CClient* s_client = NULL;
|
2002-05-31 14:25:26 +00:00
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
static int realMain(CMutex* mutex)
|
|
|
|
{
|
|
|
|
static const UInt16 port = 50001; // FIXME
|
2002-05-31 14:25:26 +00:00
|
|
|
|
2001-11-19 00:33:36 +00:00
|
|
|
try {
|
2002-06-08 21:48:00 +00:00
|
|
|
// initialize threading library
|
|
|
|
CThread::init();
|
|
|
|
|
|
|
|
// make logging thread safe
|
|
|
|
CMutex logMutex;
|
|
|
|
s_logMutex = &logMutex;
|
|
|
|
CLog::setLock(&logLock);
|
|
|
|
|
|
|
|
bool locked = true;
|
|
|
|
try {
|
|
|
|
// initialize network library
|
|
|
|
CNetwork::init();
|
|
|
|
|
|
|
|
// create client
|
|
|
|
CNetworkAddress addr(s_serverName, port);
|
|
|
|
s_client = new CClient("secondary"); // FIXME
|
|
|
|
|
|
|
|
// run client
|
|
|
|
if (mutex != NULL) {
|
|
|
|
mutex->unlock();
|
|
|
|
}
|
|
|
|
locked = false;
|
|
|
|
s_client->run(addr);
|
|
|
|
locked = true;
|
|
|
|
if (mutex != NULL) {
|
|
|
|
mutex->lock();
|
|
|
|
}
|
|
|
|
|
|
|
|
// clean up
|
|
|
|
delete s_client;
|
|
|
|
s_client = NULL;
|
|
|
|
CNetwork::cleanup();
|
|
|
|
CLog::setLock(NULL);
|
|
|
|
s_logMutex = NULL;
|
|
|
|
}
|
|
|
|
catch (...) {
|
|
|
|
// clean up
|
|
|
|
if (!locked && mutex != NULL) {
|
|
|
|
mutex->lock();
|
|
|
|
}
|
|
|
|
delete s_client;
|
|
|
|
s_client = NULL;
|
|
|
|
CNetwork::cleanup();
|
|
|
|
CLog::setLock(NULL);
|
|
|
|
s_logMutex = NULL;
|
|
|
|
throw;
|
|
|
|
}
|
2001-11-19 00:33:36 +00:00
|
|
|
}
|
2002-06-08 21:48:00 +00:00
|
|
|
catch (XBase& e) {
|
|
|
|
log((CLOG_CRIT "failed: %s", e.what()));
|
|
|
|
return 16;
|
|
|
|
}
|
|
|
|
catch (XThread&) {
|
|
|
|
// terminated
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int restartMain()
|
|
|
|
{
|
|
|
|
return realMain(NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
// invoke realMain and wait for it. if s_restartable then keep
|
|
|
|
// restarting realMain until it returns a terminate code.
|
|
|
|
static int restartableMain()
|
|
|
|
{
|
|
|
|
if (s_restartable) {
|
|
|
|
CPlatform platform;
|
|
|
|
return platform.restart(restartMain, 16);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return realMain(NULL);
|
2001-11-19 00:33:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-05-31 14:25:26 +00:00
|
|
|
|
2002-06-04 11:06:26 +00:00
|
|
|
//
|
|
|
|
// command line parsing
|
|
|
|
//
|
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
#define BYE "\nTry `%s --help' for more information."
|
|
|
|
|
|
|
|
static void (*bye)(int) = &exit;
|
2002-06-04 11:06:26 +00:00
|
|
|
|
|
|
|
static void version()
|
|
|
|
{
|
|
|
|
log((CLOG_PRINT
|
|
|
|
"%s %d.%d.%d, protocol version %d.%d\n"
|
|
|
|
"%s",
|
|
|
|
pname,
|
|
|
|
kMajorVersion,
|
|
|
|
kMinorVersion,
|
|
|
|
kReleaseVersion,
|
|
|
|
kProtocolMajorVersion,
|
|
|
|
kProtocolMinorVersion,
|
|
|
|
kCopyright));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void help()
|
|
|
|
{
|
|
|
|
log((CLOG_PRINT
|
|
|
|
"Usage: %s"
|
|
|
|
" [--debug <level>]"
|
2002-06-08 21:48:00 +00:00
|
|
|
" [--"DAEMON"|--no-"DAEMON"]"
|
2002-06-04 11:06:26 +00:00
|
|
|
" [--restart|--no-restart]"
|
2002-06-08 21:48:00 +00:00
|
|
|
" [--install]"
|
2002-06-04 11:06:26 +00:00
|
|
|
" <server-address>\n"
|
2002-06-08 21:48:00 +00:00
|
|
|
"or\n"
|
|
|
|
" --uninstall\n"
|
2002-06-04 11:06:26 +00:00
|
|
|
"Start the synergy mouse/keyboard sharing server.\n"
|
|
|
|
"\n"
|
|
|
|
" -d, --debug <level> filter out log messages with priorty below level.\n"
|
|
|
|
" level may be: FATAL, ERROR, WARNING, NOTE, INFO,\n"
|
|
|
|
" DEBUG, DEBUG1, DEBUG2.\n"
|
2002-06-08 21:48:00 +00:00
|
|
|
" -f, --no-"DAEMON" run the client in the foreground.\n"
|
|
|
|
"* --"DAEMON" run the client as a "DAEMON".\n"
|
2002-06-04 11:06:26 +00:00
|
|
|
" -1, --no-restart do not try to restart the client if it fails for\n"
|
|
|
|
" some reason.\n"
|
2002-06-08 21:48:00 +00:00
|
|
|
"* --restart restart the client automatically if it fails.\n"
|
|
|
|
" --install install server as a "DAEMON".\n"
|
|
|
|
" --uninstall uninstall server "DAEMON".\n"
|
2002-06-04 11:06:26 +00:00
|
|
|
" -h, --help display this help and exit.\n"
|
|
|
|
" --version display version information and exit.\n"
|
|
|
|
"\n"
|
2002-06-08 21:48:00 +00:00
|
|
|
"* marks defaults.\n"
|
2002-06-04 11:06:26 +00:00
|
|
|
"\n"
|
|
|
|
"Where log messages go depends on the platform and whether or not the\n"
|
2002-06-08 21:48:00 +00:00
|
|
|
"client is running as a "DAEMON".",
|
2002-06-04 11:06:26 +00:00
|
|
|
pname));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool isArg(int argi,
|
2002-06-08 21:48:00 +00:00
|
|
|
int argc, const char** argv,
|
2002-06-04 11:06:26 +00:00
|
|
|
const char* name1,
|
|
|
|
const char* name2,
|
|
|
|
int minRequiredParameters = 0)
|
|
|
|
{
|
|
|
|
if ((name1 != NULL && strcmp(argv[argi], name1) == 0) ||
|
|
|
|
(name2 != NULL && strcmp(argv[argi], name2) == 0)) {
|
|
|
|
// match. check args left.
|
|
|
|
if (argi + minRequiredParameters >= argc) {
|
2002-06-08 21:48:00 +00:00
|
|
|
log((CLOG_PRINT "%s: missing arguments for `%s'" BYE,
|
|
|
|
pname, argv[argi], pname));
|
|
|
|
bye(2);
|
2002-06-04 11:06:26 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// no match
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
static void parse(int argc, const char** argv)
|
2002-06-04 11:06:26 +00:00
|
|
|
{
|
|
|
|
assert(pname != NULL);
|
|
|
|
assert(argv != NULL);
|
|
|
|
assert(argc >= 1);
|
|
|
|
|
|
|
|
// parse options
|
|
|
|
int i;
|
|
|
|
for (i = 1; i < argc; ++i) {
|
|
|
|
if (isArg(i, argc, argv, "-d", "--debug", 1)) {
|
|
|
|
// change logging level
|
|
|
|
s_logFilter = argv[++i];
|
|
|
|
}
|
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
else if (isArg(i, argc, argv, "-f", "--no-"DAEMON)) {
|
2002-06-04 11:06:26 +00:00
|
|
|
// not a daemon
|
|
|
|
s_daemon = false;
|
|
|
|
}
|
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
else if (isArg(i, argc, argv, NULL, "--"DAEMON)) {
|
2002-06-04 11:06:26 +00:00
|
|
|
// daemonize
|
|
|
|
s_daemon = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (isArg(i, argc, argv, "-1", "--no-restart")) {
|
|
|
|
// don't try to restart
|
|
|
|
s_restartable = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (isArg(i, argc, argv, NULL, "--restart")) {
|
|
|
|
// try to restart
|
|
|
|
s_restartable = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (isArg(i, argc, argv, "-h", "--help")) {
|
|
|
|
help();
|
2002-06-08 21:48:00 +00:00
|
|
|
bye(0);
|
2002-06-04 11:06:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
else if (isArg(i, argc, argv, NULL, "--version")) {
|
|
|
|
version();
|
2002-06-08 21:48:00 +00:00
|
|
|
bye(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (isArg(i, argc, argv, NULL, "--install")) {
|
|
|
|
#if !defined(CONFIG_PLATFORM_WIN32)
|
|
|
|
log((CLOG_PRINT "%s: `%s' not permitted on this platform" BYE,
|
|
|
|
pname, argv[i], pname));
|
|
|
|
bye(2);
|
|
|
|
#endif
|
|
|
|
s_install = true;
|
|
|
|
if (s_uninstall) {
|
|
|
|
log((CLOG_PRINT "%s: `--install' and `--uninstall'"
|
|
|
|
" are mutually exclusive" BYE,
|
|
|
|
pname, argv[i], pname));
|
|
|
|
bye(2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (isArg(i, argc, argv, NULL, "--uninstall")) {
|
|
|
|
#if !defined(CONFIG_PLATFORM_WIN32)
|
|
|
|
log((CLOG_PRINT "%s: `%s' not permitted on this platform" BYE,
|
|
|
|
pname, argv[i], pname));
|
|
|
|
bye(2);
|
|
|
|
#endif
|
|
|
|
s_uninstall = true;
|
|
|
|
if (s_install) {
|
|
|
|
log((CLOG_PRINT "%s: `--install' and `--uninstall'"
|
|
|
|
" are mutually exclusive" BYE,
|
|
|
|
pname, argv[i], pname));
|
|
|
|
bye(2);
|
|
|
|
}
|
2002-06-04 11:06:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
else if (isArg(i, argc, argv, "--", NULL)) {
|
|
|
|
// remaining arguments are not options
|
|
|
|
++i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (argv[i][0] == '-') {
|
2002-06-08 21:48:00 +00:00
|
|
|
log((CLOG_PRINT "%s: unrecognized option `%s'" BYE,
|
|
|
|
pname, argv[i], pname));
|
|
|
|
bye(2);
|
2002-06-04 11:06:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
else {
|
|
|
|
// this and remaining arguments are not options
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
// exactly one non-option argument (server-address) unless using
|
|
|
|
// --uninstall.
|
|
|
|
if (s_uninstall) {
|
|
|
|
if (i != argc) {
|
|
|
|
log((CLOG_PRINT "%s: unrecognized option `%s' to `%s'" BYE,
|
|
|
|
pname, argv[i], pname,
|
|
|
|
s_install ? "--install" : "--uninstall"));
|
|
|
|
bye(2);
|
|
|
|
}
|
2002-06-04 11:06:26 +00:00
|
|
|
}
|
2002-06-08 21:48:00 +00:00
|
|
|
else {
|
|
|
|
if (i == argc) {
|
|
|
|
log((CLOG_PRINT "%s: a server address or name is required" BYE,
|
|
|
|
pname, pname));
|
|
|
|
bye(1);
|
|
|
|
}
|
|
|
|
if (i + 1 != argc) {
|
|
|
|
log((CLOG_PRINT "%s: unrecognized option `%s'" BYE,
|
|
|
|
pname, argv[i], pname));
|
|
|
|
bye(2);
|
|
|
|
}
|
|
|
|
s_serverName = argv[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
// increase default filter level for daemon. the user must
|
|
|
|
// explicitly request another level for a daemon.
|
|
|
|
if (s_daemon && s_logFilter == NULL) {
|
|
|
|
#if defined(CONFIG_PLATFORM_WIN32)
|
|
|
|
if (CPlatform::isWindows95Family()) {
|
|
|
|
// windows 95 has no place for logging so avoid showing
|
|
|
|
// the log console window.
|
|
|
|
s_logFilter = "FATAL";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
s_logFilter = "NOTE";
|
|
|
|
}
|
2002-06-04 11:06:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// set log filter
|
|
|
|
if (!CLog::setFilter(s_logFilter)) {
|
2002-06-08 21:48:00 +00:00
|
|
|
log((CLOG_PRINT "%s: unrecognized log level `%s'" BYE,
|
|
|
|
pname, s_logFilter, pname));
|
|
|
|
bye(2);
|
2002-06-04 11:06:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-05-31 14:25:26 +00:00
|
|
|
//
|
|
|
|
// platform dependent entry points
|
|
|
|
//
|
|
|
|
|
2001-11-19 00:33:36 +00:00
|
|
|
#if defined(CONFIG_PLATFORM_WIN32)
|
|
|
|
|
|
|
|
#include "CMSWindowsScreen.h"
|
2002-06-08 21:48:00 +00:00
|
|
|
|
|
|
|
static bool logMessageBox(int priority, const char* msg)
|
|
|
|
{
|
|
|
|
if (priority <= CLog::kFATAL) {
|
|
|
|
MessageBox(NULL, msg, pname, MB_OK | MB_ICONWARNING);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void byeThrow(int x)
|
|
|
|
{
|
|
|
|
throw CWin32Platform::CDaemonFailed(x);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void daemonStop(void)
|
|
|
|
{
|
|
|
|
s_client->quit();
|
|
|
|
}
|
|
|
|
|
|
|
|
static int daemonStartup(IPlatform* iplatform,
|
|
|
|
int argc, const char** argv)
|
|
|
|
{
|
|
|
|
// get platform pointer
|
|
|
|
CWin32Platform* platform = static_cast<CWin32Platform*>(iplatform);
|
|
|
|
|
|
|
|
// catch errors that would normally exit
|
|
|
|
bye = &byeThrow;
|
|
|
|
|
|
|
|
// parse command line
|
|
|
|
s_install = false;
|
|
|
|
s_uninstall = false;
|
|
|
|
parse(argc, argv);
|
|
|
|
if (s_install || s_uninstall) {
|
|
|
|
// not allowed to install/uninstall from service
|
|
|
|
throw CWin32Platform::CDaemonFailed(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// run as a service
|
|
|
|
return platform->runDaemon(realMain, daemonStop);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int daemonStartup95(IPlatform*, int, const char**)
|
|
|
|
{
|
|
|
|
return realMain(NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool logDiscard(int, const char*)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool s_die = false;
|
|
|
|
|
|
|
|
static void checkParse(int e)
|
|
|
|
{
|
|
|
|
// anything over 1 means invalid args. 1 means missing args.
|
|
|
|
// 0 means graceful exit. we plan to exit for anything but
|
|
|
|
// 1 (missing args); the service control manager may supply
|
|
|
|
// the missing arguments so we don't exit in that case.
|
|
|
|
s_die = (e != 1);
|
|
|
|
throw s_die;
|
|
|
|
}
|
2001-11-19 00:33:36 +00:00
|
|
|
|
|
|
|
int WINAPI WinMain(HINSTANCE instance, HINSTANCE, LPSTR, int)
|
|
|
|
{
|
2002-06-04 12:26:23 +00:00
|
|
|
CPlatform platform;
|
|
|
|
|
|
|
|
// save instance
|
2001-11-19 00:33:36 +00:00
|
|
|
CMSWindowsScreen::init(instance);
|
|
|
|
|
2002-06-04 11:06:26 +00:00
|
|
|
// get program name
|
2002-06-08 21:48:00 +00:00
|
|
|
pname = platform.getBasename(__argv[0]);
|
|
|
|
|
|
|
|
// parse command line without reporting errors but recording if
|
|
|
|
// the app would've exited. this is too avoid showing a dialog
|
|
|
|
// box if we're being started as a service because we shouldn't
|
|
|
|
// take too long to startup in that case. this mostly works but
|
|
|
|
// will choke if the service control manager passes --install
|
|
|
|
// or --uninstall (but that's unlikely).
|
|
|
|
CLog::setOutputter(&logDiscard);
|
|
|
|
bye = &checkParse;
|
|
|
|
try {
|
|
|
|
parse(__argc, const_cast<const char**>(__argv));
|
|
|
|
}
|
|
|
|
catch (...) {
|
|
|
|
// ignore
|
|
|
|
}
|
2001-10-14 18:29:43 +00:00
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
// if we're not starting as an NT service then reparse the command
|
|
|
|
// line normally.
|
|
|
|
if (s_die || !s_daemon || s_install || s_uninstall ||
|
|
|
|
CWin32Platform::isWindows95Family()) {
|
|
|
|
// send PRINT and FATAL output to a message box
|
|
|
|
CLog::setOutputter(&logMessageBox);
|
2002-06-04 11:06:26 +00:00
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
// exit on bye
|
|
|
|
bye = &exit;
|
2002-06-04 11:06:26 +00:00
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
// reparse
|
|
|
|
parse(__argc, const_cast<const char**>(__argv));
|
|
|
|
}
|
2002-06-04 11:06:26 +00:00
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
// if starting as a daemon then we ignore the startup command line
|
|
|
|
// here. we'll parse the command line passed in when the service
|
|
|
|
// control manager calls us back.
|
|
|
|
else {
|
|
|
|
// do nothing
|
|
|
|
}
|
|
|
|
|
|
|
|
// install/uninstall
|
|
|
|
if (s_install) {
|
|
|
|
// get the full path to this program
|
|
|
|
TCHAR path[MAX_PATH];
|
|
|
|
if (GetModuleFileName(NULL, path,
|
|
|
|
sizeof(path) / sizeof(path[0])) == 0) {
|
|
|
|
log((CLOG_CRIT "cannot determine absolute path to program"));
|
|
|
|
return 16;
|
|
|
|
}
|
|
|
|
|
|
|
|
// construct the command line to start the service with
|
|
|
|
CString commandLine = "--"DAEMON;
|
|
|
|
if (s_restartable) {
|
|
|
|
commandLine += " --restart";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
commandLine += " --no-restart";
|
|
|
|
}
|
|
|
|
if (s_logFilter != NULL) {
|
|
|
|
commandLine += " --debug ";
|
|
|
|
commandLine += s_logFilter;
|
|
|
|
}
|
|
|
|
commandLine += " ";
|
|
|
|
commandLine += s_serverName;
|
|
|
|
|
|
|
|
// install
|
|
|
|
if (!platform.installDaemon(DAEMON_NAME,
|
|
|
|
"Shares this system's mouse and keyboard with others.",
|
|
|
|
path, commandLine.c_str())) {
|
|
|
|
log((CLOG_CRIT "failed to install service"));
|
|
|
|
return 16;
|
|
|
|
}
|
|
|
|
log((CLOG_PRINT "installed successfully"));
|
2001-11-19 00:33:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2002-06-08 21:48:00 +00:00
|
|
|
else if (s_uninstall) {
|
|
|
|
if (!platform.uninstallDaemon(DAEMON_NAME)) {
|
|
|
|
log((CLOG_CRIT "failed to uninstall service"));
|
|
|
|
return 16;
|
|
|
|
}
|
|
|
|
log((CLOG_PRINT "uninstalled successfully"));
|
|
|
|
return 0;
|
2001-11-19 00:33:36 +00:00
|
|
|
}
|
2002-06-08 21:48:00 +00:00
|
|
|
|
|
|
|
// daemonize if requested
|
|
|
|
int result;
|
|
|
|
if (s_daemon) {
|
|
|
|
if (CWin32Platform::isWindows95Family()) {
|
|
|
|
result = platform.daemonize(DAEMON_NAME, &daemonStartup95);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = platform.daemonize(DAEMON_NAME, &daemonStartup);
|
|
|
|
}
|
|
|
|
if (result == -1) {
|
|
|
|
log((CLOG_CRIT "failed to start as a service"));
|
|
|
|
return 16;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result = restartableMain();
|
2002-06-02 18:49:35 +00:00
|
|
|
}
|
2002-06-08 21:48:00 +00:00
|
|
|
|
|
|
|
return result;
|
2001-11-19 00:33:36 +00:00
|
|
|
}
|
|
|
|
|
2002-06-04 11:06:26 +00:00
|
|
|
#elif defined(CONFIG_PLATFORM_UNIX)
|
2001-11-19 00:33:36 +00:00
|
|
|
|
2002-06-08 21:48:00 +00:00
|
|
|
static int daemonStartup(IPlatform*, int, const char**)
|
|
|
|
{
|
|
|
|
return restartableMain();
|
|
|
|
}
|
2001-11-19 00:33:36 +00:00
|
|
|
|
2002-06-04 11:06:26 +00:00
|
|
|
int main(int argc, char** argv)
|
|
|
|
{
|
2002-06-04 12:26:23 +00:00
|
|
|
CPlatform platform;
|
|
|
|
|
2002-06-04 11:06:26 +00:00
|
|
|
// get program name
|
2002-06-04 12:26:23 +00:00
|
|
|
pname = platform.getBasename(argv[0]);
|
2002-06-04 11:06:26 +00:00
|
|
|
|
|
|
|
// parse command line
|
2002-06-08 21:48:00 +00:00
|
|
|
parse(argc, const_cast<const char**>(argv));
|
2002-06-04 11:06:26 +00:00
|
|
|
|
|
|
|
// daemonize if requested
|
2002-06-08 21:48:00 +00:00
|
|
|
int result;
|
2002-06-04 11:06:26 +00:00
|
|
|
if (s_daemon) {
|
2002-06-08 21:48:00 +00:00
|
|
|
result = platform.daemonize(DAEMON_NAME, &daemonStartup);
|
|
|
|
if (result == -1) {
|
2002-06-04 12:26:23 +00:00
|
|
|
log((CLOG_CRIT "failed to daemonize"));
|
|
|
|
return 16;
|
|
|
|
}
|
2002-06-04 11:06:26 +00:00
|
|
|
}
|
2002-06-08 21:48:00 +00:00
|
|
|
else {
|
|
|
|
result = restartableMain();
|
2002-06-02 18:49:35 +00:00
|
|
|
}
|
2002-06-08 21:48:00 +00:00
|
|
|
|
|
|
|
return result;
|
2001-10-08 19:24:46 +00:00
|
|
|
}
|
2001-11-19 00:33:36 +00:00
|
|
|
|
2002-06-04 11:06:26 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
#error no main() for platform
|
|
|
|
|
2001-11-19 00:33:36 +00:00
|
|
|
#endif
|