void ServerSearch::on_refreshButton_clicked()
{
ui->listWidget->clear();
QByteArray datagram(Helper::serverSearchRequest().toUtf8(), Helper::serverSearchRequest().length());
m_pUdpSocket->writeDatagram(datagram, QHostAddress::Broadcast, Helper::serverSearchPort());
}
void Message::tsend(QString aMessage)
{
// qDebug() <<aMessage;
QByteArray datagram(aMessage.toAscii());
// QByteArray datagram = "Message";
udpSocket->writeDatagram(datagram.data(), datagram.size(),QHostAddress("134.117.27.122"),45555);
}
void UDPServer::sendAnswer( pAnswer & _pa, QHostAddress src_host, uint id )
{
char data[65536];
int len;
_pa.getDatagram(data, &len);
QByteArray datagram(data, len);
m_pobjUDPOutSocket->writeDatagram(datagram.data(), datagram.size(), src_host, m_mapClientsInfo[id].m_mapAddrs[ src_host.toString() ] );
}
void SocksServer::sd_activated()
{
while (d->sd->hasPendingDatagrams()) {
QByteArray datagram(d->sd->pendingDatagramSize(), Qt::Uninitialized);
QHostAddress sender;
quint16 senderPort;
auto sz = d->sd->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort);
if (sz >= 0) {
datagram.truncate(sz);
incomingUDP(sender.toString(), senderPort, d->sd->peerAddress(), d->sd->peerPort(), datagram);
}
}
}
void SocksConnection::HandleUdpResponse(const TunnelPacket &packet)
{
qDebug() << "SOCKS got UDP response";
QByteArray address;
if(!SerializeSocksAddress(packet.GetHost(), packet.GetPort(), address)) {
qDebug() << "SOCKS unable to serialize address";
}
// First 3 bytes should be 0, followed by address, then data
QByteArray datagram(3, 0);
datagram += address + packet.GetMessage();
_udp_socket->writeDatagram(datagram, _udp_peer, _udp_peer_port);
}
bool ARControlConnection::sendFrame(quint8 type, quint8 id, quint8 seq, const char *data, quint32 dataSize)
{
Q_D(ARControlConnection);
// Check we're actually able to send.
if(d->c2d == NULL || !d->c2d->isWritable())
{
d->errorString = "Control connection not establised.";
emit error();
return false;
}
QByteArray datagram(ARNETWORK_FRAME_HEADER_SIZE + dataSize, 0x00);
QDataStream stream(&datagram, QIODevice::WriteOnly);
stream.setByteOrder(QDataStream::LittleEndian);
// Write frame header to buffer.
stream << type
<< id
<< seq
<< (quint32)datagram.size();
// Write frame payload to buffer.
if(dataSize > 0) stream.writeRawData(data, dataSize);
qint64 result = d->c2d->write(datagram.constData(), datagram.size());
if(result != datagram.size())
{
//TODO: Maybe retry here ..
WARNING_T("Failed to send complete message");
return false;
}
if(type != ARControlConnection::LowLatencyData)
{
DEBUG_T(QString(">> %1:%2 [%3]")
.arg(d->c2d->peerAddress().toString())
.arg(d->c2d->peerPort())
.arg(QString(datagram.toHex())));
}
return true;
}
void TIDorb::core::comm::UDPConnection::read(unsigned char* buffer, size_t buffer_size,
size_t offset, size_t length)
{
try {
while (length > 0) {
// Copy datagram bytes available in read buffer
size_t available = datagram_size - datagram_offset;
if (available) {
size_t to_copy = MIN(length, available);
memcpy(buffer + offset, datagram_buffer + datagram_offset, to_copy);
offset += to_copy;
length -= to_copy;
datagram_offset += to_copy;
} else {
// Read another datagram
TIDSocket::DatagramPacket datagram(datagram_buffer, datagram_max_size,
0, datagram_max_size);
socket->receive(datagram);
datagram_size = datagram.getLength();
if (datagram_size < 0) {
throw CORBA::COMM_FAILURE("read error", 0, CORBA::COMPLETED_NO);
}
datagram_offset = 0;
}
}
} catch(const TIDSocket::Exception& e) {
CORBA::COMM_FAILURE connection_error(e.what(), 0, CORBA::COMPLETED_NO);
// TODO: ?seguro que este close()?
close_by_broken_connection(connection_error);
throw connection_error;
}
}
void Discover::expireRecords ()
{
int next = 1000; // Maximum default interval for expiration
quint64 now = QDateTime::currentMSecsSinceEpoch();
for (const auto& pair : foundRecords.toStdMap())
{
int delta = pair.second - now;
if (delta <= 0)
{
// It's expired
logDebug(QString("Lost Record: %1").arg(pair.first.toString()));
foundRecords.remove(pair.first);
// Notify this app
emit recordLost(pair.first);
// Server: Forward global departures to other global peers
if (mServerMode)
{
QList<Record> recordInListForm;
recordInListForm.append(pair.first);
QByteArray datagram("DSDD");
datagram += makeDatagram(recordInListForm, false);
for (Record& record : foundRecords.keys())
if (record["Scope"] == "Global")
{
bool ok;
globalSocket->writeDatagram(datagram, QHostAddress(record["Address"]), record["Port"].toUInt(&ok, 10));
}
}
}
else if (delta < next) next = delta; // Set the timer for this one
}
// Set timer for next time
expireTimer->start(next);
}
void TIDorb::core::comm::UDPConnection::write(unsigned char* buffer,
size_t buffer_size,
size_t offset, size_t length)
{
try {
size_t numWrittenNow = 0;
TIDSocket::InetSocketAddress addr(initial_point._host, initial_point._port,
_orb->conf().prefer_ipv6);
TIDSocket::DatagramPacket datagram(buffer, buffer_size, offset, length, addr);
char* interface = NULL;
if (_orb->conf().prefer_ipv6) {
string point = initial_point._host;
string::size_type colon_position = point.find('%');
if (colon_position != string::npos)
interface = CORBA::string_dup(point.substr(colon_position + 1).c_str());
}
while (length > 0) {
socket->send(datagram);
numWrittenNow = datagram.getLength();
if (numWrittenNow < 0) {
throw CORBA::COMM_FAILURE("write error", 0, CORBA::COMPLETED_NO);
}
offset += numWrittenNow;
length -= numWrittenNow;
datagram.setData(buffer, buffer_size, offset, length);
}
} catch(const TIDSocket::Exception& e) {
CORBA::COMM_FAILURE connection_error(e.what(), 0, CORBA::COMPLETED_NO);
close_by_broken_connection(connection_error);
throw connection_error;
}
}
void ARControlConnection::onReadyRead()
{
Q_D(ARControlConnection);
while(d->d2c->hasPendingDatagrams())
{
QHostAddress remoteAddr;
quint16 remotePort;
// If we've not received enough data, then return and wait for more.
if(d->d2c->pendingDatagramSize() < ARNETWORK_FRAME_HEADER_SIZE) break;
QByteArray datagram(d->d2c->pendingDatagramSize(), 0x00);
quint32 offset = 0;
d->d2c->readDatagram(datagram.data(), datagram.size(), &remoteAddr, &remotePort);
while(offset < datagram.size())
{
ARControlFrame frame;
frame.type = static_cast<quint8>(datagram[offset + 0]);
frame.id = static_cast<quint8>(datagram[offset + 1]);
frame.seq = static_cast<quint8>(datagram[offset + 2]);
frame.size = qFromLittleEndian(*((quint32*)(datagram.constData() + offset + 3)));
// Copy datagram data to frame if the frame size is larger than just the header.
if(frame.size > ARNETWORK_FRAME_HEADER_SIZE)
{
const char *data = datagram.constData();
frame.payload.insert(0, data + offset + ARNETWORK_FRAME_HEADER_SIZE, frame.size - ARNETWORK_FRAME_HEADER_SIZE);
}
// Output comms debug info (if it's not a video data frame).
if(frame.id != ARNET_D2C_VIDEO_DATA_ID)
{
DEBUG_T(QString("<< %1:%2 [%3]")
.arg(remoteAddr.toString())
.arg(remotePort)
.arg(QString(datagram.toHex())));
}
// Process frame depending on buffer id.
if(frame.id == ARNET_D2C_PING_ID)
{
onPing(frame);
}
else if(frame.id == ARNET_D2C_EVENT_ID || frame.id == ARNET_D2C_NAVDATA_ID)
{
onNavdata(frame);
}
else if(frame.id == ARNET_D2C_VIDEO_DATA_ID)
{
onVideoData(frame);
}
else
{
WARNING_T(QString("Unhandled frame id: %1").arg(frame.id));
}
// Increment datagram offset to continue processing next frame.
offset += frame.size;
}
}
}
void Discover::acceptRecords (QList<Record> records, bool removeThem, QString senderScope, QString senderAddress, QString senderPort)
{
// TODO
// This function gets its own copy of records
// This loop edits each item so it can be used after
for (Record& record : records)
{
// Preprocess the record before considering it
Record::decompressReserved(record);
// Set the scope based on the address if included, otherwise scope of sender
QHostAddress recordAddress;
if (record.has("Address")) recordAddress.setAddress(record["Address"]);
if (recordAddress.protocol()!=QAbstractSocket::IPv4Protocol) recordAddress = QHostAddress::Null;
if (recordAddress==QHostAddress::Broadcast) recordAddress = QHostAddress::Null;
if (recordAddress==QHostAddress::AnyIPv4) recordAddress = QHostAddress::Null;
if (recordAddress.isNull())
{
record["Scope"] = senderScope;
}
else
{
if (recordAddress.isLoopback()) record["Scope"] = "Loopback";
else if (addressIsLocal(recordAddress)) record["Scope"] = "Local";
else record["Scope"] = "Global";
}
if (record["Address"].isEmpty()) record["Address"] = senderAddress; // Sender may override these
if (record["Port"].isEmpty()) record["Port"] = senderPort; // Sender may override these
// TODO Extract a custom expiration duration so each record can have its own
if (removeThem)
{
// See if it's new
if (foundRecords.contains(record))
{
logDebug(QString("Record Departed: %1").arg(record.toString()));
foundRecords.remove(record);
emit recordLost(record);
}
}
else
{
// See if it's new
if (not foundRecords.contains(record) and passesFilters(record))
{
logDebug(QString("Found Record: %1").arg(record.toString()));
emit recordFound(record);
}
// Reset the timer
foundRecords[record] = QDateTime::currentMSecsSinceEpoch() + 2500; // Set the expire time
}
expireTimer->start(0); // In case the next expiration time was changed
}
// Server: Forward global departures to other global peers
if (mServerMode and removeThem and senderScope == "Global")
{
QByteArray datagram("DSDD");
datagram += makeDatagram(records, false);
for (Record& record : foundRecords.keys())
if (record["Scope"] == "Global")
{
bool ok;
globalSocket->writeDatagram(datagram, QHostAddress(record["Address"]), record["Port"].toUInt(&ok, 10));
}
}
}
void Discover::announceRecords ()
{
// Reset timer
timer->start(announcePeriodMsec);
if (not running) return;
// Servers don't announce periodically or send departure messages
if (mServerMode) return;
// Start building a list of records to send in each scope
QList<Record> recordsToSend;
///////////////////////////////////////////////////////////////////////
// Global scope first
///////////////////////////////////////////////////////////////////////
for (Record record : ownedRecords)
if (record["Scope"] == "Global")
{
recordsToSend.push_back(record);
}
if (not recordsToSend.empty() or defaultScope=="Global")
{
// This is a discovery request which should be responded to
QByteArray datagram("DSDR");
if (departure) datagram = "DSDD";
datagram += makeDatagram(recordsToSend, false);
// Send to each Global server
for (QPair<QHostAddress,quint16> globalServer : globalServers)
{
globalSocket->writeDatagram(datagram, globalServer.first, globalServer.second);
}
}
///////////////////////////////////////////////////////////////////////
// Local scope next
///////////////////////////////////////////////////////////////////////
for (Record record : ownedRecords)
if (record["Scope"] == "Local")
{
recordsToSend.push_back(record);
}
if (not recordsToSend.empty() or defaultScope=="Global" or defaultScope=="Local")
{
QByteArray datagram("DSDA");
if (announceNeedsResponse) datagram = "DSDR";
if (departure) datagram = "DSDD";
datagram += makeDatagram(recordsToSend, true);
// For each interface
for (auto iface : QNetworkInterface::allInterfaces())
{
// For each IPv4 address on this interface
for (auto entry : iface.addressEntries())
{
if (entry.ip().protocol() != QAbstractSocket::IPv4Protocol) continue;
// Add it to addressEntryCache if necessary for local scope testing
if (not addressEntryCache.contains(entry)) addressEntryCache.push_back(entry);
// Multicast
if (iface.flags().testFlag(QNetworkInterface::CanMulticast) and !entry.ip().isNull() and !entry.ip().isLoopback())
{
// Create the socket if it doesn't exit yet
if (not multiSocket.contains(entry.ip().toString()))
{
logDebug(QString("New multicast socket: %1 %2").arg(entry.ip().toString(), entry.netmask().toString()));
// Add it, create and bind the socket
QUdpSocket* socket = new QUdpSocket(this);
connect(socket, SIGNAL(readyRead()), this, SLOT(readDatagrams()));
socket->setSocketOption(QAbstractSocket::MulticastTtlOption, 1);
if (not socket->bind(QHostAddress::AnyIPv4, port, QAbstractSocket::ShareAddress | QAbstractSocket::ReuseAddressHint))
{
logWarning(QString("Error binding to iface %1: %2").arg(entry.ip().toString(), socket->errorString()));
}
socket->setMulticastInterface(iface);
socket->joinMulticastGroup(groupAddress, iface);
multiSocket.insert(entry.ip().toString(), socket);
}
// Send datagram
multiSocket[entry.ip().toString()]->writeDatagram(datagram, groupAddress, port);
}
}
}
}
///////////////////////////////////////////////////////////////////////
// Loopback scope last
///////////////////////////////////////////////////////////////////////
for (Record record : ownedRecords)
if (record["Scope"] == "Loopback")
{
recordsToSend.push_back(record);
}
if (not recordsToSend.empty() or true) // Any scope is above or equivalent to loopback
{
QByteArray datagram("DSDA");
if (announceNeedsResponse) datagram = "DSDR";
if (departure) datagram = "DSDD";
datagram += makeDatagram(recordsToSend, true);
// Loopback
//loopbackSocket->writeDatagram(datagram, QHostAddress::LocalHost, port);
}
// Reset
announceNeedsResponse = false;
departure = false;
}
void Dialog::sendToSpeaker(char*data,int totalLen)//send via UDP
{
QByteArray datagram(data,totalLen);
udpSocketOut->writeDatagram(datagram.data(), datagram.size(), QHostAddress::LocalHost, 1500);
}
void MainWindow::processDatagrams()
{
const hdr_t *request;
do {
qint64 sz = _udpSocket.pendingDatagramSize();
Q_ASSERT(sz >= (qint64) sizeof(hdr_t));
QByteArray datagram(sz,0);
QByteArray rdatagram;
QHostAddress host;
quint16 port;
bool res;
Q_ASSERT(sz == _udpSocket.readDatagram(datagram.data(), datagram.size(), &host, &port));
request = (hdr_t*) datagram.constData();
Q_ASSERT(datagram.size() == request->pdusz);
// _log << "Req:" << *request << endl;
// skip respons messages
if(request->cmdid >= RDSK_Response)
{
// _log << ", skip" << endl;
continue;
}
QHostInfo hi = QHostInfo::fromName(host.toString());
QString hn(hi.hostName());
QVariant var;
CPMClient* client;
QList<QTreeWidgetItem*> clientitem = ui->treeWidget->findItems(hn,Qt::MatchFixedString);
if(clientitem.isEmpty())
{
client = new CPMClient(hn);
connect(client,SIGNAL(adddrive(CPMClient*,CPMDrive*)),this,SLOT(adddrive(CPMClient*,CPMDrive*)));
var.setValue(client);
QTreeWidgetItem *item = new QTreeWidgetItem(QStringList(hn));
item->setData(0,Qt::UserRole, var);
ui->treeWidget->addTopLevelItem(item);
}
else
{
var = clientitem.first()->data(0,Qt::UserRole);
}
client = qobject_cast<CPMClient*>(qvariant_cast<QObject*>(var));
Q_ASSERT(client);
res = client->req(*request, rdatagram);
hdr_t *response = (hdr_t*)rdatagram.data();
if(!res)
_log << "ERR:" << *response << endl;
sz = _udpSocket.writeDatagram((const char*)response, (qint64)response->pdusz, host, port);
if(_clientwidget)
_clientwidget->update();
Q_ASSERT( sz == response->pdusz);
}while(_udpSocket.hasPendingDatagrams());
