QByteArray NetworkPackage::serialize() const
{
//Object -> QVariant
//QVariantMap variant;
//variant["id"] = mId;
//variant["type"] = mType;
//variant["body"] = mBody;
QVariantMap variant = qobject2qvariant(this);
if (hasPayload()) {
//qCDebug(KDECONNECT_CORE) << "Serializing payloadTransferInfo";
variant[QStringLiteral("payloadSize")] = payloadSize();
variant[QStringLiteral("payloadTransferInfo")] = mPayloadTransferInfo;
}
//QVariant -> json
auto jsonDocument = QJsonDocument::fromVariant(variant);
QByteArray json = jsonDocument.toJson(QJsonDocument::Compact);
if (json.isEmpty()) {
qCDebug(KDECONNECT_CORE) << "Serialization error:";
} else {
/*if (!isEncrypted()) {
//qCDebug(KDECONNECT_CORE) << "Serialized package:" << json;
}*/
json.append('\n');
}
return json;
}
void
RTMP::update()
{
if (!connected()) {
_handShaker->call();
if (_handShaker->error()) {
_error = true;
}
if (!_handShaker->success()) return;
_connected = true;
}
const size_t reads = 10;
for (size_t i = 0; i < reads; ++i) {
/// No need to continue reading (though it should do no harm).
if (error()) return;
RTMPPacket p;
// If we haven't finished reading a packet, retrieve it; otherwise
// use an empty one.
if (_incompletePacket.get()) {
log_debug("Doing incomplete packet");
p = *_incompletePacket;
_incompletePacket.reset();
}
else {
if (!readPacketHeader(p)) continue;
}
// Get the payload if possible.
if (hasPayload(p) && !readPacketPayload(p)) {
// If the payload is not completely readable, store it and
// continue.
_incompletePacket.reset(new RTMPPacket(p));
continue;
}
// Store a copy of the packet for later additions and as a reference for
// future sends.
RTMPPacket& stored = storePacket(CHANNELS_IN, p.header.channel, p);
// If the packet is complete, the stored packet no longer needs to
// keep the data alive.
if (isReady(p)) {
clearPayload(stored);
handlePacket(p);
return;
}
}
}
XMLMessageBean* XMLMessage::getBean()
{
XMLMessageBean* resultBean = (XMLMessageBean*)NULL;
if (!hasPayload())
return resultBean; // NULL
char *data = (char*)getPayload()->data();
if (data == NULL)
return resultBean; // NULL
//
// Hugh hack to get message number quickly.
//
const char *messagePrefix = "<MessageType type=\"int\">", *messageSuffix = "</MessageType>";
char *messnumBegin = NULL, *messnumEnd = NULL;
if ((messnumBegin = strstr(data, messagePrefix)) == NULL)
return resultBean; // NULL
if ((messnumEnd = strstr(messnumBegin, messageSuffix)) == NULL)
return resultBean; // NULL
// Should be replaced with a call to xml.datatype.DataTypeInt::decode()
messnumBegin += strlen(messagePrefix);
char *cp = messnumBegin;
while (cp != messnumEnd)
{
if (!isdigit(*cp)) // Check for junk
return resultBean; // NULL
cp++;
}
int numLen = messnumEnd - messnumBegin;
char *strNum = new char[numLen+1];
/** CJM 09-09-05.. fix for memory instability */
memset( strNum, 0x00, numLen+1 );
strncpy(strNum, messnumBegin, numLen);
int mNum = atoi(strNum);
delete[] strNum;
if (m_ApplicationBean != NULL)
resultBean = m_ApplicationBean->getXMLMessageBean(mNum);
if (resultBean != NULL)
resultBean->decode(data);
return resultBean;
}
void Widget::_receive( Msg * _pMsg )
{
State state = m_state;
switch( _pMsg->type() )
{
case MsgType::MouseEnter:
if( m_bPressed )
state.setPressed(true);
else
state.setHovered(true);
break;
case MsgType::MouseLeave:
state.setHovered(false); // Also clears any pressed flag.
break;
case MsgType::MousePress:
{
auto pMsg = static_cast<MousePressMsg*>(_pMsg);
if( pMsg->button() == MouseButton::Left )
{
if( state.isHovered() )
state.setPressed(true);
m_bPressed = true;
}
break;
}
case MsgType::MouseRelease:
{
auto pMsg = static_cast<MouseReleaseMsg*>(_pMsg);
if( pMsg->button() == MouseButton::Left )
{
if( state.isHovered() )
state.setPressed(false);
m_bPressed = false;
}
break;
}
case MsgType::FocusGained:
state.setFocused(true);
break;
case MsgType::FocusLost:
state.setFocused(false);
break;
case MsgType::DropPick:
{
auto pMsg = static_cast<DropPickMsg*>(_pMsg);
if (!pMsg->hasPayload())
{
pMsg->setPayload(Payload::create());
}
break;
}
case MsgType::DropEnter:
state.setTargeted(true);
break;
case MsgType::DropLeave:
state.setTargeted(false);
break;
default:
break;
}
if( state != m_state )
_setState( state );
}
/// Fills a pre-existent RTMPPacket with information.
//
/// This is either read entirely from incoming data, or copied from a
/// previous packet in the same channel. This happens when the header type
/// is less than RTMP_PACKET_SIZE_LARGE.
//
/// It seems as if new packets can add to the data of old ones if they have
/// a minimal, small header.
bool
RTMP::readPacketHeader(RTMPPacket& packet)
{
RTMPHeader& hr = packet.header;
std::uint8_t hbuf[RTMPHeader::headerSize] = { 0 };
std::uint8_t* header = hbuf;
// The first read may fail, but otherwise we expect a complete header.
if (readSocket(hbuf, 1) == 0) {
return false;
}
//log_debug("Packet is %s", boost::io::group(std::hex, (unsigned)hbuf[0]));
const int htype = ((hbuf[0] & 0xc0) >> 6);
//log_debug("Thingy whatsit (packet size type): %s", htype);
const int channel = (hbuf[0] & 0x3f);
//log_debug("Channel: %s", channel);
hr.headerType = static_cast<PacketSize>(htype);
hr.channel = channel;
++header;
if (hr.channel == 0) {
if (readSocket(&hbuf[1], 1) != 1) {
log_error(_("failed to read RTMP packet header 2nd byte"));
return false;
}
hr.channel = hbuf[1] + 64;
++header;
}
else if (hr.channel == 1) {
if (readSocket(&hbuf[1], 2) != 2) {
log_error(_("Failed to read RTMP packet header 3nd byte"));
return false;
}
const std::uint32_t tmp = (hbuf[2] << 8) + hbuf[1];
hr.channel = tmp + 64;
log_debug("%s, channel: %0x", __FUNCTION__, hr.channel);
header += 2;
}
// This is the size in bytes of the packet header according to the
// type.
int nSize = packetSize[htype];
/// If we didn't receive a large header, the timestamp is relative
if (htype != RTMP_PACKET_SIZE_LARGE) {
if (!hasPacket(CHANNELS_IN, hr.channel)) {
log_error(_("Incomplete packet received on channel %s"), channel);
return false;
}
// For all other header types, copy values from the last message of
// this channel. This includes any payload data from incomplete
// messages.
packet = getPacket(CHANNELS_IN, hr.channel);
}
--nSize;
if (nSize > 0 && readSocket(header, nSize) != nSize) {
log_error(_("Failed to read RTMP packet header. type: %s"),
static_cast<unsigned>(hbuf[0]));
return false;
}
if (nSize >= 3) {
const std::uint32_t timestamp = decodeInt24(header);
// Make our packet timestamp absolute. If the value is 0xffffff,
// the absolute value comes later.
if (timestamp != 0xffffff) {
if (htype != RTMP_PACKET_SIZE_LARGE) {
packet.header._timestamp += timestamp;
}
else {
packet.header._timestamp = timestamp;
}
}
// Have at least a different size payload from the last packet.
if (nSize >= 6) {
// We do this in case there was an incomplete packet in the
// channel already.
clearPayload(packet);
hr.dataSize = decodeInt24(header + 3);
// More than six: read packet type
if (nSize > 6) {
hr.packetType = static_cast<PacketType>(header[6]);
// Large packets have a streamID.
if (nSize == 11) {
hr._streamID = decodeInt32LE(header + 7);
}
}
}
}
if (hr._timestamp == 0xffffff) {
if (readSocket(header+nSize, 4) != 4) {
log_error(_("%s, failed to read extended timestamp"),
__FUNCTION__);
return false;
}
hr._timestamp = amf::readNetworkLong(header+nSize);
}
const size_t bufSize = hr.dataSize + RTMPHeader::headerSize;
// If the packet does not have a payload, it was a complete packet stored in
// the channel for reference. This is the only case when a packet should
// exist but have no payload. We re-allocate in this case.
if (!hasPayload(packet)) {
packet.buffer.reset(new SimpleBuffer(bufSize));
// Why do this again? In case it was copied from the old packet?
hr.headerType = static_cast<PacketSize>(htype);
}
// Resize anyway. If it's different from what it was before, we should
// already have cleared it.
packet.buffer->resize(bufSize);
return true;
}
size_t
Interest::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
// Interest ::= INTEREST-TYPE TLV-LENGTH
// Name
// Selectors?
// Nonce
// InterestLifetime?
// Link?
// SelectedDelegation?
// Payload
// IsPint
// (reverse encoding)
// IsPint
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::IsPint, getIsPint());
// Payload
if (hasPayload()) {
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::Payload1, getPayload1());
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::Payload2, getPayload2());
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::Payload3, getPayload3());
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::Payload4, getPayload4());
}
if (hasLink()) {
if (hasSelectedDelegation()) {
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::SelectedDelegation,
m_selectedDelegationIndex);
}
totalLength += encoder.prependBlock(m_link);
}
else {
BOOST_ASSERT(!hasSelectedDelegation());
}
// InterestLifetime
if (getInterestLifetime() >= time::milliseconds::zero() &&
getInterestLifetime() != DEFAULT_INTEREST_LIFETIME)
{
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::InterestLifetime,
getInterestLifetime().count());
}
// Nonce
getNonce(); // to ensure that Nonce is properly set
totalLength += encoder.prependBlock(m_nonce);
// Selectors
if (hasSelectors())
{
totalLength += getSelectors().wireEncode(encoder);
}
// Name
totalLength += getName().wireEncode(encoder);
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::Interest);
return totalLength;
}