{

flush_proxy();

int cnt = data->fragments_size();

if (cnt > 0) {

target->begin_batch();

for (int i = 0; i < cnt; i++)

{

auto &frag = data->fragments(i);

color_value color = frag.has_color() ? color_value(frag.color()) : COLOR_RESET;

target->add_text(color, frag.text());

}

target->end_batch();

}

: p_default_output(default_output)

{

active = false;

socket = new CActiveSocket();

suspend_ready = false;

if (!p_default_output)

{

delete_output = true;

p_default_output = new color_ostream_wrapper(std::cout);

}

else

delete_output = false;

{

if (!socket->IsSocketValid())

return false;

char *ptr = (char*)buf;

while (size > 0) {

int cnt = socket->Receive(size);

if (cnt <= 0)

return false;

memcpy(ptr, socket->GetData(), cnt);

ptr += cnt;

size -= cnt;

}

return true;

{

int port = DEFAULT_PORT;

const char *port_env = getenv("DFHACK_PORT");

if (port_env)

{

int port_val = atoi(port_env);

if (port_val > 0)

port = port_val;

}

else

{

for (const char *filename : {"dfhack-config/remote-server.json", "../dfhack-config/remote-server.json"})

{

std::ifstream in_file(filename, std::ios_base::in);

if (in_file)

{

Json::Value config;

try {

in_file >> config;

} catch (const std::exception & e) {

std::cerr << "Error reading remote server config file: " << filename << ": " << e.what() << std::endl;

}

in_file.close();

if (config.isMember("port")) {

port = config["port"].asInt();

break;

}

}

}

}

return port;

{

assert(!active);

if (port <= 0)

port = GetDefaultPort();

if (!socket->Initialize())

{

default_output().printerr("Socket init failed.\n");

return false;

}

if (!socket->Open("localhost", port))

{

default_output().printerr("Could not connect to localhost:{}\n", port);

return false;

}

active = true;

RPCHandshakeHeader header;

memcpy(header.magic, RPCHandshakeHeader::REQUEST_MAGIC, sizeof(header.magic));

header.version = 1;

if (socket->Send((uint8*)&header, sizeof(header)) != sizeof(header))

{

default_output().printerr("Could not send handshake header.\n");

socket->Close();

return active = false;

}

if (!readFullBuffer(socket, &header, sizeof(header)))

{

default_output().printerr("Could not read handshake header.\n");

socket->Close();

return active = false;

}

if (memcmp(header.magic, RPCHandshakeHeader::RESPONSE_MAGIC, sizeof(header.magic)) ||

header.version != 1)

{

default_output().printerr("Invalid handshake response.\n");

socket->Close();

return active = false;

}

bind_call.name = "BindMethod";

bind_call.p_client = this;

bind_call.id = 0;

runcmd_call.name = "RunCommand";

runcmd_call.p_client = this;

runcmd_call.id = 1;

return true;

{

if (active && socket->IsSocketValid())

{

RPCMessageHeader header;

header.id = RPC_REQUEST_QUIT;

header.size = 0;

if (socket->Send((uint8_t*)&header, sizeof(header)) != sizeof(header))

default_output().printerr("Could not send the disconnect message.\n");

}

socket->Close();

const std::string &name, const std::string &plugin)

{

if (!active || !socket->IsSocketValid())

return false;

bind_call.reset();

{

auto in = bind_call.in();

in->set_method(name);

if (!plugin.empty())

in->set_plugin(plugin);

in->set_input_msg(function->p_in_template->GetTypeName());

in->set_output_msg(function->p_out_template->GetTypeName());

}

if (bind_call(out) != CR_OK)

return false;

function->id = bind_call.out()->assigned_id();

return true;

const std::vector<std::string> &args)

{

if (!active || !socket->IsSocketValid())

{

out.printerr("In RunCommand: client connection not valid.\n");

return CR_FAILURE;

}

runcmd_call.reset();

runcmd_call.in()->set_command(cmd);

for (size_t i = 0; i < args.size(); i++)

runcmd_call.in()->add_arguments(args[i]);

return runcmd_call(out);

{

if (!active)

return -1;

if (!suspend_ready) {

suspend_ready = true;

suspend_call.bind(this, "CoreSuspend");

resume_call.bind(this, "CoreResume");

}

if (suspend_call(default_output()) == CR_OK)

return suspend_call.out()->value();

else

return -1;

{

if (!suspend_ready)

return -1;

if (resume_call(default_output()) == CR_OK)

return resume_call.out()->value();

else

return -1;

{

if (free)

{

delete p_in;

delete p_out;

p_in = p_out = NULL;

}

else

{

if (p_in)

p_in->Clear();

if (p_out)

p_out->Clear();

}

const std::string &name, const std::string &plugin)

{

if (isValid())

{

if (p_client == client && this->name == name && this->plugin == plugin)

return true;

out.printerr("Function already bound to {}::{}\n",

this->plugin, this->name);

return false;

}

this->name = name;

this->plugin = plugin;

this->p_client = client;

return client->bind(out, this, name, plugin);

{

int size = size_ready ? msg->GetCachedSize() : msg->ByteSize();

int fullsz = size + sizeof(RPCMessageHeader);

uint8_t *data = new uint8_t[fullsz];

RPCMessageHeader *hdr = (RPCMessageHeader*)data;

hdr->id = id;

hdr->size = size;

uint8_t *pstart = data + sizeof(RPCMessageHeader);

uint8_t *pend = msg->SerializeWithCachedSizesToArray(pstart);

assert((pend - pstart) == size); (void)pend;

int got = socket->Send(data, fullsz);

delete[] data;

return (got == fullsz);

const message_type *input, message_type *output)

{

if (!isValid())

{

out.printerr("Calling an unbound RPC function {}:{}.\n",

this->plugin, this->name);

return CR_NOT_IMPLEMENTED;

}

if (!p_client->socket->IsSocketValid())

{

out.printerr("In call to {}:{}: invalid socket.\n",

this->plugin, this->name);

return CR_LINK_FAILURE;

}

int send_size = input->ByteSize();

if (send_size > RPCMessageHeader::MAX_MESSAGE_SIZE)

{

out.printerr("In call to {}:{}: message too large: {}.\n",

this->plugin, this->name, send_size);

return CR_LINK_FAILURE;

}

if (!sendRemoteMessage(p_client->socket, id, input, true))

{

out.printerr("In call to {}:{}: I/O error in send.\n",

this->plugin, this->name);

return CR_LINK_FAILURE;

}

color_ostream_proxy text_decoder(out);

CoreTextNotification text_data;

output->Clear();

for (;;) {

RPCMessageHeader header;

if (!readFullBuffer(p_client->socket, &header, sizeof(header)))

{

out.printerr("In call to {}:{}: I/O error in receive header.\n",

this->plugin, this->name);

return CR_LINK_FAILURE;

}

//out.print("Received %d:%d\n", header.id, header.size);

if ((DFHack::DFHackReplyCode)header.id == RPC_REPLY_FAIL)

return header.size == CR_OK ? CR_FAILURE : command_result(header.size);

if (header.size < 0 || header.size > RPCMessageHeader::MAX_MESSAGE_SIZE)

{

out.printerr("In call to {}:{}: invalid received size {}.\n",

this->plugin, this->name, header.size);

return CR_LINK_FAILURE;

}

uint8_t *buf = new uint8_t[header.size];

if (!readFullBuffer(p_client->socket, buf, header.size))

{

out.printerr("In call to {}:{}: I/O error in receive {} bytes of data.\n",

this->plugin, this->name, header.size);

return CR_LINK_FAILURE;

}

switch (header.id) {

case RPC_REPLY_RESULT:

if (!output->ParseFromArray(buf, header.size))

{

out.printerr("In call to {}:{}: error parsing received result.\n",

this->plugin, this->name);

delete[] buf;

return CR_LINK_FAILURE;

}

delete[] buf;

return CR_OK;

case RPC_REPLY_TEXT:

text_data.Clear();

if (text_data.ParseFromArray(buf, header.size))

text_decoder.decode(&text_data);

else

out.printerr("In call to {}:{}: received invalid text data.\n",

this->plugin, this->name);

break;

default:

break;

}

delete[] buf;

}