/**
* SendResendRequest:
* Request RAOP client to resend missed RTP packets
*/
void MythRAOPConnection::SendResendRequest(uint64_t timestamp,
uint16_t expected, uint16_t got)
{
if (!m_clientControlSocket)
return;
int16_t missed = (got < expected) ?
(int16_t)(((int32_t)got + UINT16_MAX + 1) - expected) :
got - expected;
LOG(VB_GENERAL, LOG_INFO, LOC +
QString("Missed %1 packet(s): expected %2 got %3 ts:%4")
.arg(missed).arg(expected).arg(got).arg(timestamp));
char req[8];
req[0] = 0x80;
req[1] = RANGE_RESEND | 0x80;
*(uint16_t *)(req + 2) = qToBigEndian(m_seqNum++);
*(uint16_t *)(req + 4) = qToBigEndian(expected); // missed seqnum
*(uint16_t *)(req + 6) = qToBigEndian(missed); // count
if (m_clientControlSocket->writeDatagram(req, sizeof(req),
m_peerAddress, m_clientControlPort)
== sizeof(req))
{
for (uint16_t count = 0; count < missed; count++)
{
LOG(VB_GENERAL, LOG_INFO, LOC + QString("Sent resend for %1")
.arg(expected + count));
m_resends.insert(expected + count, timestamp);
}
}
else
LOG(VB_GENERAL, LOG_ERR, LOC + "Failed to send resend request.");
}
void RpcConnection::writeHeader(char* header, quint16 type, quint16 method,
quint32 length)
{
*((quint16*)(header+0)) = qToBigEndian(type);
*((quint16*)(header+2)) = qToBigEndian(method);
*((quint32*)(header+4)) = qToBigEndian(length);
}
/**
* SendTimeRequest:
* Send a time request to the RAOP client.
*/
void MythRAOPConnection::SendTimeRequest(void)
{
if (!m_clientControlSocket) // should never happen
return;
timeval t;
gettimeofday(&t, NULL);
char req[32];
req[0] = 0x80;
req[1] = TIMING_REQUEST | 0x80;
// this is always 0x00 0x07 according to http://blog.technologeek.org/airtunes-v2
// no other value works
req[2] = 0x00;
req[3] = 0x07;
*(uint32_t *)(req + 4) = (uint32_t)0;
*(uint64_t *)(req + 8) = (uint64_t)0;
*(uint64_t *)(req + 16) = (uint64_t)0;
*(uint32_t *)(req + 24) = qToBigEndian((uint32_t)t.tv_sec);
*(uint32_t *)(req + 28) = qToBigEndian((uint32_t)t.tv_usec);
if (m_clientTimingSocket->writeDatagram(req, sizeof(req), m_peerAddress, m_clientTimingPort) != sizeof(req))
{
LOG(VB_GENERAL, LOG_ERR, LOC + "Failed to send resend time request.");
return;
}
LOG(VB_GENERAL, LOG_DEBUG, LOC +
QString("Requesting master time (Local %1.%2)")
.arg(t.tv_sec).arg(t.tv_usec));
}
QByteArray SettingsFrame::dump(StreamContext& context) const
{
if (context.identifier != 0) {
qWarning() << "SETTINGS Frame identifier must be 0";
}
QByteArray payload;
if (!ack_) {
payload.resize(settings_.size() * 8);
uchar* payloadPtr = reinterpret_cast<uchar*>(payload.data());
for(SettingsType key: settings_.keys()) {
quint32 value = settings_[key];
qToBigEndian(static_cast<quint32>(key), payloadPtr);
payloadPtr += sizeof(quint32);
qToBigEndian(value, payloadPtr);
payloadPtr += sizeof(quint32);
}
}
uchar flags = 0;
if (ack_) flags |= SETTINGS_FLAG_ACK;
BasicFrame frame;
frame.setType(FRAME_SETTINGS);
frame.setFlags(flags);
frame.setPayload(payload);
frame.setIdentifier(0);
return frame.dump();
}
void CryptFileDevice::initCtr(CtrState *state, const unsigned char *iv)
{
qint64 position = pos();
state->num = position % AES_BLOCK_SIZE;
memset(state->ecount, 0, 16);
/* Initialise counter in 'ivec' */
qint64 count = position / AES_BLOCK_SIZE;
if (state->num > 0)
count++;
qint64 newCount = count;
if (newCount > 0)
newCount = qToBigEndian(count);
memcpy(state->ivec + 8, &newCount, 8);
/* Copy IV into 'ivec' */
memcpy(state->ivec, iv, 8);
if (count > 0)
{
count = qToBigEndian(count - 1);
unsigned char * prevIvec = new unsigned char[16];
memcpy(prevIvec, state->ivec, 8);
memcpy(prevIvec + 8, &count, 8);
AES_encrypt(prevIvec, state->ecount, &m_aesKey);
}
}
void TimeSync::getNTPTime()
{
QUdpSocket sock;
sock.connectToHost("0.pool.ntp.org",123);
if(!sock.waitForConnected(1000))return;
QByteArray data(48,char(0)); *(reinterpret_cast<qint32 *>(&data.data()[0]))=4194959577;
if(sock.write(data)<0||!sock.waitForReadyRead(3000)||sock.bytesAvailable()!=48)return;
data=sock.readAll();
quint32 seconds=qToBigEndian(*(reinterpret_cast<quint32 *>(&data.data()[40])));
quint32 fraction=qToBigEndian(*(reinterpret_cast<quint32 *>(&data.data()[44])));
quint32 newTime=QDateTime::fromMSecsSinceEpoch(seconds*1000ll+fraction*1000ll/0x100000000ll-2208988800000ll).toTime_t();
if(newTime<1451606400 || newTime>4000000000){
QThread::msleep(500);
emit startSync();
return;
}
qint32 tempTimeShift=qint64(newTime)-qint64(QDateTime::currentDateTime().toTime_t());
if(timeShift!=0)tempTimeShift=qint32((qint64(timeShift)+qint64(tempTimeShift))/2);
if(tempTimeShift>3600 || tempTimeShift<-3600){
static bool showMessage=true;
if(showMessage)emit warningMessage(julyTr("TIME_SYNC_ERROR","Your clock is not set. Please close the Qt Bitcoin Trader and set the clock. Changing time at Qt Bitcoin Trader enabled can cause errors and damage the keys."));
showMessage=false;
}
else
timeShift.fetchAndStoreOrdered(tempTimeShift);
getNTPTimeRetryCount++;
if(getNTPTimeRetryCount<3)emit startSync();
}
int MovePointer::serializePayload(uchar *data) const
{
uchar *ptr = data;
qToBigEndian(m_x, ptr); ptr += 4;
qToBigEndian(m_y, ptr); ptr += 4;
return ptr-data;
}
int PenMove::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
foreach(const PenPoint &p, _points) {
qToBigEndian(p.x, ptr); ptr += 4;
qToBigEndian(p.y, ptr); ptr += 4;
qToBigEndian(p.p, ptr); ptr += 2;
}
int PenMove::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = _ctx;
foreach(const PenPoint &p, _points) {
qToBigEndian(p.x, ptr); ptr += 2;
qToBigEndian(p.y, ptr); ptr += 2;
*(ptr++) = p.p;
}
void LedGridControllerUT::setPixel()
{
MyMock::expectOneCallAndReturnInt(QString("open_fbdev"), 1);
LedGridController *controller = LedGridController::getInstance();
controller->setPixel(0,0, QColor(0x80,0x0,0xFF));
QCOMPARE(controller->frameBuffer[0], qToBigEndian((quint16)0x781F));
controller->setPixel(3,4, QColor(0xFF,0xFF,0xFF));
QCOMPARE(controller->frameBuffer[(4*8)+3], qToBigEndian((quint16)0xFFFF));
}
int CanvasResize::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
qToBigEndian(_top, ptr); ptr += 2;
qToBigEndian(_right, ptr); ptr += 2;
qToBigEndian(_bottom, ptr); ptr += 2;
qToBigEndian(_left, ptr); ptr += 2;
return ptr - data;
}
int MovePointer::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
qToBigEndian(_x, ptr); ptr += 4;
qToBigEndian(_y, ptr); ptr += 4;
*(ptr++) = _persistence;
return ptr-data;
}
int PenMove::serializePayload(uchar *data) const
{
uchar *ptr = data;
for(const PenPoint &p : _points) {
qToBigEndian(p.x, ptr); ptr += 4;
qToBigEndian(p.y, ptr); ptr += 4;
qToBigEndian(p.p, ptr); ptr += 2;
}
return ptr - data;
}
int AnnotationReshape::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
*(ptr++) = _id;
qToBigEndian(_x, ptr); ptr += 4;
qToBigEndian(_y, ptr); ptr += 4;
qToBigEndian(_w, ptr); ptr += 2;
qToBigEndian(_h, ptr); ptr += 2;
return ptr - data;
}
void SatelliteSingleSend::connected()
{
SATELLITE_PKGINFO_HEADER_TYPE header( SATELLITE_PKGINFO_MAGIC_VALUE );
header <<= 32;
header |= mMessage.size();
header = qToBigEndian( header );
SATELLITE_PKGINFO_CHECKSUM_TYPE checksum( qChecksum( mMessage.constData(), mMessage.size() ) );
checksum = qToBigEndian( checksum );
mpServerConnection->write( (char*)(&header), SATELLITE_PKGINFO_HEADER_SIZE );
mpServerConnection->write( mMessage );
mpServerConnection->write( (char*)(&checksum), SATELLITE_PKGINFO_CHECKSUM_SIZE );
mpServerConnection->flush();
mpServerConnection->disconnectFromHost();
}
void ClientSocket::sendDeleteKeyCommand(const QString &trackName, int row)
{
if (!connected() ||
clientTracks.count(trackName) == 0)
return;
quint32 track = qToBigEndian((quint32)clientTracks[trackName]);
row = qToBigEndian((quint32)row);
unsigned char cmd = DELETE_KEY;
send((char *)&cmd, 1, false);
send((char *)&track, sizeof(int), false);
send((char *)&row, sizeof(int), true);
}
TinySVCMDNS::TinySVCMDNS() {
// Get all network interfaces
QList<QNetworkInterface> network_interfaces =
QNetworkInterface::allInterfaces();
for (QNetworkInterface network_interface : network_interfaces) {
// Only use up and non loopback interfaces
if (network_interface.flags().testFlag(network_interface.IsUp) &&
!network_interface.flags().testFlag(network_interface.IsLoopBack)) {
uint32_t ipv4 = 0;
QString ipv6;
qLog(Debug) << "Interface" << network_interface.humanReadableName();
// Now check all network addresses for this device
QList<QNetworkAddressEntry> network_address_entries =
network_interface.addressEntries();
for (QNetworkAddressEntry network_address_entry :
network_address_entries) {
QHostAddress host_address = network_address_entry.ip();
if (host_address.protocol() == QAbstractSocket::IPv4Protocol) {
ipv4 = qToBigEndian(host_address.toIPv4Address());
qLog(Debug) << " ipv4:" << host_address.toString();
} else if (host_address.protocol() == QAbstractSocket::IPv6Protocol) {
ipv6 = host_address.toString();
qLog(Debug) << " ipv6:" << host_address.toString();
}
}
// Now start the service
CreateMdnsd(ipv4, ipv6);
}
}
}
/*
* DnsServiceRegistrar::add
*
* Registers a new service.
*
* Parameters:
* - type: service type
* - port: port number of the registered service
* - name: service name (optional)
*
* Return value: reference of the DNS service if registration was successful, NULL otherwise
*/
DNSServiceRef DnsServiceRegistrar::add(const QString& type, quint16 port, const QString& name)
{
/* Deal with name default value */
char *nameStr;
if (name == "") {
nameStr = NULL;
} else {
nameStr = name.toUtf8().data();
}
/* Create and register the new service ref. */
DNSServiceRef ref;
DNSServiceErrorType err = DNSServiceRegister(&ref, 0, 0, nameStr, type.toUtf8().data(), NULL,
NULL, qToBigEndian(port), 0, NULL, registerCallback, this);
if (err != kDNSServiceErr_NoError) {
Model::logger().addEntry(Logger::Error, QString("Error while registering service (error code = %1)").arg(err));
return NULL;
}
/* Create the QSocketNotifier */
int sockFd = DNSServiceRefSockFD(ref);
RefNotifier *pNotif = new RefNotifier(ref, sockFd, QSocketNotifier::Read, this);
connect(pNotif, SIGNAL(activated(int)), this, SLOT(onNotifierActivated()));
return ref;
}
bool LwIPTcpServer::listen(const QHostAddress &address, quint16 port) {
Q_D(LwIPTcpServer);
if(d->conn == 0) {
d->conn = LwIPDispatcher::createConn(NETCONN_TCP, this);
if(d->conn == 0) {
return false;
}
struct ip_addr addr;
addr.addr = qToBigEndian(address.toIPv4Address());
if(netconn_bind(d->conn, &addr, port) != ERR_OK)
goto failure;
if(netconn_listen(d->conn) != ERR_OK)
goto failure;
d->serverAddress = address;
d->serverPort = port;
return true;
} else
return false;
failure:
LwIPDispatcher::disposeConn(d->conn);
d->conn = 0;
return false;
}
int UserAttr::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = contextId();
qToBigEndian(_attrs, ptr); ptr += 2;
return ptr-data;
}
static QByteArray deriveKeyPbkdf2(QCryptographicHash::Algorithm algorithm,
const QByteArray &data, const QByteArray &salt,
int iterations, quint64 dkLen)
{
QByteArray key;
quint32 currentIteration = 1;
QMessageAuthenticationCode hmac(algorithm, data);
QByteArray index(4, Qt::Uninitialized);
while (quint64(key.length()) < dkLen) {
hmac.addData(salt);
qToBigEndian(currentIteration, reinterpret_cast<uchar*>(index.data()));
hmac.addData(index);
QByteArray u = hmac.result();
hmac.reset();
QByteArray tkey = u;
for (int iter = 1; iter < iterations; iter++) {
hmac.addData(u);
u = hmac.result();
hmac.reset();
std::transform(tkey.cbegin(), tkey.cend(), u.cbegin(), tkey.begin(),
std::bit_xor<char>());
}
key += tkey;
currentIteration++;
}
return key.left(dkLen);
}
int SessionConf::serializePayload(uchar *data) const
{
uchar *ptr = data;
*(ptr++) = _maxusers;
qToBigEndian(_attrs, ptr); ptr += 2;
return ptr-data;
}
void Core::bootstrapDht()
{
const Settings& s = Settings::getInstance();
QList<Settings::DhtServer> dhtServerList = s.getDhtServerList();
int listSize = dhtServerList.size();
static int j = qrand() % listSize, n=0;
// We couldn't connect after trying 6 different nodes, let's try something else
if (n>3)
{
qDebug() << "Core: We're having trouble connecting to the DHT, slowing down";
bootstrapTimer->setInterval(TOX_BOOTSTRAP_INTERVAL*(n-1));
}
else
qDebug() << "Core: Connecting to the DHT ...";
int i=0;
while (i < (2 - (n>3)))
{
const Settings::DhtServer& dhtServer = dhtServerList[j % listSize];
if (tox_bootstrap_from_address(tox, dhtServer.address.toLatin1().data(),
qToBigEndian(dhtServer.port), CUserId(dhtServer.userId).data()) == 1)
qDebug() << QString("Core: Bootstraping from ")+dhtServer.name+QString(", addr ")+dhtServer.address.toLatin1().data()
+QString(", port ")+QString().setNum(dhtServer.port);
else
qDebug() << "Core: Error bootstraping from "+dhtServer.name;
tox_do(tox);
j++;
i++;
n++;
}
}
static inline T castWithEndian(T src)
{
if(Socket_Handler::endian() == QSysInfo::BigEndian)
return qToBigEndian(src);
else
return qToLittleEndian(src);
}
bool Writer::writeHeader()
{
Q_ASSERT(m_file->isOpen());
// Format identification
const char *MAGIC = "DPREC";
m_file->write(MAGIC, 6);
// Metadata block
QJsonObject metadata;
QJsonObject version;
version["major"] = DRAWPILE_PROTO_MAJOR_VERSION;
version["minor"] = DRAWPILE_PROTO_MINOR_VERSION;
version["str"] = DRAWPILE_VERSION;
metadata["version"] = version;
// Write metadata
QByteArray metadatabuf = QJsonDocument(metadata).toJson(QJsonDocument::Compact);
uchar lenbuf[2];
qToBigEndian(quint16(metadatabuf.length()), lenbuf);
m_file->write((const char*)lenbuf, 2);
m_file->write(metadatabuf);
return true;
}
void SonicPiTCPOSCServer::readMessage()
{
while(socket->bytesAvailable() > 0){
if (blockSize == 0) {
if (socket->bytesAvailable() < (int)sizeof(quint32)){
return;
}
socket->read((char *)&blockSize, sizeof(quint32));
blockSize = qToBigEndian(blockSize);
}
if (socket->bytesAvailable() < blockSize){
return;
}
buffer.resize(blockSize);
int bytesRead = socket->read(&buffer[0], blockSize);
if(bytesRead < 0 || (uint32_t)bytesRead != blockSize) {
std::cerr << "[GUI] - Error: read: " << bytesRead << " Expected:" << blockSize << "\n";
blockSize = 0;
return;
}
std::vector<char> tmp(buffer);
tmp.swap(buffer);
handler->oscMessage(buffer);
blockSize = 0;
std::vector<char>().swap(buffer);
}
}
QByteArray AbstractSshPacket::generateMac(const SshAbstractCryptoFacility &crypt,
quint32 seqNr) const
{
const quint32 seqNrBe = qToBigEndian(seqNr);
QByteArray data(reinterpret_cast<const char *>(&seqNrBe), sizeof seqNrBe);
data += QByteArray(m_data.constData(), length() + 4);
return crypt.generateMac(data, data.size());
}
int LaserTrail::serializePayload(uchar *data) const
{
uchar *ptr = data;
qToBigEndian(m_color, ptr); ptr += 4;
*(ptr++) = m_persistence;
return ptr-data;
}
/*!
Retrieves the sfnt table named \a tagName from the underlying physical font, or an empty
byte array if no such table was found. The returned font table's byte order is Big Endian, like
the sfnt format specifies. The \a tagName must be four characters long and should be formatted
in the default endianness of the current platform.
*/
QByteArray QRawFont::fontTable(const char *tagName) const
{
if (!d->isValid())
return QByteArray();
const quint32 *tagId = reinterpret_cast<const quint32 *>(tagName);
return d->fontEngine->getSfntTable(qToBigEndian(*tagId));
}
std::string Common::packAddress(const QHostAddress &addr,
const uint16_t &port)
{
std::string addrBin;
char typeChar;
std::string portNs(2, '\0');
qToBigEndian(port, reinterpret_cast<uchar*>(&portNs[0]));
if (addr.protocol() == QAbstractSocket::IPv4Protocol) {
uint32_t ipv4Address = qToBigEndian(addr.toIPv4Address());
typeChar = static_cast<char>(Address::IPV4);
addrBin = std::string(reinterpret_cast<char*>(&ipv4Address), 4);
} else {
typeChar = static_cast<char>(Address::IPV6);
Q_IPV6ADDR ipv6Address = addr.toIPv6Address();
addrBin = std::string(reinterpret_cast<char*>(ipv6Address.c), 16);
}
return typeChar + addrBin + portNs;
}