void CmdEval::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
thrift.write(m_output);
thrift.write(m_frame);
thrift.write(m_bypassAccessCheck);
if (this->m_version == 2) thrift.write(m_failed);
}
void CmdMachine::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
thrift.read(m_sandboxes);
thrift.read(m_rpcConfig);
thrift.read(m_force);
thrift.read(m_succeed);
}
void DebuggerCommand::sendImpl(DebuggerThriftBuffer &thrift) {
TRACE(2, "DebuggerCommand::sendImpl\n");
thrift.write((int32_t)m_type);
thrift.write(m_class);
thrift.write(m_body);
thrift.write(m_version);
}
void CmdInstrument::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
thrift.write(m_type);
thrift.write(m_enabled);
ASSERT(m_instPoints);
InstPointInfo::SendImpl(*m_instPoints, thrift);
}
// Always called from recv and implements specific
// logic for deserializing a list command received via Thrift.
void CmdList::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
thrift.read(m_file);
thrift.read(m_line1);
thrift.read(m_line2);
thrift.read(m_code);
}
// Always called from send and implements specific
// logic for serializing a list command to send via Thrift.
void CmdList::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
thrift.write(m_file);
thrift.write(m_line1);
thrift.write(m_line2);
thrift.write(m_code);
}
void CmdMachine::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
thrift.write(m_sandboxes);
thrift.write(m_rpcConfig);
thrift.write(m_force);
thrift.write(m_succeed);
}
void CmdPrint::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
thrift.read(m_ret);
thrift.read(m_output);
thrift.read(m_frame);
thrift.read(m_bypassAccessCheck);
thrift.read(m_printLevel);
}
void CmdInternalTesting::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
thrift.write(m_arg);
// Write less data on purpose, to get the server to choke on deserialization
if ((m_arg != "shortcmd")) {
thrift.write(m_unused);
}
}
void CmdWhere::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
{
String sdata;
DebuggerWireHelpers::WireSerialize(m_stacktrace, sdata);
thrift.write(sdata);
}
thrift.write(m_stackArgs);
}
void InstPointInfo::recvImpl(DebuggerThriftBuffer &thrift) {
TRACE(2, "InstPointInfo::recvImpl\n");
thrift.read(m_locType);
thrift.read(m_valid);
thrift.read(m_file);
thrift.read(m_line);
thrift.read(m_func);
thrift.read(m_desc);
thrift.read(m_code);
}
void CmdVariable::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
thrift.write(m_frame);
{
String sdata;
DebuggerWireHelpers::WireSerialize(m_variables, sdata);
thrift.write(sdata);
}
thrift.write(m_global);
}
// Resets the buffer, serializes this command into the buffer and then
// flushes the buffer.
// Returns false if an exception occurs during these steps.
bool DebuggerCommand::send(DebuggerThriftBuffer &thrift) {
TRACE(5, "DebuggerCommand::send cmd of type %d\n", m_type);
try {
thrift.reset(false);
sendImpl(thrift);
thrift.flush();
} catch (...) {
Logger::Error("DebuggerCommand::send(): a socket error has happened");
return false;
}
return true;
}
bool DebuggerCommand::send(DebuggerThriftBuffer &thrift) {
try {
thrift.reset(false);
sendImpl(thrift);
thrift.flush();
} catch (...) {
Logger::Verbose("DebuggerCommand::send(): a socket error has happened");
thrift.close();
return false;
}
return true;
}
void CmdWhere::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
{
String sdata;
thrift.read(sdata);
if (DebuggerWireHelpers::WireUnserialize(sdata, m_stacktrace) !=
DebuggerWireHelpers::NoError) {
m_stacktrace = null_array;
m_wireError = sdata;
}
}
thrift.read(m_stackArgs);
}
void CmdVariable::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
thrift.read(m_frame);
{
String sdata;
thrift.read(sdata);
if (DebuggerWireHelpers::WireUnserialize(sdata, m_variables) !=
DebuggerWireHelpers::NoError) {
m_variables = null_array;
m_wireError = sdata;
}
}
thrift.read(m_global);
}
void CmdPrint::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
if (m_printLevel > 0) {
g_context->setDebuggerPrintLevel(m_printLevel);
}
thrift.write(m_ret);
if (m_printLevel > 0) {
g_context->setDebuggerPrintLevel(-1);
}
thrift.write(m_output);
thrift.write(m_frame);
thrift.write(m_bypassAccessCheck);
thrift.write(m_printLevel);
}
void CmdEval::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
thrift.read(m_output);
thrift.read(m_frame);
thrift.read(m_bypassAccessCheck);
if (this->m_version == 2) thrift.read(m_failed);
// Old senders will set version to 0. A new sender sets it to 1
// and then expects an answer using version 2.
// Note that version 1 is the same format as version 0, so old
// receivers will not break when receiving a version 1 message.
// This code ensures that version 2 messages are received only
// by receivers that previously sent a version 1 message (thus
// indicating their ability to deal with version 2 messages).
if (this->m_version == 1) this->m_version = 2;
}
void InstPointInfo::SendImpl(const InstPointInfoPtrVec& ips,
DebuggerThriftBuffer &thrift) {
TRACE(2, "InstPointInfo::SendImpl\n");
int16_t size = ips.size();
thrift.write(size);
for (int i = 0; i < size; i++) {
ips[i]->sendImpl(thrift);
}
}
bool DebuggerCommand::recv(DebuggerThriftBuffer &thrift) {
try {
recvImpl(thrift);
} catch (...) {
Logger::Verbose("DebuggerCommand::recv(): a socket error has happened");
thrift.close();
return false;
}
return true;
}
void CmdVariable::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
thrift.read(m_frame);
{
String sdata;
thrift.read(sdata);
auto error = DebuggerWireHelpers::WireUnserialize(sdata, m_variables);
if (error != DebuggerWireHelpers::NoError) {
m_variables = null_array;
if (error != DebuggerWireHelpers::HitLimit || m_version == 0) {
// Unexpected error. Log it.
m_wireError = sdata;
}
}
}
thrift.read(m_global);
if (m_version == 2) {
thrift.read(m_varName);
thrift.read(m_filter);
}
}
void InstPointInfo::RecvImpl(InstPointInfoPtrVec& ips,
DebuggerThriftBuffer &thrift) {
TRACE(2, "InstPointInfo::RecvImpl\n");
int16_t size;
thrift.read(size);
ips.resize(size);
for (int i = 0; i < size; i++) {
InstPointInfoPtr ipi(new InstPointInfo());
ipi->recvImpl(thrift);
ips[i] = ipi;
}
}
void CmdVariable::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
thrift.write(m_frame);
{
String sdata;
DebuggerWireHelpers::WireSerialize(m_variables, sdata);
thrift.write(sdata);
}
thrift.write(m_global);
if (m_version == 2) {
thrift.write(m_formatMaxLen);
thrift.write(m_varName);
thrift.write(m_filter);
}
}
void CmdPrint::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
if (m_printLevel > 0) {
g_context->setDebuggerPrintLevel(m_printLevel);
}
{
String sdata;
DebuggerWireHelpers::WireSerialize(m_ret, sdata);
thrift.write(sdata);
}
if (m_printLevel > 0) {
g_context->setDebuggerPrintLevel(-1);
}
thrift.write(m_output);
thrift.write(m_frame);
thrift.write(m_bypassAccessCheck);
thrift.write(m_printLevel);
thrift.write(m_noBreak);
}
void CmdPrint::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
{
String sdata;
thrift.read(sdata);
int error = DebuggerWireHelpers::WireUnserialize(sdata, m_ret);
if (error) {
m_ret = null;
}
if (error == DebuggerWireHelpers::HitLimit) {
m_wireError = "Hit unserialization limit. "
"Try with smaller print level";
}
}
thrift.read(m_output);
thrift.read(m_frame);
thrift.read(m_bypassAccessCheck);
thrift.read(m_printLevel);
thrift.read(m_noBreak);
}
void CmdHeaptrace::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
thrift.read(m_accum.typesMap);
thrift.read(m_accum.sizeMap);
thrift.read(m_accum.adjacencyList);
}
void CmdHeaptrace::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
thrift.write(m_accum.typesMap);
thrift.write(m_accum.sizeMap);
thrift.write(m_accum.adjacencyList);
}
void CmdShell::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
thrift.read(m_args);
thrift.read(m_out);
}
void CmdUser::sendImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::sendImpl(thrift);
thrift.write(m_cmd);
}
void CmdUser::recvImpl(DebuggerThriftBuffer &thrift) {
DebuggerCommand::recvImpl(thrift);
thrift.read(m_cmd);
}