void SyslogParser::parseNew(const std::string& msg, RemoteSyslogChannel::Severity severity, RemoteSyslogChannel::Facility fac, std::size_t& pos)
{
Poco::Message::Priority prio = convert(severity);
// rest of the unparsed header is:
// VERSION SP TIMESTAMP SP HOSTNAME SP APP-NAME SP PROCID SP MSGID
std::string versionStr(parseUntilSpace(msg, pos));
std::string timeStr(parseUntilSpace(msg, pos)); // can be the nilvalue!
std::string hostName(parseUntilSpace(msg, pos));
std::string appName(parseUntilSpace(msg, pos));
std::string procId(parseUntilSpace(msg, pos));
std::string msgId(parseUntilSpace(msg, pos));
std::string message(msg.substr(pos));
pos = msg.size();
Poco::DateTime date;
int tzd = 0;
bool hasDate = Poco::DateTimeParser::tryParse(RemoteSyslogChannel::SYSLOG_TIMEFORMAT, timeStr, date, tzd);
Poco::Message logEntry(msgId, message, prio);
logEntry["host"] = hostName;
logEntry["app"] = appName;
if (hasDate)
logEntry.setTime(date.timestamp());
int lval(0);
Poco::NumberParser::tryParse(procId, lval);
logEntry.setPid(lval);
_pListener->log(logEntry);
}
/**
* Start an RPC request
*
* Use send() to pass on each of the call parameters
*
* Returns a MsgpackRequest object. You can connect to
* its finished() SIGNAL to handle the response
*/
MsgpackRequest* MsgpackIODevice::startRequestUnchecked(const QString& method, quint32 argcount)
{
quint32 msgid = msgId();
// [type(0), msgid, method, args]
msgpack_pack_array(&m_pk, 4);
msgpack_pack_int(&m_pk, 0);
msgpack_pack_int(&m_pk, msgid);
const QByteArray& utf8 = method.toUtf8();
msgpack_pack_bin(&m_pk, utf8.size());
msgpack_pack_bin_body(&m_pk, utf8.constData(), utf8.size());
msgpack_pack_array(&m_pk, argcount);
MsgpackRequest *r = new MsgpackRequest( msgid, this);
connect(r, &MsgpackRequest::timeout,
this, &MsgpackIODevice::requestTimeout);
m_requests.insert(msgid, r);
return r;
}
void FifoReadCallback::readDataAvailable(size_t len) noexcept {
try {
readBuffer_.postallocate(len);
// Process any pending packet headers.
if (pendingHeader_.packetSize() > 0) {
if (readBuffer_.chainLength() < pendingHeader_.packetSize()) {
return;
}
feedParser(pendingHeader_,
readBuffer_.split(pendingHeader_.packetSize()));
pendingHeader_.setPacketSize(0);
}
while (readBuffer_.chainLength() >= std::max(sizeof(MessageHeader),
sizeof(PacketHeader))) {
if (isMessageHeader(readBuffer_)) {
auto msgHeader = parseMessageHeader(readBuffer_);
auto fromAddr = msgHeader.getLocalAddress();
auto toAddr = msgHeader.getPeerAddress();
if (msgHeader.direction() == MessageDirection::Received) {
std::swap(fromAddr, toAddr);
}
parserMap_.fetch(msgHeader.msgId()).setAddresses(fromAddr, toAddr);
continue;
}
auto packetHeader = parsePacketHeader(
readBuffer_.split(sizeof(PacketHeader))->coalesce());
if (packetHeader.packetSize() > readBuffer_.chainLength()) {
// Wait for more data.
pendingHeader_ = std::move(packetHeader);
return;
}
feedParser(packetHeader, readBuffer_.split(packetHeader.packetSize()));
}
} catch (const std::exception& ex) {
CHECK(false) << "Unexpected exception: " << ex.what();
}
}
