// 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

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;

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;

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;

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;

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));

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));

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));

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));

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);

static std::mutex access_;

static bool blocked_;

friend struct BlockGuard;

public:

static std::future<bool> listen(int port);

static void block();