void RpcConnection::sendNotification(int notifType,
SharedProtobufMessage notifData)
{
char msgBuf[PB_HDR_SIZE];
char* const msg = &msgBuf[0];
int len;
if (!isCompatCheckDone)
return;
if (!isNotifEnabled)
return;
if (!notifData->IsInitialized())
{
qWarning("notification missing required fields!! <----");
qDebug("notif = \n%s"
"missing = \n%s---->",
notifData->DebugString().c_str(),
notifData->InitializationErrorString().c_str());
qFatal("exiting");
return;
}
len = notifData->ByteSize();
writeHeader(msg, PB_MSG_TYPE_NOTIFY, notifType, len);
qDebug("Server(%s): sending %d bytes to client <----",
__FUNCTION__, len + PB_HDR_SIZE);
BUFDUMP(msg, 8);
qDebug("notif = %d\ndata = \n%s---->",
notifType, notifData->DebugString().c_str());
clientSock->write(msg, PB_HDR_SIZE);
notifData->SerializeToZeroCopyStream(outStream);
outStream->Flush();
}
/*ARGSUSED*/
static int
bufhandler(const dtrace_bufdata_t *bufdata, void *arg)
{
const dtrace_aggdata_t *agg = bufdata->dtbda_aggdata;
const dtrace_recdesc_t *rec = bufdata->dtbda_recdesc;
const dtrace_probedesc_t *pd;
uint32_t flags = bufdata->dtbda_flags;
char buf[512], *c = buf, *end = c + sizeof (buf);
int i, printed;
struct {
const char *name;
uint32_t value;
} flagnames[] = {
{ "AGGVAL", DTRACE_BUFDATA_AGGVAL },
{ "AGGKEY", DTRACE_BUFDATA_AGGKEY },
{ "AGGFORMAT", DTRACE_BUFDATA_AGGFORMAT },
{ "AGGLAST", DTRACE_BUFDATA_AGGLAST },
{ "???", UINT32_MAX },
{ NULL }
};
if (bufdata->dtbda_probe != NULL) {
pd = bufdata->dtbda_probe->dtpda_pdesc;
} else if (agg != NULL) {
pd = agg->dtada_pdesc;
} else {
pd = NULL;
}
BUFDUMPHDR(">>> Called buffer handler");
BUFDUMPHDR("");
BUFDUMPHDR(" dtrace_bufdata");
BUFDUMPSTR(bufdata, dtbda_buffered);
BUFDUMPPTR(bufdata, dtbda_probe);
BUFDUMPPTR(bufdata, dtbda_aggdata);
BUFDUMPPTR(bufdata, dtbda_recdesc);
(void) snprintf(c, end - c, "0x%x ", bufdata->dtbda_flags);
c += strlen(c);
for (i = 0, printed = 0; flagnames[i].name != NULL; i++) {
if (!(flags & flagnames[i].value))
continue;
(void) snprintf(c, end - c,
"%s%s", printed++ ? " | " : "(", flagnames[i].name);
c += strlen(c);
flags &= ~flagnames[i].value;
}
if (printed)
(void) snprintf(c, end - c, ")");
BUFDUMPASSTR(bufdata, dtbda_flags, buf);
BUFDUMPHDR("");
if (pd != NULL) {
BUFDUMPHDR(" dtrace_probedesc");
BUFDUMPSTR(pd, dtpd_provider);
BUFDUMPSTR(pd, dtpd_mod);
BUFDUMPSTR(pd, dtpd_func);
BUFDUMPSTR(pd, dtpd_name);
BUFDUMPHDR("");
}
if (rec != NULL) {
BUFDUMPHDR(" dtrace_recdesc");
BUFDUMP(rec, dtrd_action);
BUFDUMP(rec, dtrd_size);
if (agg != NULL) {
uint8_t *data;
int lim = rec->dtrd_size;
(void) sprintf(buf, "%d (data: ", rec->dtrd_offset);
c = buf + strlen(buf);
if (lim > sizeof (uint64_t))
lim = sizeof (uint64_t);
data = (uint8_t *)agg->dtada_data + rec->dtrd_offset;
for (i = 0; i < lim; i++) {
(void) snprintf(c, end - c, "%s%02x",
i == 0 ? "" : " ", *data++);
c += strlen(c);
}
(void) snprintf(c, end - c,
"%s)", lim < rec->dtrd_size ? " ..." : "");
BUFDUMPASSTR(rec, dtrd_offset, buf);
} else {
BUFDUMP(rec, dtrd_offset);
}
BUFDUMPHDR("");
}
if (agg != NULL) {
dtrace_aggdesc_t *desc = agg->dtada_desc;
BUFDUMPHDR(" dtrace_aggdesc");
BUFDUMPSTR(desc, dtagd_name);
BUFDUMP(desc, dtagd_varid);
BUFDUMP(desc, dtagd_id);
BUFDUMP(desc, dtagd_nrecs);
BUFDUMPHDR("");
}
return (DTRACE_HANDLE_OK);
}
void RpcConnection::sendRpcReply(PbRpcController *controller)
{
google::protobuf::Message *response = controller->response();
QIODevice *blob;
char msgBuf[PB_HDR_SIZE];
char* const msg = &msgBuf[0];
int len;
if (controller->Failed())
{
QByteArray err = controller->ErrorString().toUtf8();
qWarning("rpc failed (%s)", qPrintable(controller->ErrorString()));
len = err.size();
writeHeader(msg, PB_MSG_TYPE_ERROR, pendingMethodId, len);
clientSock->write(msg, PB_HDR_SIZE);
clientSock->write(err.constData(), len);
goto _exit;
}
blob = controller->binaryBlob();
if (blob)
{
len = blob->size();
qDebug("is binary blob of len %d", len);
writeHeader(msg, PB_MSG_TYPE_BINBLOB, pendingMethodId, len);
clientSock->write(msg, PB_HDR_SIZE);
blob->seek(0);
while (!blob->atEnd())
{
int l;
len = blob->read(msg, sizeof(msgBuf));
l = clientSock->write(msg, len);
Q_ASSERT(l == len);
Q_UNUSED(l);
}
goto _exit;
}
if (!response->IsInitialized())
{
qWarning("response missing required fields!! <----");
qDebug("response = \n%s"
"missing = \n%s---->",
response->DebugString().c_str(),
response->InitializationErrorString().c_str());
qFatal("exiting");
goto _exit;
}
len = response->ByteSize();
writeHeader(msg, PB_MSG_TYPE_RESPONSE, pendingMethodId, len);
// Avoid printing stats since it happens once every couple of seconds
if (pendingMethodId != 13)
{
qDebug("Server(%s): sending %d bytes to client <----",
__FUNCTION__, len + PB_HDR_SIZE);
BUFDUMP(msg, 8);
qDebug("method = %d\nreq = \n%s---->",
pendingMethodId, response->DebugString().c_str());
}
clientSock->write(msg, PB_HDR_SIZE);
response->SerializeToZeroCopyStream(outStream);
outStream->Flush();
if (pendingMethodId == 15) {
isCompatCheckDone = true;
isNotifEnabled = controller->NotifEnabled();
}
_exit:
if (controller->Disconnect())
clientSock->disconnectFromHost();
delete controller;
isPending = false;
}
