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; }