260 lines
8.1 KiB
C++
260 lines
8.1 KiB
C++
/*
|
|
https://github.com/peterix/dfhack
|
|
Copyright (c) 2009-2012 Petr Mrázek (peterix@gmail.com)
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any
|
|
damages arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any
|
|
purpose, including commercial applications, and to alter it and
|
|
redistribute it freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must
|
|
not claim that you wrote the original software. If you use this
|
|
software in a product, an acknowledgment in the product documentation
|
|
would be appreciated but is not required.
|
|
|
|
2. Altered source versions must be plainly marked as such, and
|
|
must not be misrepresented as being the original software.
|
|
|
|
3. This notice may not be removed or altered from any source
|
|
distribution.
|
|
*/
|
|
|
|
#pragma once
|
|
#include "Pragma.h"
|
|
#include "Export.h"
|
|
#include "RemoteClient.h"
|
|
#include "Core.h"
|
|
|
|
#include <future>
|
|
|
|
class CPassiveSocket;
|
|
class CActiveSocket;
|
|
class CSimpleSocket;
|
|
|
|
namespace DFHack
|
|
{
|
|
class Plugin;
|
|
class CoreService;
|
|
class ServerConnection;
|
|
|
|
class DFHACK_EXPORT RPCService;
|
|
|
|
enum ServerFunctionFlags {
|
|
// The function is expected to be called only once per client,
|
|
// so always delete all cached buffers after processing.
|
|
SF_CALLED_ONCE = 1,
|
|
// Don't automatically suspend the core around the call.
|
|
// The function is supposed to manage locking itself.
|
|
SF_DONT_SUSPEND = 2,
|
|
// The function is considered safe to call from a remote computer.
|
|
// All other functions cannot be allowed for security reasons.
|
|
SF_ALLOW_REMOTE = 4
|
|
};
|
|
|
|
class DFHACK_EXPORT ServerFunctionBase : public RPCFunctionBase {
|
|
public:
|
|
const char *const name;
|
|
const int flags;
|
|
|
|
virtual command_result execute(color_ostream &stream) = 0;
|
|
|
|
int16_t getId() { return id; }
|
|
|
|
protected:
|
|
friend class RPCService;
|
|
|
|
ServerFunctionBase(const message_type *in, const message_type *out,
|
|
RPCService *owner, const char *name, int flags)
|
|
: RPCFunctionBase(in, out), name(name), flags(flags), owner(owner), id(-1)
|
|
{}
|
|
virtual ~ServerFunctionBase() {}
|
|
|
|
RPCService *owner;
|
|
int16_t id;
|
|
};
|
|
|
|
template<typename In, typename Out>
|
|
class ServerFunction : public ServerFunctionBase {
|
|
public:
|
|
typedef command_result (*function_type)(color_ostream &out, const In *input, Out *output);
|
|
|
|
In *in() { return static_cast<In*>(RPCFunctionBase::in()); }
|
|
Out *out() { return static_cast<Out*>(RPCFunctionBase::out()); }
|
|
|
|
ServerFunction(RPCService *owner, const char *name, int flags, function_type fptr)
|
|
: ServerFunctionBase(&In::default_instance(), &Out::default_instance(), owner, name, flags),
|
|
fptr(fptr) {}
|
|
|
|
virtual command_result execute(color_ostream &stream) { return fptr(stream, in(), out()); }
|
|
|
|
private:
|
|
function_type fptr;
|
|
};
|
|
|
|
template<typename In>
|
|
class VoidServerFunction : public ServerFunctionBase {
|
|
public:
|
|
typedef command_result (*function_type)(color_ostream &out, const In *input);
|
|
|
|
In *in() { return static_cast<In*>(RPCFunctionBase::in()); }
|
|
|
|
VoidServerFunction(RPCService *owner, const char *name, int flags, function_type fptr)
|
|
: ServerFunctionBase(&In::default_instance(), &EmptyMessage::default_instance(), owner, name, flags),
|
|
fptr(fptr) {}
|
|
|
|
virtual command_result execute(color_ostream &stream) { return fptr(stream, in()); }
|
|
|
|
private:
|
|
function_type fptr;
|
|
};
|
|
|
|
template<typename Svc, typename In, typename Out>
|
|
class ServerMethod : public ServerFunctionBase {
|
|
public:
|
|
typedef command_result (Svc::*function_type)(color_ostream &out, const In *input, Out *output);
|
|
|
|
In *in() { return static_cast<In*>(RPCFunctionBase::in()); }
|
|
Out *out() { return static_cast<Out*>(RPCFunctionBase::out()); }
|
|
|
|
ServerMethod(RPCService *owner, const char *name, int flags, function_type fptr)
|
|
: ServerFunctionBase(&In::default_instance(), &Out::default_instance(), owner, name, flags),
|
|
fptr(fptr) {}
|
|
|
|
virtual command_result execute(color_ostream &stream) {
|
|
return (static_cast<Svc*>(owner)->*fptr)(stream, in(), out());
|
|
}
|
|
|
|
private:
|
|
function_type fptr;
|
|
};
|
|
|
|
template<typename Svc, typename In>
|
|
class VoidServerMethod : public ServerFunctionBase {
|
|
public:
|
|
typedef command_result (Svc::*function_type)(color_ostream &out, const In *input);
|
|
|
|
In *in() { return static_cast<In*>(RPCFunctionBase::in()); }
|
|
|
|
VoidServerMethod(RPCService *owner, const char *name, int flags, function_type fptr)
|
|
: ServerFunctionBase(&In::default_instance(), &EmptyMessage::default_instance(), owner, name, flags),
|
|
fptr(fptr) {}
|
|
|
|
virtual command_result execute(color_ostream &stream) {
|
|
return (static_cast<Svc*>(owner)->*fptr)(stream, in());
|
|
}
|
|
|
|
private:
|
|
function_type fptr;
|
|
};
|
|
|
|
class DFHACK_EXPORT RPCService {
|
|
friend class ServerConnection;
|
|
friend class Plugin;
|
|
friend class Core;
|
|
|
|
std::vector<ServerFunctionBase*> functions;
|
|
std::map<std::string, ServerFunctionBase*> lookup;
|
|
ServerConnection *owner;
|
|
|
|
Plugin *holder;
|
|
|
|
void finalize(ServerConnection *owner, std::vector<ServerFunctionBase*> *ftable);
|
|
|
|
public:
|
|
RPCService();
|
|
virtual ~RPCService();
|
|
|
|
ServerFunctionBase *getFunction(const std::string &name);
|
|
|
|
template<typename In, typename Out>
|
|
void addFunction(
|
|
const char *name,
|
|
command_result (*fptr)(color_ostream &out, const In *input, Out *output),
|
|
int flags = 0
|
|
) {
|
|
assert(!owner);
|
|
functions.push_back(new ServerFunction<In,Out>(this, name, flags, fptr));
|
|
}
|
|
|
|
template<typename In>
|
|
void addFunction(
|
|
const char *name,
|
|
command_result (*fptr)(color_ostream &out, const In *input),
|
|
int flags = 0
|
|
) {
|
|
assert(!owner);
|
|
functions.push_back(new VoidServerFunction<In>(this, name, flags, fptr));
|
|
}
|
|
|
|
protected:
|
|
ServerConnection *connection() { return owner; }
|
|
|
|
template<typename Svc, typename In, typename Out>
|
|
void addMethod(
|
|
const char *name,
|
|
command_result (Svc::*fptr)(color_ostream &out, const In *input, Out *output),
|
|
int flags = 0
|
|
) {
|
|
assert(!owner);
|
|
functions.push_back(new ServerMethod<Svc,In,Out>(this, name, flags, fptr));
|
|
}
|
|
|
|
template<typename Svc, typename In>
|
|
void addMethod(
|
|
const char *name,
|
|
command_result (Svc::*fptr)(color_ostream &out, const In *input),
|
|
int flags = 0
|
|
) {
|
|
assert(!owner);
|
|
functions.push_back(new VoidServerMethod<Svc,In>(this, name, flags, fptr));
|
|
}
|
|
|
|
void dumpMethods(std::ostream & out) const;
|
|
};
|
|
|
|
class ServerConnection {
|
|
class connection_ostream : public buffered_color_ostream {
|
|
ServerConnection *owner;
|
|
|
|
protected:
|
|
virtual void flush_proxy();
|
|
|
|
public:
|
|
connection_ostream(ServerConnection *owner) : owner(owner) {}
|
|
};
|
|
|
|
bool in_error;
|
|
CActiveSocket *socket;
|
|
connection_ostream stream;
|
|
|
|
std::vector<ServerFunctionBase*> functions;
|
|
|
|
CoreService *core_service;
|
|
std::map<std::string, RPCService*> plugin_services;
|
|
|
|
void threadFn();
|
|
ServerConnection(CActiveSocket* socket);
|
|
~ServerConnection();
|
|
|
|
public:
|
|
|
|
static void Accepted(CActiveSocket* socket);
|
|
|
|
ServerFunctionBase *findFunction(color_ostream &out, const std::string &plugin, const std::string &name);
|
|
};
|
|
|
|
class ServerMain {
|
|
static std::mutex access_;
|
|
static bool blocked_;
|
|
friend struct BlockGuard;
|
|
|
|
public:
|
|
|
|
static std::future<bool> listen(int port);
|
|
static void block();
|
|
};
|
|
}
|