void Dispatcher::sendTTHTreeRequest(QHostAddress host, QByteArray tthRoot, quint32 startOffset, quint32 numberOfBuckets)
{
QByteArray *datagram = new QByteArray;
datagram->reserve(34);
datagram->append(UnicastPacket);
datagram->append(TTHTreeRequestPacket);
datagram->append(tthRoot);
datagram->append(toQByteArray(startOffset));
datagram->append(toQByteArray(numberOfBuckets));
sendUnicastRawDatagram(host, datagram);
}
QByteArray Dispatcher::assembleSearchPacket(QHostAddress &searchingHost, quint64 &searchID, QByteArray &searchData, bool appendBucket)
{
QByteArray datagram;
datagram.reserve(300);
datagram.append(toQByteArray(searchingHost.toIPv4Address()));
datagram.append(toQByteArray(searchID));
datagram.append(fixedCIDLength(CID)); // moet seker wees lengte is reg, anders bevark hy die indekse wat kom
datagram.append(toQByteArray((quint16)searchData.length()));
datagram.append(searchData);
if (appendBucket)
datagram.append(networkTopology->getOwnBucket());
return datagram;
}
void Signal::generatePreKeys() {
const uint32_t preKeyCount = 100;
uint32_t actualCount = m_storage.preKeyCount();
if (actualCount < preKeyCount) {
uint32_t count = preKeyCount - actualCount;
uint32_t startId = m_storage.maxPreKeyId() + 1;
if (startId + count >= PRE_KEY_MEDIUM_MAX_VALUE) {
startId = 1;
}
signal_protocol_key_helper_pre_key_list_node *pre_keys_head = nullptr;
if (signal_protocol_key_helper_generate_pre_keys(&pre_keys_head, startId, count, m_signalContext) == SG_SUCCESS) {
QVector<QPair<uint32_t, QByteArray>> keys;
signal_protocol_key_helper_pre_key_list_node *cur_node = pre_keys_head;
signal_buffer *key_buf = nullptr;
while (cur_node) {
session_pre_key *pre_key = signal_protocol_key_helper_key_list_element(cur_node);
if (session_pre_key_serialize(&key_buf, pre_key) == SG_SUCCESS) {
keys.append(qMakePair(session_pre_key_get_id(pre_key), toQByteArray(key_buf)));
signal_buffer_bzero_free(key_buf);
}
cur_node = signal_protocol_key_helper_key_list_next(cur_node);
}
signal_protocol_key_helper_key_list_free(pre_keys_head);
m_storage.storePreKeys(keys);
}
}
}
/**
* @brief TokenItem::toQByteArray Stores the current instance of TokenItem in a QByteArray.
* @remarks Used in drag&drop events to pass a TokenItem through the MimeData.
* @return QByteArray containing sufficient information about the TokenItem to reconstruct it.
*/
QByteArray TokenItem::toQByteArray() {
QByteArray out;
QDataStream stream(&out, QIODevice::WriteOnly);
toQByteArray(&stream);
return out;
}
void Dispatcher::sendCIDPingForwardRequest(QHostAddress &forwardingNode, QByteArray &cid)
{
QByteArray *datagram = new QByteArray;
datagram->reserve(30);
datagram->append(UnicastPacket);
datagram->append(CIDPingForwardRequestPacket);
datagram->append(toQByteArray(dispatchIP.toIPv4Address()));
datagram->append(cid);
sendUnicastRawDatagram(forwardingNode, datagram);
}
void Dispatcher::sendTTHSearchMulticast(QByteArray &tth)
{
QByteArray datagram;
datagram.reserve(30);
datagram.append(MulticastPacket);
datagram.append(TTHSearchRequestPacket);
datagram.append(toQByteArray(dispatchIP.toIPv4Address()));
datagram.append(tth);
sendMulticastRawDatagram(datagram);
}
void Dispatcher::sendTTHSearchForwardRequest(QHostAddress &forwardingNode, QByteArray &tth)
{
QByteArray *datagram = new QByteArray;
datagram->reserve(30);
datagram->append(UnicastPacket);
datagram->append(TTHSearchForwardRequestPacket);
datagram->append(toQByteArray(dispatchIP.toIPv4Address()));
datagram->append(tth);
sendUnicastRawDatagram(forwardingNode, datagram);
//qDebug() << "Dispatcher::sendTTHSearchForwardRequest() forwardingNode tth" << forwardingNode << tth.toBase64();
}
void Dispatcher::sendUnicastAnnounceForwardRequest(QHostAddress toAddr)
{
QByteArray *datagram = new QByteArray;
datagram->reserve(54);
datagram->append(UnicastPacket);
datagram->append(AnnounceForwardRequestPacket);
datagram->append(toQByteArray(dispatchIP.toIPv4Address()));
datagram->append(CID);
datagram->append(networkTopology->getOwnBucketId());
sendUnicastRawDatagram(toAddr, datagram);
}
void Dispatcher::sendTTHSearchResult(QHostAddress toHost, QByteArray tth)
{
QByteArray *datagram = new QByteArray;
datagram->reserve(30);
datagram->append(UnicastPacket);
datagram->append(TTHSearchResultPacket);
datagram->append(toQByteArray(dispatchIP.toIPv4Address()));
datagram->append(tth);
//TODO: uncomment post 0.1.9
//datagram->append(CID);
sendUnicastRawDatagram(toHost, datagram);
}
QString Server::findIssue(const QString & text, int & issue_id) {
issue_id = -1; // Not found
QUrlQuery params;
params.addQueryItem("filters[text][operator]", "=");
params.addQueryItem("filters[text][value]", text);
QString url = "/arx/issues/find/format/rss?issues/project_key/arx&"
+ toQString(qUrlQueryToPostData(params));
http::Request request(toUTF8(m_serverPrefix + url));
boost::scoped_ptr<http::Response> response(get(request));
if(!response->ok()) {
return QString();
}
QXmlStreamReader xml(toQByteArray(response->data()));
// Using XPath would have probably been simpler, but it would
// add a dependency to QtXmlPatterns...
// Look for the first "/rss/channel/item/link" entry...
const QString XML_PATH[] = { "rss", "channel", "item", "link" };
size_t currentItem = 0;
QString issueLink;
while(!xml.atEnd() && !xml.hasError()) {
// Read next element
QXmlStreamReader::TokenType token = xml.readNext();
if(currentItem == size_t(boost::size(XML_PATH))) {
QString issue = xml.text().toString();
if(getIssueIdFromUrl(toUTF8(issue), issue_id)) {
return issue;
}
break;
}
// If token is StartElement, we'll see if we can read it.
if(token == QXmlStreamReader::StartElement && xml.name() == XML_PATH[currentItem]) {
currentItem++;
}
}
return QString();
}
Bundle Signal::collectBundle() {
generatePreKeys();
Bundle bundle;
bundle.signedPreKeyId = m_storage.signedPreKeyid();
session_signed_pre_key *signed_pre_key = nullptr;
if (signal_protocol_signed_pre_key_load_key(m_storage.storeContext(), &signed_pre_key, bundle.signedPreKeyId) != SG_SUCCESS) {
return bundle;
}
bundle.signedPreKeySignature = toQByteArray(session_signed_pre_key_get_signature(signed_pre_key),
session_signed_pre_key_get_signature_len(signed_pre_key));
QByteArray signedPreKeyPublicKey = getPublicKey(session_signed_pre_key_get_key_pair(signed_pre_key));
if (!signedPreKeyPublicKey.isNull()) {
bundle.signedPreKeyPublic = signedPreKeyPublicKey;
bundle.identityKeyPublic = getIdentityPublicKey();
foreach (auto preKey, m_storage.loadAllPreKeys()) {
session_pre_key *pre_key = nullptr;
if (session_pre_key_deserialize(&pre_key,
reinterpret_cast<const uint8_t *>(preKey.second.data()),
static_cast<size_t>(preKey.second.size()),
m_signalContext) == SG_SUCCESS) {
QByteArray preKeyPublicKey = getPublicKey(session_pre_key_get_key_pair(pre_key));
if (!preKeyPublicKey.isNull()) {
bundle.preKeys.append(qMakePair(preKey.first, preKeyPublicKey));
}
SIGNAL_UNREF(pre_key);
}
}
if (!bundle.preKeys.isEmpty()) {
bundle.loaded = true;
}
}
QTextStream* LongStringPrivate::textStream() const
{
const QByteArray input = toQByteArray();
return new QTextStream(input);
}
QDataStream* LongStringPrivate::dataStream() const
{
const QByteArray input = toQByteArray();
return new QDataStream(input);
}
