QString connection::Broadcast() { // Om ip adressen te ontdekken QNetworkAddressEntry inter; // sockets aanmaken en verbinden met enerzijds broadcast en anderzijds een luister poort QUdpSocket udpSocketSend; QUdpSocket udpSocketGet; udpSocketSend.connectToHost(inter.broadcast(), 40000); // udpSocketGet->bind(inter->ip(),667); // udpSocketGet->bind(QHostAddress::Any,667) if(udpSocketGet.bind(udpgetport,QUdpSocket::ShareAddress)) Label->setText(Label->text() + "[INFO] Could properly bind udpSocketget to " + QString::number(udpgetport) + "\n"); else Label->setText(Label->text() + "[INFO] Couldn't properly bind udpSocketget to " + QString::number(udpgetport) + "\n"); // Pakket verzenden QByteArray send_datagram = "DISCOVER-STRATEGO-SERVER"; // Optimalisatie voor in de loop QByteArray receive_datagram; quint16 serverPort; forever{ udpSocketSend.writeDatagram(send_datagram, QHostAddress::Broadcast, 40000); if(udpSocketGet.waitForReadyRead(3000)){ receive_datagram.resize(udpSocketGet.pendingDatagramSize()); udpSocketGet.readDatagram(receive_datagram.data(),receive_datagram.size(),&server,&serverPort); if(QString::fromUtf8(receive_datagram.data()) == "DISCOVERED-STRATEGO-SERVER") { receive_datagram.resize(udpSocketGet.pendingDatagramSize()); udpSocketGet.readDatagram(receive_datagram.data(),receive_datagram.size(),&server,&serverPort); Label->setText(Label->text() +"[INFO] PLAYER DATA: "+ receive_datagram.data() +"\n"); speler = receive_datagram.toInt(); if(speler==1) { attacker=true; } else { attacker=false; } receive_datagram.resize(udpSocketGet.pendingDatagramSize()); udpSocketGet.readDatagram(receive_datagram.data(),receive_datagram.size(),&server,&serverPort); Label->setText(Label->text() + "[INFO] GAME DATA: "+receive_datagram.data()+"\n"); spel = receive_datagram.toInt(); Label->setText(Label->text() + " SPEL:" + QString::number(spel) + "\n"); Label->setText(Label->text() + "[INFO] Found STRATEGO-SERVER on " + server.toString().toUtf8().constData() + "\n"); return server.toString(); } } else { Label->setText(Label->text() + "[INFO] UDP Discover TimeOut!\n"); static int timeout=0; timeout++; if(timeout==5) { Label->setText(Label->text() + "[ERROR] Server is not online. Please try again later!"); return ""; } } } return ""; }
void Connection::slReceive() { QUdpSocket* sock = (QUdpSocket*) QObject::sender(); const bool main = (sock->localPort() == sets.portMain) ? true : false; const bool aux = (sock->localPort() == sets.portAux) ? true : false; if (sock->hasPendingDatagrams()) { if (main) emit sgRxMain(); if (aux) emit sgRxAux(); } int size = 0; bool enabled = false; if (main) enabled = sets.main; if (aux) enabled = sets.aux; while (sock->hasPendingDatagrams() && run && enabled) { size = sock->pendingDatagramSize(); convertor->setBufSize(size); sock->readDatagram(convertor->getBuf(), size); if (convertor->convert()) emit sgWr(); else emit sgNoWr(); if (main) timerRxMain->start(); if (aux) timerRxAux->start(); } }
void TestClient::testSendKeyInputPacket(){ Client* client = new Client(NULL); QUdpSocket* socket = new QUdpSocket(); socket->bind(INCOMING_PORT); client->setDirection(1); client->setIsJumping(false); client->setIsLaunching(true); client->sendDatagram(KEY_INPUT_PACKET); QHostAddress *address = NULL; quint16 *port = NULL; QByteArray *datagram = new QByteArray(socket->pendingDatagramSize(), (char) 0); socket->readDatagram(datagram->data(), datagram->size(), address, port); QCOMPARE(datagram->at(0), KEY_INPUT_PACKET); QCOMPARE((int)datagram->at(1), -1); QCOMPARE((int)datagram->at(2), 1); QCOMPARE((bool)datagram->at(3), false); QCOMPARE((bool)datagram->at(4), true); delete socket; }
void MainWindow::controlMessageReceived() { qDebug() << "message received"; QUdpSocket* udpSocket = qobject_cast<QUdpSocket*>(sender()); while (udpSocket->hasPendingDatagrams()) { QByteArray datagram; datagram.resize(udpSocket->pendingDatagramSize()); QHostAddress sender; quint16 senderPort; udpSocket->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort); if (datagram=="left") { drone->moveLeft(); } else if (datagram== "right") { drone->moveRight(); } else if (datagram=="stayx" && datagram=="stayy"){ drone->stay(); } else if (datagram=="up") { drone->higher(); } else if (datagram=="down") { drone->lower(); } else { qDebug() << "invalid command received"; } } }
void OceanSocket::processIncomingWaves() { QUdpSocket* socket = dynamic_cast<QUdpSocket*>(QObject::sender()); while (socket->hasPendingDatagrams()) { QByteArray wave; QHostAddress host; wave.resize(socket->pendingDatagramSize()); socket->readDatagram(wave.data(), wave.size(), &host); for (int i = 0; i < boundAddresses.count(); i++) { if (host == boundAddresses.at(i)) // skip processing since this is our own packet return; } if (wave.startsWith(NET_OCEAN_HEARTBEAT)) emit shipHeartbeat(host, wave.mid(1).data()); else if (wave.startsWith(NET_OCEAN_COURSE_CHANGE)) emit shipChangedCourse(host, wave.mid(1).data()); else if (wave.startsWith(NET_OCEAN_RETURN_TO_PORT)) emit shipDocked(host, wave.mid(1).data()); else if (wave.startsWith(NET_OCEAN_ADMIN_LOCK_REQ)) emit adminLockRequested(host, wave.mid(1).data()); else if (wave.startsWith(NET_OCEAN_ADMIN_LOCK_RESP)) emit adminLockRequestReponse(host, (atoi(wave.mid(1,1).data()) == NET_OCEAN_ACKNOWLEDGE), wave.mid(2).data()); else if (wave.startsWith(NET_OCEAN_MESSAGE)) this->processMessage(host, wave.mid(1).data()); else if (wave.startsWith(NET_OCEAN_SAIL)) emit shipSailed(host, wave.mid(1).data()); } }
void AudioReceiver::readPendingAudioRcvrData() { QUdpSocket *socket = qobject_cast<QUdpSocket *>(sender()); while (socket->hasPendingDatagrams()) { m_datagram.resize(socket->pendingDatagramSize()); if (socket->readDatagram(m_datagram.data(), m_datagram.size()) < 0) { AUDIO_RECEIVER << "read client" << m_client << "socket failed."; if (io->rcveIQ_toggle) { // toggles the rcveIQ signal emit rcveIQEvent(this, 2); io->rcveIQ_toggle = false; } } else { io->au_queue.enqueue(m_datagram); if (!io->rcveIQ_toggle) { // toggles the rcveIQ signal emit rcveIQEvent(this, 1); io->rcveIQ_toggle = true; } } } }
void SocketTestWindow::readyReadMessage() { if(m_tcpEnable) { QByteArray data = m_socketClient->readAll(); QString rd = data; // char logbuf[BUFSIZ] = {0}; // sprintf(logbuf,"receive data from %s:%d %s",) // QLogProvider::getLog()->log(logbuf); ui->m_teRecvData->setText(rd); } else { QUdpSocket* udpSocket = dynamic_cast<QUdpSocket*>(m_socketClient); while (udpSocket->hasPendingDatagrams()) { QByteArray datagram; datagram.resize(udpSocket->pendingDatagramSize()); udpSocket->readDatagram(datagram.data(), datagram.size(), &m_remoteHost, &m_remotePort); char logbuf[BUFSIZ] = {0}; sprintf(logbuf,"receive datagram from %s:%d",m_remoteHost.toString().toStdString().c_str(),m_remotePort); ui->m_teRecvData->setText(datagram); QLogProvider::getLog()->log(logbuf); } } }
void StunClient::onStunReadyRead() { QUdpSocket *sock = (QUdpSocket*)(sender()); qDebug()<<""<<sock; u08bits rbuf[STUN_BUFFER_SIZE]; while (sock->hasPendingDatagrams()) { QByteArray datagram; datagram.resize(sock->pendingDatagramSize()); QHostAddress sender; quint16 senderPort; sock->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort); { m_sending_udp = false; m_sending_timer->stop(); } qDebug()<<"read: "<<sender<<senderPort<<datagram.length()<<datagram.toHex().left(20)<<"..."; for (int i = 0; i < datagram.length(); i ++) { char c = datagram.at(i); fprintf(stderr, "%c", isprint(c) ? c : '.'); if (i > 375) break; } fprintf(stderr, " ...]\n"); this->processResponse(datagram, QString("%1:%2").arg(sender.toString()).arg(senderPort)); // processTheDatagram(datagram); } }
void ICServer::processPendingDatagrams() { QByteArray datagram; QUdpSocket *socket = isRunning ? udpSocket : testUdpSocket; do { QHostAddress *address = new QHostAddress; datagram.resize(socket->pendingDatagramSize()); socket->readDatagram(datagram.data(), datagram.size(), address); ICMessageHandler *messageHandler = new ICMessageHandler(this); connect(messageHandler, SIGNAL(connectionOffer(QString)), this, SLOT(processSidCollision(QString))); connect(messageHandler, SIGNAL(serverDiscovery(QHostAddress,QString)), this, SLOT(processDiscovery(QHostAddress,QString))); connect(messageHandler, SIGNAL(questionRequest(QHostAddress)), this, SLOT(processRequest(QHostAddress))); connect(messageHandler, SIGNAL(answerReady(ICAnswer,QString)), this, SLOT(processAnswer(ICAnswer,QString))); ICMessageProcessor *processor = new ICMessageProcessor(messageHandler, *address, datagram); QThreadPool::globalInstance()->start(processor); qDebug()<< "[1] Received from " << *address << datagram; delete address; } while (socket->hasPendingDatagrams()); }
void UdpRelay::onClientUdpSocketReadyRead() { QUdpSocket *sock = qobject_cast<QUdpSocket *>(sender()); if (!sock) { emit info("Fatal. A false object calling onClientUdpSocketReadyRead."); return; } if (sock->pendingDatagramSize() > RecvSize) { emit info("[UDP] Datagram is too large. Discarded."); return; } QByteArray data; data.resize(sock->pendingDatagramSize()); QHostAddress r_addr; quint16 r_port; sock->readDatagram(data.data(), RecvSize, &r_addr, &r_port); QByteArray response; if (isLocal) { data = encryptor->decryptAll(data); Address destAddr; int header_length = 0; bool _auth; Common::parseHeader(data, destAddr, header_length, _auth); if (header_length == 0) { emit info("[UDP] Can't parse header. " "Wrong encryption method or password?"); return; } response = QByteArray(3, static_cast<char>(0)) + data; } else { data.prepend(Common::packAddress(r_addr, r_port)); response = encryptor->encryptAll(data); } Address clientAddress = cache.key(sock); if (clientAddress.getPort() != 0) { listenSocket.writeDatagram(response, clientAddress.getFirstIP(), clientAddress.getPort()); } else { emit debug("[UDP] Drop a packet from somewhere else we know."); } }
void tst_QUdpSocket::pendingDatagramSize() { QUdpSocket server; QVERIFY2(server.bind(), server.errorString().toLatin1().constData()); QHostAddress serverAddress = QHostAddress::LocalHost; if (!(server.localAddress() == QHostAddress::Any)) serverAddress = server.localAddress(); QUdpSocket client; QVERIFY(client.writeDatagram("this is", 7, serverAddress, server.localPort()) == 7); QVERIFY(client.writeDatagram(0, 0, serverAddress, server.localPort()) == 0); QVERIFY(client.writeDatagram("3 messages", 10, serverAddress, server.localPort()) == 10); char c = 0; QVERIFY(server.waitForReadyRead()); if (server.hasPendingDatagrams()) { #if defined Q_OS_HPUX && defined __ia64 QEXPECT_FAIL("", "HP-UX 11i v2 can't determine the datagram size correctly.", Abort); #endif QCOMPARE(server.pendingDatagramSize(), qint64(7)); c = '\0'; QCOMPARE(server.readDatagram(&c, 1), qint64(1)); QCOMPARE(c, 't'); c = '\0'; } else { QSKIP("does not have the 1st datagram", SkipSingle); } if (server.hasPendingDatagrams()) { QCOMPARE(server.pendingDatagramSize(), qint64(0)); QCOMPARE(server.readDatagram(&c, 1), qint64(0)); QCOMPARE(c, '\0'); // untouched c = '\0'; } else { QSKIP("does not have the 2nd datagram", SkipSingle); } if (server.hasPendingDatagrams()) { QCOMPARE(server.pendingDatagramSize(), qint64(10)); QCOMPARE(server.readDatagram(&c, 1), qint64(1)); QCOMPARE(c, '3'); } else { QSKIP("does not have the 3rd datagram", SkipSingle); } }
void CNetwork::DataMayRead( ) { QByteArray byData; QUdpSocket* udpServer = qobject_cast< QUdpSocket* > ( sender( ) ); while ( udpServer->hasPendingDatagrams( ) ) { byData.resize( udpServer->pendingDatagramSize( ) ); udpServer->readDatagram( byData.data( ), byData.size( ) ); ProcessData( byData ); } }
void tst_QUdpSocket::broadcasting() { QFETCH_GLOBAL(bool, setProxy); if (setProxy) { #ifdef TEST_QNETWORK_PROXY QFETCH_GLOBAL(int, proxyType); if (proxyType == QNetworkProxy::Socks5Proxy) { QSKIP("With socks5 Broadcast is not supported.", SkipAll); } #endif } #ifdef Q_OS_AIX QSKIP("Broadcast does not work on darko", SkipAll); #endif const char *message[] = {"Yo mista", "", "Yo", "Wassap"}; for (int i = 0; i < 4; ++i) { QUdpSocket serverSocket; QVERIFY2(serverSocket.bind(QHostAddress::Any, 5000), serverSocket.errorString().toLatin1().constData()); QCOMPARE(serverSocket.state(), QUdpSocket::BoundState); connect(&serverSocket, SIGNAL(readyRead()), SLOT(empty_readyReadSlot())); QUdpSocket broadcastSocket; for (int j = 0; j < 100; ++j) { broadcastSocket.writeDatagram(message[i], strlen(message[i]), QHostAddress::Broadcast, 5000); QTestEventLoop::instance().enterLoop(15); if (QTestEventLoop::instance().timeout()) { #if defined(Q_OS_FREEBSD) QEXPECT_FAIL("", "Broadcasting to 255.255.255.255 does not work on FreeBSD", Abort); QVERIFY(false); // seems that QFAIL() doesn't respect the QEXPECT_FAIL() :/ #endif QFAIL("Network operation timed out"); } QVERIFY(serverSocket.hasPendingDatagrams()); do { QByteArray arr; arr.resize(serverSocket.pendingDatagramSize() + 1); QHostAddress host; quint16 port; QCOMPARE((int) serverSocket.readDatagram(arr.data(), arr.size() - 1, &host, &port), (int) strlen(message[i])); arr.resize(strlen(message[i])); QCOMPARE(arr, QByteArray(message[i])); } while (serverSocket.hasPendingDatagrams()); } } }
void ServerSktUdp::newData() { QUdpSocket* s = qobject_cast<QUdpSocket*>(sender()); if (!s) return; qint64 bufLen = s->pendingDatagramSize(); char* buf = TK::createBuffer(bufLen, MAXBUFFER); if (!buf) return; QHostAddress addr; quint16 port(0); qint64 readLen = 0; qint64 ioLen = s->readDatagram(buf, bufLen, &addr, &port); //while (ioLen > 0) //{ readLen += ioLen; // ioLen = s->readDatagram(buf+readLen, bufLen-readLen, &addr, &port); //} if (ioLen >= 0) { Conn* conn = (Conn*)getCookie(TK::ipstr(addr, port, false)); if (!conn) { conn = new Conn; if (conn) { conn->key = TK::ipstr(addr, port, false); conn->addr = addr; conn->port = port; setCookie(conn->key, conn); } } if (conn) { recordRecv(readLen); conn->stamp = QDateTime::currentDateTime(); dump(buf, readLen, false, conn->key); } } TK::releaseBuffer(buf); }
void ServerPool::newUdpDatagram(void) { QUdpSocket *socket = dynamic_cast<QUdpSocket*>(sender()); while (socket->state() == QAbstractSocket::BoundState && socket->hasPendingDatagrams()) { QByteArray buffer; buffer.resize(socket->pendingDatagramSize()); QHostAddress sender; quint16 senderPort; socket->readDatagram(buffer.data(), buffer.size(), &sender, &senderPort); emit newDatagram(buffer, sender, senderPort); } }
void tst_QUdpSocket::writeToNonExistingPeer() { QSKIP("Connected-mode UDP sockets and their behaviour are erratic", SkipAll); QFETCH(QHostAddress, peerAddress); quint16 peerPort = 34534; qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError"); QUdpSocket sConnected; QSignalSpy sConnectedReadyReadSpy(&sConnected, SIGNAL(readyRead())); QSignalSpy sConnectedErrorSpy(&sConnected, SIGNAL(error(QAbstractSocket::SocketError))); sConnected.connectToHost(peerAddress, peerPort, QIODevice::ReadWrite); // the first write succeeds... QCOMPARE(sConnected.write("", 1), qint64(1)); // the second one should fail! QTest::qSleep(1000); // do not process events QCOMPARE(sConnected.write("", 1), qint64(-1)); QCOMPARE(int(sConnected.error()), int(QUdpSocket::ConnectionRefusedError)); // the third one will succeed... QCOMPARE(sConnected.write("", 1), qint64(1)); QTestEventLoop::instance().enterLoop(1); QCOMPARE(sConnectedReadyReadSpy.count(), 0); QCOMPARE(sConnectedErrorSpy.count(), 1); QCOMPARE(int(sConnected.error()), int(QUdpSocket::ConnectionRefusedError)); // we should now get a read error QCOMPARE(sConnected.write("", 1), qint64(1)); QTest::qSleep(1000); // do not process events char buf[2]; QVERIFY(!sConnected.hasPendingDatagrams()); QCOMPARE(sConnected.bytesAvailable(), Q_INT64_C(0)); QCOMPARE(sConnected.pendingDatagramSize(), Q_INT64_C(-1)); QCOMPARE(sConnected.readDatagram(buf, 2), Q_INT64_C(-1)); QCOMPARE(int(sConnected.error()), int(QUdpSocket::ConnectionRefusedError)); QCOMPARE(sConnected.write("", 1), qint64(1)); QTest::qSleep(1000); // do not process events QCOMPARE(sConnected.read(buf, 2), Q_INT64_C(0)); QCOMPARE(int(sConnected.error()), int(QUdpSocket::ConnectionRefusedError)); // we should still be connected QCOMPARE(int(sConnected.state()), int(QUdpSocket::ConnectedState)); }
bool CQMedia::loadURL(const QString& url) { QString tmp = url; tmp.remove(0,6); QString ip = tmp.split(QChar(':'))[0]; int port = tmp.split(QChar(':'))[1].toInt(); QUdpSocket udp; udp.bind(port,QUdpSocket::ShareAddress); udp.joinMulticastGroup(QHostAddress(ip)); QEventLoop q; QTimer::singleShot(1000,&q,SLOT(quit())); connect(&udp,SIGNAL(readyRead()),&q,SLOT(quit())); q.exec(); if(udp.pendingDatagramSize() == -1) { //qDebug("has no avalid datapkg..."); QTimer::singleShot(3500,this,SLOT(_emitTimeout())); return false; } qDebug("has avalid datapkg..."); udp.leaveMulticastGroup(QHostAddress(ip)); udp.close(); this->url = url; // SdpsrcParser sdpSrc(url); // if(!sdpSrc.isValid()) // { // qDebug()<<"SdpsrcParser invalid!!"; // return false; // } // sdpSrc.printf(); GstElement *udpsrc = gst_bin_get_by_name(GST_BIN(pipeline),"udpsrc"); GstCaps *caps = gst_caps_new_simple("application/x-rtp",NULL); //QString uri = "udp://"+sdpSrc.broadcastIP+":"+QString::number(sdpSrc.v_port); // QString uri = "udp://"+sdpSrc.broadcastIP+":"+QString::number(sdpSrc.v_port); // QString uri = "udp://239.255.42.42:1234"; QString uri = url; g_object_set(G_OBJECT(udpsrc),"uri",uri.toUtf8().data(),"caps",caps,NULL); gst_object_unref(udpsrc); return true; }
void tst_QUdpSocket::writeDatagram() { QUdpSocket server; QVERIFY2(server.bind(), server.errorString().toLatin1().constData()); QHostAddress serverAddress = QHostAddress::LocalHost; if (!(server.localAddress() == QHostAddress::Any)) serverAddress = server.localAddress(); QUdpSocket client; qRegisterMetaType<qint64>("qint64"); qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError"); for(int i=0;; i++) { QSignalSpy errorspy(&client, SIGNAL(error(QAbstractSocket::SocketError))); QSignalSpy bytesspy(&client, SIGNAL(bytesWritten(qint64))); qint64 written = client.writeDatagram(QByteArray(i * 1024, 'w'), serverAddress, server.localPort()); if (written != i * 1024) { #if defined (Q_OS_HPUX) QSKIP("HP-UX 11.11 on hai (PA-RISC 64) truncates too long datagrams.", SkipSingle); #endif QCOMPARE(bytesspy.count(), 0); QCOMPARE(errorspy.count(), 1); QCOMPARE(*static_cast<const int *>(errorspy.at(0).at(0).constData()), int(QUdpSocket::DatagramTooLargeError)); QCOMPARE(client.error(), QUdpSocket::DatagramTooLargeError); break; } QVERIFY(bytesspy.count() == 1); QCOMPARE(*static_cast<const qint64 *>(bytesspy.at(0).at(0).constData()), qint64(i * 1024)); QCOMPARE(errorspy.count(), 0); if (!server.waitForReadyRead(5000)) QSKIP(QString("UDP packet lost at size %1, unable to complete the test.").arg(i * 1024).toLatin1().data(), SkipSingle); QCOMPARE(server.pendingDatagramSize(), qint64(i * 1024)); QCOMPARE(server.readDatagram(0, 0), qint64(0)); } }
void TestClient::testSendHelloPacket(){ Client* client = new Client(NULL); QUdpSocket* socket = new QUdpSocket(); socket->bind(INCOMING_PORT); client->sendDatagram(HELLO_PACKET); QHostAddress *address = NULL; quint16 *port = NULL; QByteArray *datagram = new QByteArray(socket->pendingDatagramSize(), (char) 0); socket->readDatagram(datagram->data(), datagram->size(), address, port); QCOMPARE(datagram->at(0), HELLO_PACKET); delete socket; }
void RemoteInterfaceListener::run() { // Init socket stopRequested = false; QUdpSocket socket; if(!socket.bind(QHostAddress(server->ip), server->port, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint)) { // Show error Debug::print("[RemoteInterfaceListener] could not bind"); stopRequested = true; } // Enter processing loop... while (stopRequested == false) { // Process all pending datagrams while(socket.hasPendingDatagrams() && !stopRequested) { // Get the data from socket QByteArray data; data.resize(socket.pendingDatagramSize()); QHostAddress sender; quint16 senderPort; socket.readDatagram(data.data(), data.size(), &sender, &senderPort); // Extract message and keep track of the pointer in the server RemoteInterfaceMessage *message = new RemoteInterfaceMessage(&data); message->sourceIp = sender.toString(); message->sourcePort = senderPort; message->destinationIp = server->ip; message->destinationPort = server->port; server->messages->append(message); // Show reception and pass on for processing... Debug::print("[RemoteInterfaceListener] received %1 message from %2:%3", message->type, sender.toString(), senderPort); server->processMessage(message); } // Sleep wait QThread::msleep(core->intSetting("RemoteInterface_ListenerInterval")); } }
void ExitTunnel::UdpReadFromProxy() { if(!_running) { qDebug("SOCKS UDP read but not running"); return; } QUdpSocket* socket = qobject_cast<QUdpSocket*>(sender()); if(!socket) { qWarning("SOCKS Illegal call to UDP ReadFromClient()"); return; } if(!CheckSession()) { qDebug("SOCKS read but no session"); return; } // Restart the timeout timer _timers[socket]->start(); QHostAddress peer; quint16 peer_port; QByteArray datagram; while(socket->hasPendingDatagrams()) { datagram.resize(socket->pendingDatagramSize()); quint64 bytes = socket->readDatagram(datagram.data(), datagram.size(), &peer, &peer_port); qDebug() << "SOCKS UDP read bytes:" << bytes; if(bytes != static_cast<quint64>(datagram.size())) { qWarning() << "SOCKS UDP invalid dgram read. Got:" << bytes << "Expected:" << datagram.size(); continue; } SendReply(UdpResponsePacket(_table.IdForConnection(socket), SocksHostAddress(peer, peer_port), datagram).ToByteArray()); } qDebug() << "MEM active" << _table.Count(); }
void TestClient::testSendLevelIDPacket(){ Client* client = new Client(NULL); QUdpSocket* socket = new QUdpSocket(); socket->bind(INCOMING_PORT); client->setLevelID(1); client->sendDatagram(LEVEL_ID_PACKET); QHostAddress *address = NULL; quint16 *port = NULL; QByteArray *datagram = new QByteArray(socket->pendingDatagramSize(), (char) 0); socket->readDatagram(datagram->data(), datagram->size(), address, port); QCOMPARE(datagram->at(0), LEVEL_ID_PACKET); QCOMPARE((int)datagram->at(1), -1); QCOMPARE((int)datagram->at(2), 1); delete socket; }
int Discoverer::findHPSDRDevices() { int devicesFound = 0; m_findDatagram.resize(63); m_findDatagram[0] = (char)0xEF; m_findDatagram[1] = (char)0xFE; m_findDatagram[2] = (char)0x02; for (int i = 3; i < 63; i++) m_findDatagram[i] = (char)0x00; QUdpSocket socket; CHECKED_CONNECT( &socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(displayDiscoverySocketError(QAbstractSocket::SocketError))); io->networkIOMutex.lock(); DISCOVERER_DEBUG << "using " << qPrintable(QHostAddress(set->getHPSDRDeviceLocalAddr()).toString()) << " for discovery."; io->networkIOMutex.unlock(); // clear comboBox entries in the network dialogue set->clearNetworkIOComboBoxEntry(); #if defined(Q_OS_WIN32) if (socket.bind( QHostAddress(set->getHPSDRDeviceLocalAddr()), 0, QUdpSocket::ReuseAddressHint | QUdpSocket::ShareAddress)) //QUdpSocket::ReuseAddressHint)) { set->setMetisPort(this, socket.localPort()); io->networkIOMutex.lock(); DISCOVERER_DEBUG << "discovery_socket bound successfully to port " << socket.localPort(); io->networkIOMutex.unlock(); } else { io->networkIOMutex.lock(); DISCOVERER_DEBUG << "discovery_socket bind failed."; io->networkIOMutex.unlock(); socket.close(); return 0; } #elif defined(Q_OS_LINUX) if (socket.bind( QHostAddress(set->getHPSDRDeviceLocalAddr()), QUdpSocket::DefaultForPlatform)) { CHECKED_CONNECT( &socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(displayDiscoverySocketError(QAbstractSocket::SocketError))); set->setMetisPort(this, socket.localPort()); io->networkIOMutex.lock(); DISCOVERER_DEBUG << "discovery_socket bound successfully to port " << socket.localPort(); io->networkIOMutex.unlock(); } else { io->networkIOMutex.lock(); DISCOVERER_DEBUG << "discovery_socket bind failed."; io->networkIOMutex.unlock(); socket.close(); return 0; } #endif if (socket.writeDatagram(m_findDatagram, QHostAddress::Broadcast, DEVICE_PORT) == 63) { io->networkIOMutex.lock(); DISCOVERER_DEBUG << "discovery data sent."; io->networkIOMutex.unlock(); } else { io->networkIOMutex.lock(); DISCOVERER_DEBUG << "discovery data not sent."; io->networkIOMutex.unlock(); } // wait a little //SleeperThread::msleep(30); SleeperThread::msleep(500); while (socket.hasPendingDatagrams()) { TNetworkDevicecard mc; quint16 port; m_deviceDatagram.resize(socket.pendingDatagramSize()); socket.readDatagram(m_deviceDatagram.data(), m_deviceDatagram.size(), &mc.ip_address, &port); if (m_deviceDatagram[0] == (char)0xEF && m_deviceDatagram[1] == (char)0xFE) { if (m_deviceDatagram[2] == (char)0x02) { sprintf(mc.mac_address, "%02X:%02X:%02X:%02X:%02X:%02X", m_deviceDatagram[3] & 0xFF, m_deviceDatagram[4] & 0xFF, m_deviceDatagram[5] & 0xFF, m_deviceDatagram[6] & 0xFF, m_deviceDatagram[7] & 0xFF, m_deviceDatagram[8] & 0xFF); io->networkIOMutex.lock(); DISCOVERER_DEBUG << "Device found at " << qPrintable(mc.ip_address.toString()) << ":" << port << "; Mac addr: [" << mc.mac_address << "]"; DISCOVERER_DEBUG << "Device code version: " << qPrintable(QString::number(m_deviceDatagram.at(9), 16)); io->networkIOMutex.unlock(); int no = m_deviceDatagram.at(10); QString str; if (no == 0) str = "Metis"; else if (no == 1) str = "Hermes"; else if (no == 2) str = "Griffin"; else if (no == 4) str = "Angelia"; mc.boardID = no; mc.boardName = str; io->networkIOMutex.lock(); DISCOVERER_DEBUG << "Device board ID: " << no; DISCOVERER_DEBUG << "Device is: " << qPrintable(str); io->networkIOMutex.unlock(); m_deviceCards.append(mc); str += " ("; str += mc.ip_address.toString(); str += ")"; set->addNetworkIOComboBoxEntry(str); devicesFound++; } else if (m_deviceDatagram[2] == (char)0x03) { io->networkIOMutex.lock(); DISCOVERER_DEBUG << "Device already sending data!"; io->networkIOMutex.unlock(); } } } set->setMetisCardList(m_deviceCards); if (devicesFound == 1) { set->setCurrentHPSDRDevice(m_deviceCards.at(0)); io->networkIOMutex.lock(); DISCOVERER_DEBUG << "Device selected: " << qPrintable(m_deviceCards.at(0).ip_address.toString()); io->networkIOMutex.unlock(); } socket.close(); return devicesFound; }
int main(int argc, char *argv[]) { int debugMode = DEBUGMODE; if(debugMode) { } else { qInstallMessageHandler(myMessageOutputDisable); } QDEBUG() << "number of arguments:" << argc; QStringList args; QDEBUGVAR(RAND_MAX); if(argc > 1) { QCoreApplication a(argc, argv); args = a.arguments(); QDEBUGVAR(args); qRegisterMetaType<Packet>(); QDEBUG() << "Running command line mode."; Packet sendPacket; sendPacket.init(); QString outBuilder; QTextStream o(&outBuilder); QTextStream out(stdout); QDate vDate = QDate::fromString(QString(__DATE__).simplified(), "MMM d yyyy"); QCoreApplication::setApplicationName("Packet Sender"); QCoreApplication::setApplicationVersion("version " + vDate.toString("yyyy-MM-dd")); QCommandLineParser parser; parser.setApplicationDescription("Packet Sender is a Network TCP and UDP Test Utility by Dan Nagle\nSee http://PacketSender.com/ for more information."); parser.addHelpOption(); parser.addVersionOption(); // A boolean option with a single name (-p) QCommandLineOption quietOption(QStringList() << "q" << "quiet", "Quiet mode. Only output received data."); parser.addOption(quietOption); QCommandLineOption hexOption(QStringList() << "x" << "hex", "Parse data as hex (default)."); parser.addOption(hexOption); QCommandLineOption asciiOption(QStringList() << "a" << "ascii", "Parse data as mixed-ascii (like the GUI)."); parser.addOption(asciiOption); QCommandLineOption pureAsciiOption(QStringList() << "A" << "ASCII", "Parse data as pure ascii (no \\xx translation)."); parser.addOption(pureAsciiOption); // An option with a value QCommandLineOption waitOption(QStringList() << "w" << "wait", "Wait up to <milliseconds> for a response after sending. Zero means do not wait (Default).", "milliseconds"); parser.addOption(waitOption); // An option with a value QCommandLineOption fileOption(QStringList() << "f" << "file", "Send contents of specified path. Max 1024 for UDP, 10 MiB for TCP.", "path"); parser.addOption(fileOption); // An option with a value QCommandLineOption bindPortOption(QStringList() << "b" << "bind", "Bind port. Default is 0 (dynamic).", "port"); parser.addOption(bindPortOption); QCommandLineOption tcpOption(QStringList() << "t" << "tcp", "Send TCP (default)."); parser.addOption(tcpOption); // A boolean option with multiple names (-f, --force) QCommandLineOption udpOption(QStringList() << "u" << "udp", "Send UDP."); parser.addOption(udpOption); // An option with a value QCommandLineOption nameOption(QStringList() << "n" << "name", "Send previously saved packet named <name>. Other options overrides saved packet parameters.", "name"); parser.addOption(nameOption); parser.addPositionalArgument("address", "Destination address. Optional for saved packet."); parser.addPositionalArgument("port", "Destination port. Optional for saved packet."); parser.addPositionalArgument("data", "Data to send. Optional for saved packet."); // Process the actual command line arguments given by the user parser.process(a); const QStringList args = parser.positionalArguments(); bool quiet = parser.isSet(quietOption); bool hex = parser.isSet(hexOption); bool mixedascii = parser.isSet(asciiOption); bool ascii = parser.isSet(pureAsciiOption); unsigned int wait = parser.value(waitOption).toUInt(); unsigned int bind = parser.value(bindPortOption).toUInt(); bool tcp = parser.isSet(tcpOption); bool udp = parser.isSet(udpOption); bool ipv6 = false; QString name = parser.value(nameOption); QString filePath = parser.value(fileOption); QString address = ""; unsigned int port = 0; int argssize = args.size(); QString data, dataString; data.clear(); dataString.clear(); if(argssize >= 1) { address = args[0]; } if(argssize >= 2) { port = args[1].toUInt(); } if(argssize >= 3) { data = (args[2]); } //check for invalid options.. if(argssize > 3) { OUTIF() << "Warning: Extra parameters detected. Try surrounding your data with quotes."; } if(hex && mixedascii) { OUTIF() << "Warning: both hex and pure ascii set. Defaulting to hex."; mixedascii = false; } if(hex && ascii) { OUTIF() << "Warning: both hex and pure ascii set. Defaulting to hex."; ascii = false; } if(mixedascii && ascii) { OUTIF() << "Warning: both mixed ascii and pure ascii set. Defaulting to pure ascii."; mixedascii = false; } if(tcp && udp) { OUTIF() << "Warning: both TCP and UDP set. Defaulting to TCP."; udp = false; } if(!filePath.isEmpty() && !QFile::exists(filePath)) { OUTIF() << "Error: specified path "<< filePath <<" does not exist."; filePath.clear(); OUTPUT(); return -1; } //bind is now default 0 if(!bind && parser.isSet(bindPortOption)) { OUTIF() << "Warning: Binding to port zero is dynamic."; } if(!port && name.isEmpty()) { OUTIF() << "Warning: Sending to port zero."; } //set default choices if(!hex && !ascii && !mixedascii) { hex = true; } if(!tcp && !udp) { tcp = true; } //Create the packet to send. if(!name.isEmpty()) { sendPacket = Packet::fetchFromDB(name); if(sendPacket.name.isEmpty()) { OUTIF() << "Error: Saved packet \""<< name <<"\" not found."; OUTPUT(); return -1; } else { if(data.isEmpty()) { data = sendPacket.hexString; hex = true; ascii = false; mixedascii = false; } if(!port) { port = sendPacket.port; } if(address.isEmpty()) { address = sendPacket.toIP; } if(!parser.isSet(tcpOption) && !parser.isSet(udpOption)) { if(sendPacket.tcpOrUdp.toUpper() == "TCP") { tcp=true; udp = false; } else { tcp=false; udp = true; } } } } if(!parser.isSet(bindPortOption)) { bind = 0; } if(!filePath.isEmpty() && QFile::exists(filePath)) { QFile dataFile(filePath); if(dataFile.open(QFile::ReadOnly)) { if(tcp) { QByteArray dataArray = dataFile.read(1024*1024*10);; dataString = Packet::byteArrayToHex(dataArray); } else { QByteArray dataArray = dataFile.read(1024); dataString = Packet::byteArrayToHex(dataArray); } //data format is raw. ascii = 0; hex = 0; mixedascii = 0; } } QDEBUGVAR(argssize); QDEBUGVAR(quiet); QDEBUGVAR(hex); QDEBUGVAR(mixedascii); QDEBUGVAR(ascii); QDEBUGVAR(address); QDEBUGVAR(port); QDEBUGVAR(wait); QDEBUGVAR(bind); QDEBUGVAR(tcp); QDEBUGVAR(udp); QDEBUGVAR(name); QDEBUGVAR(data); QDEBUGVAR(filePath); //NOW LETS DO THIS! if(ascii) { //pure ascii dataString = Packet::byteArrayToHex(data.toLatin1()); } if(hex) { //hex dataString = Packet::byteArrayToHex(Packet::HEXtoByteArray(data)); } if(mixedascii) { //mixed ascii dataString = Packet::ASCIITohex(data); } if(dataString.isEmpty()) { OUTIF() << "Warning: No data to send. Is your formatting correct?"; } QHostAddress addy; if(!addy.setAddress(address)) { QHostInfo info = QHostInfo::fromName(address); if (info.error() != QHostInfo::NoError) { OUTIF() << "Error: Could not resolve address:" + address; OUTPUT(); return -1; } else { addy = info.addresses().at(0); address = addy.toString(); } } QHostAddress theAddress(address); if (QAbstractSocket::IPv6Protocol == theAddress.protocol()) { QDEBUG() << "Valid IPv6 address."; ipv6 = true; } QByteArray sendData = sendPacket.HEXtoByteArray(dataString); QByteArray recvData; recvData.clear(); int bytesWriten = 0; int bytesRead = 0; if(tcp) { QTcpSocket sock; if(ipv6) { sock.bind(QHostAddress::AnyIPv6, bind); } else { sock.bind(QHostAddress::AnyIPv4, bind); } sock.connectToHost(addy, port); sock.waitForConnected(1000); if(sock.state() == QAbstractSocket::ConnectedState) { OUTIF() << "TCP (" <<sock.localPort() <<")://" << address << ":" << port << " " << dataString; bytesWriten = sock.write(sendData); sock.waitForBytesWritten(1000); //OUTIF() << "Sent:" << Packet::byteArrayToHex(sendData); if(wait) { sock.waitForReadyRead(wait); recvData = sock.readAll(); bytesRead = recvData.size(); QString hexString = Packet::byteArrayToHex(recvData); if(quiet) { o << "\n" << hexString; } else { o << "\nResponse Time:" << QDateTime::currentDateTime().toString(DATETIMEFORMAT); o << "\nResponse HEX:" << hexString; o << "\nResponse ASCII:" << Packet::hexToASCII(hexString); } } sock.disconnectFromHost(); sock.waitForDisconnected(1000); sock.close(); OUTPUT(); return bytesWriten; } else { OUTIF() << "Error: Failed to connect to " << address; OUTPUT(); return -1; } } else { QUdpSocket sock; if(ipv6) { if(!sock.bind(QHostAddress::AnyIPv6, bind)) { OUTIF() << "Error: Could not bind to " << bind; OUTPUT(); return -1; } } else { if(!sock.bind(QHostAddress::AnyIPv4, bind)) { OUTIF() << "Error: Could not bind to " << bind; OUTPUT(); return -1; } } OUTIF() << "UDP (" <<sock.localPort() <<")://" << address << ":" << port << " " << dataString; bytesWriten = sock.writeDatagram(sendData, addy, port); //OUTIF() << "Wrote " << bytesWriten << " bytes"; sock.waitForBytesWritten(1000); if(wait) { sock.waitForReadyRead(wait); if(sock.hasPendingDatagrams()) { QHostAddress sender; quint16 senderPort; recvData.resize(sock.pendingDatagramSize()); sock.readDatagram(recvData.data(), recvData.size(), &sender, &senderPort); QString hexString = Packet::byteArrayToHex(recvData); if(quiet) { o << "\n" << hexString; } else { o << "\nResponse Time:" << QDateTime::currentDateTime().toString(DATETIMEFORMAT); o << "\nResponse HEX:" << hexString; o << "\nResponse ASCII:" << Packet::hexToASCII(hexString); } } } sock.close(); OUTPUT(); return bytesWriten; } OUTPUT(); } else { QApplication a(argc, argv); QDEBUGVAR(args); qRegisterMetaType<Packet>(); QFile file(":/packetsender.css"); if(file.open(QFile::ReadOnly)) { QString StyleSheet = QLatin1String(file.readAll()); // qDebug() << "stylesheet: " << StyleSheet; a.setStyleSheet(StyleSheet); } MainWindow w; w.show(); return a.exec(); } return 0; }
void MainWindow::processData() { int cnt = 0; while (m_udp.hasPendingDatagrams()) { QByteArray datagram; datagram.resize(m_udp.pendingDatagramSize()); QHostAddress sender; quint16 senderPort; m_udp.readDatagram(datagram.data(), datagram.size(), &sender, &senderPort); quint32 size = *(quint32*)datagram.data(); QByteArray data = qUncompress(datagram); char *udpData = (char*)data.data(); switch (udpData[0]) { case TYPE_SENSORS: processSensorsData((TUdpDataSENSORS*)udpData); break; case TYPE_PLAYER: { TUdpDataPLAYER *d = (TUdpDataPLAYER*)udpData; for (int i = 0; i < 8; i++) { float x = d->frustumPoints[i][0]; float y = d->frustumPoints[i][1]; float z = d->frustumPoints[i][2]; m_pdaData.frustum[i] = QVector3D(x, y, z); } QByteArray b(udpData + sizeof(TUdpDataPLAYER), data.size()); QDataStream ds(b); ds.setByteOrder(QDataStream::LittleEndian); ds.setFloatingPointPrecision(QDataStream::SinglePrecision); m_pdaData.playerPoints.clear(); for (int i = 0; i < d->playerSize; i++) { int16_t latU, lonU; ds >> latU >> lonU; m_pdaData.playerPoints.append(latlonUtoVector(latU, lonU)); } ui->lbInfo->setText(QString("Points: %1\nLives: %2").arg(d->points).arg(d->lives)); ui->lbInfo_2->setText(QString("Time left: %1:%2").arg(d->timeLeft / 60).arg((int)(d->timeLeft % 60), 2, 10, QChar('0'))); break; } case TYPE_STAB: m_pdaData.sphereEnabled = udpData[1]; break; case TYPE_ENEMY: { TUdpDataENEMY *d = (TUdpDataENEMY*)udpData; QByteArray b(udpData + sizeof(TUdpDataENEMY), data.size()); QDataStream ds(b); ds.setByteOrder(QDataStream::LittleEndian); ds.setFloatingPointPrecision(QDataStream::SinglePrecision); while (m_pdaData.enemies.size() < d->idx + 1) { m_pdaData.enemies.append(Enemy()); } m_pdaData.enemies[d->idx].points.clear(); for (int i = 0; i < d->enemiesSize; i++) { int16_t latU, lonU; ds >> latU >> lonU; m_pdaData.enemies[d->idx].points.push_back(latlonUtoVector(latU, lonU)); } break; } case TYPE_FOOD: { TUdpDataFOOD *d = (TUdpDataFOOD*)udpData; QByteArray b(udpData + sizeof(TUdpDataFOOD), data.size()); QDataStream ds(b); ds.setByteOrder(QDataStream::LittleEndian); ds.setFloatingPointPrecision(QDataStream::SinglePrecision); m_pdaData.foodPoints.clear(); for (int i = 0; i < d->foodSize; i++) { int16_t latU, lonU; ds >> latU >> lonU; m_pdaData.foodPoints.append(latlonUtoVector(latU, lonU)); } break; } } cnt++; } }
void MultiPointCom::run() { mutex.lock(); QTime timeout = lastConnectTime.addSecs(30); if (timeout < QTime::currentTime()) { qDebug() << "Device connected timeout" << disconnectCount++; lastConnectTime = QTime::currentTime(); #ifdef __arm__ ioctl(device, SI4432_IOC_RESET, 1); #endif } #ifdef __arm__ si4432_ioc_transfer tr; char txBuf[64], rxBuf[64]; memcpy(txBuf, request.data(), request.size()); memset(&tr, 0, sizeof(si4432_ioc_transfer)); tr.tx_buf = (__u64)txBuf; tr.rx_buf = (__u64)rxBuf; tr.len = request.size(); int len = ioctl(device, SI4432_IOC_MESSAGE(1), &tr); if (len > 0) { response.clear(); response.append(rxBuf, len); quint8 addr = response.at(0); if (addr == address) { lastConnectTime = QTime::currentTime(); disconnect = 0; emit deviceConnected(); emit responseReceived(response.at(1), QByteArray(response.data() + 2, len - 2)); } } else { disconnect++; if (disconnect > 3) { disconnect = 0; emit deviceDisconnected(); } } #else QUdpSocket *udp = new QUdpSocket(); udp->writeDatagram(request, QHostAddress::LocalHost, 19999); if (udp->waitForReadyRead(100) && (udp->pendingDatagramSize() > 0)) { response.resize(udp->pendingDatagramSize()); udp->readDatagram(response.data(), response.size()); quint8 addr = response.at(0); if (addr == address) { lastConnectTime = QTime::currentTime(); disconnect = 0; emit deviceConnected(); emit responseReceived(response.at(1), response.mid(2)); } } else { disconnect++; if (disconnect > 3) { disconnect = 0; emit deviceDisconnected(); } } delete udp; #endif mutex.unlock(); }
int main(int argc, char *argv[]) { int framePeriod = 1000000 / 60; QString logFile; // Determine log file name if (argc == 2) { logFile = argv[1]; } if (logFile.isNull()) { if (!QDir("logs").exists()) { printf("No logs directory and no log file specified\n"); return 1; } logFile = QString("logs/") + QDateTime::currentDateTime().toString("yyyyMMdd-hhmmss.log"); } // Create vision socket QUdpSocket visionSocket; if (!visionSocket.bind(SharedVisionPort, QUdpSocket::ShareAddress)) { printf("Can't bind to shared vision port"); return 1; } multicast_add(&visionSocket, SharedVisionAddress); // Create referee socket QUdpSocket refereeSocket; if (!refereeSocket.bind(LegacyRefereePort, QUdpSocket::ShareAddress)) { printf("Can't bind to referee port"); return 1; } multicast_add(&refereeSocket, RefereeAddress); // Create log file int fd = creat(logFile.toAscii(), 0666); if (fd < 0) { printf("Can't create %s: %m\n", (const char *)logFile.toAscii()); return 1; } printf("Writing to %s\n", (const char *)logFile.toAscii()); // Main loop LogFrame logFrame; bool first = true; while (true) { uint64_t startTime = timestamp(); logFrame.Clear(); logFrame.set_command_time(startTime); // Check for user input (to exit) struct pollfd pfd; pfd.fd = 0; pfd.events = POLLIN; if (poll(&pfd, 1, 0) > 0) { // Enter pressed break; } // Read vision data while (visionSocket.hasPendingDatagrams()) { string buf; unsigned int n = visionSocket.pendingDatagramSize(); buf.resize(n); visionSocket.readDatagram(&buf[0], n); SSL_WrapperPacket *packet = logFrame.add_raw_vision(); if (!packet->ParseFromString(buf)) { printf("Bad vision packet of %d bytes\n", n); continue; } } // Read referee data while (refereeSocket.hasPendingDatagrams()) { unsigned int n = refereeSocket.pendingDatagramSize(); string str(6, 0); refereeSocket.readDatagram(&str[0], str.size()); // Check the size after receiving to discard bad packets if (n != str.size()) { printf("Bad referee packet of %d bytes\n", n); continue; } logFrame.add_raw_referee(str); } if (first) { first = false; LogConfig *logConfig = logFrame.mutable_log_config(); logConfig->set_generator("simple_logger"); logConfig->set_git_version_hash(git_version_hash); logConfig->set_git_version_dirty(git_version_dirty); } uint32_t size = logFrame.ByteSize(); if (write(fd, &size, sizeof(size)) != sizeof(size)) { printf("Failed to write size: %m\n"); break; } else if (!logFrame.SerializeToFileDescriptor(fd)) { printf("Failed to write frame: %m\n"); break; } uint64_t endTime = timestamp(); int lastFrameTime = endTime - startTime; if (lastFrameTime < framePeriod) { usleep(framePeriod - lastFrameTime); } else { printf("Processor took too long: %d us\n", lastFrameTime); } } // Discard input on stdin tcflush(0, TCIFLUSH); printf("Done.\n"); return 0; }
int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); //help output if(a.arguments().contains("help")) { MSG("### OSCGrabber HELP ###"); MSG(" "); MSG("The following Arguments are available:"); MSG(" osc-server-address (address to send osc messages to) [default: 127.0.0.1]"); MSG(" osc-send-port (port to send osc messages to) [default: 7000]"); MSG(" osc-listen-port (port on wich OSCGrabber is listening for incomming osc messages) [default: 9001]"); MSG(" udp-send-address (address to send udp converted messages to) [default: 127.0.0.1]"); MSG(" udp-send-port (port to send udp converted messages to) [default: 7799]"); MSG(" udp-listen-port (port on wich OSCGrabber is listening for incomming udp messages) [default: 7788]"); MSG(" "); MSG("examaple calls:"); MSG(" OSCGrabber osc-listen-port 7000 osc-server-address 1.2.3.4"); MSG(" "); MSG("Type 'help' for this message."); a.exit(); return a.exec(); } //read command line arguments int oscListenPort = 9001; if(a.arguments().contains("osc-listen-port")) oscListenPort = a.arguments().at(a.arguments().indexOf(QRegExp("osc-listen-port"))+1).toInt(); QString oscServerAddress = "127.0.0.1"; if(a.arguments().contains("osc-server-address")) oscServerAddress = a.arguments().at(a.arguments().indexOf(QRegExp("osc-server-address"))+1); int oscSendPort = 9000; if(a.arguments().contains("osc-send-port")) oscSendPort = a.arguments().at(a.arguments().indexOf(QRegExp("osc-send-port"))+1).toInt(); int udpSendPort = 7799; if(a.arguments().contains("udp-send-port")) udpSendPort = a.arguments().at(a.arguments().indexOf(QRegExp("udp-send-port"))+1).toInt(); QString udpSendAddress = "127.0.0.1"; if(a.arguments().contains("udp-send-address")) udpSendAddress = a.arguments().at(a.arguments().indexOf(QRegExp("udp-send-address"))+1); int udpListenPort = 7788; if(a.arguments().contains("udp-listen-port")) udpListenPort = a.arguments().at(a.arguments().indexOf(QRegExp("udp-listen-port"))+1).toInt(); //start creating the services MSG("### [Creating] UDP service at Port "<<udpListenPort); MSG("### Sending to "<<udpSendAddress.toStdString()); QUdpSocket *listenSocket = new QUdpSocket(&a); listenSocket->bind(QHostAddress::AnyIPv4, udpListenPort); if(!listenSocket->isValid()) { MSG("Couldn't creat udp service at port "<<udpSendPort<<" . Port already occupied?"); a.exit(); return 0; //a.exec(); } MSG("### [Launching] OSC Bridge to address "<<oscServerAddress.toStdString()<<" "<<oscListenPort) lo::ServerThread * server = new lo::ServerThread(oscListenPort); server->start(); if (!server->is_valid()) { //this check isn't working. why? MSG("Couldn't creat osc service listening to port "<<oscListenPort<<" . Port already occupied?"); a.exit(); return 0; //a.exec(); } MSG("### --> Listening to Port: "<<oscListenPort); lo::string_type address(oscServerAddress.toStdString()); lo::Address * oscSender = new lo::Address(address, oscSendPort); // lo::Address * oscSender = new lo::Address("localhost", oscSendPort); MSG("### --> Writing on Port: "<<oscSendPort); //#################################################################################### //#################################################################################### // OSC to UDP //#################################################################################### //#################################################################################### QUdpSocket *senderSocket = new QUdpSocket(&a); server->add_method(NULL, NULL, [=](const char *path, const lo::Message& msg) { // msg.print(); QString type = QString::fromStdString(msg.types()); QString data(path); data.append("%"); data.append(type); data.append("%"); for (int i = 0; i < msg.argc(); i++) { if(type.at(i) == 'i') { data.append(QString::number(msg.argv()[i]->i)+"%"); // std::cout<<std::bitset<32>()<<std::endl; } else if(type.at(i) == 'f') data.append(QString::number(msg.argv()[i]->f)+"%"); else if(type.at(i) == 's') data.append(QString::fromStdString(&msg.argv()[i]->S)+"%"); } if(-1 == senderSocket->writeDatagram(data.toUtf8(), QHostAddress(udpSendAddress), udpSendPort)) { //qDebug()<<"ERROR: "<<senderSocket->errorString()<<" "<<senderSocket->error(); } else { //qDebug()<<"From live: "<<data; //qDebug()<<"NO ERROR?: "<<senderSocket->errorString()<<" "<<senderSocket->error()<<" valid? "<<senderSocket->isValid(); } }); //#################################################################################### //#################################################################################### // UDP to OSC //#################################################################################### //#################################################################################### QObject::connect(listenSocket, &QUdpSocket::readyRead, [=]() { QByteArray datagram; datagram.resize(listenSocket->pendingDatagramSize()); QHostAddress sender; quint16 senderPort; listenSocket->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort); //qDebug()<<"Message from: "<<sender<<" "<<senderPort<<" "<<QString::fromUtf8(datagram); QStringList splittedData = QString::fromUtf8(datagram).split("%"); if(splittedData.length() > 1) { lo::string_type path(splittedData.takeFirst().toStdString()); QString dataTypes = splittedData.takeFirst(); lo::Message message; for(int i = 0; i<dataTypes.length(); i++) { //qDebug()<<"type: "<<dataTypes.at(i); if(dataTypes.at(i) == 'i') message.add(splittedData.at(i).toInt()); else if(dataTypes.at(i) == 'f') message.add(splittedData.at(i).toFloat()); else if(dataTypes.at(i) == 's') { lo::string_type str(splittedData.at(i).toStdString()); message.add(str); } } //qDebug()<<"Stringlist: "<<splittedData; /*qDebug()<<"To live: "<<*/ oscSender->send(path, message);//<<QString::fromStdString(message.types())<<path._s; } else { lo::string_type path(splittedData.takeFirst().toStdString()); /*qDebug()<<"To live: "<<*/ oscSender->send(path); } }); //clean up services QObject::connect(&a, &QCoreApplication::destroyed, [=](){ server->stop(); delete server; }); return a.exec(); }
void Discover::readDatagrams () { QUdpSocket* socket = qobject_cast<QUdpSocket*>(QObject::sender()); if (socket) while (socket->hasPendingDatagrams()) { // Read it to a buffer QByteArray datagram; datagram.resize(socket->pendingDatagramSize()); QHostAddress sender; quint16 senderPort; socket->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort); // Check the prefix bool respond = false; bool removeThem = false; if (datagram.startsWith("DSDA")) respond = false; // Announcement, do not respond else if (datagram.startsWith("DSDR")) respond = true; // Request, do respond else if (datagram.startsWith("DSDD")) removeThem = true; // This is a departure, remove records following else { // This datagram isn't written for Discover, pass it on QList<Record> matchingRecords; for (Record record : foundRecords.keys()) { if (record.has("Address") and record["Address"]==sender.toString()) if (record.has("Port") and record["Port"]==QString::number(senderPort)) matchingRecords.append(record); } emit gotDatagram(datagram, sender, senderPort, matchingRecords); continue; } datagram.remove(0, 4); // Determine the scope of the sender // See if it's this machine QString scope("Global"); if (sender.isLoopback()) { scope = "Loopback"; } else if (sender.protocol() == QAbstractSocket::IPv4Protocol) { if (addressIsLocal(sender)) scope = "Local"; } // Process the records locally acceptRecords(Record::listFromBytes(datagram), removeThem, scope, sender.toString(), QString::number(senderPort)); // Normal: Respond to only Local requests with only owned Records if (respond and not mServerMode and (scope=="Local" or scope=="Loopback")) { globalSocket->writeDatagram(QByteArray("DSDA")+makeDatagram(ownedRecords, true), sender, senderPort); } // Server: Respond to only global requests with owned and found Records else if (respond and mServerMode and scope=="Global") { globalSocket->writeDatagram(QByteArray("DSDA")+makeDatagram(ownedRecords + foundRecords.keys(), false), sender, senderPort); } } }
/** * @brief SingleApplication::SingleApplication * Constructor. Checks and fires up LocalServer or closes the program * if another instance already exists * @param argc * @param argv */ SingleApplication::SingleApplication(QStringList &args) { _shouldContinue = false; // By default this is not the main process socket = new QUdpSocket(); QUdpSocket acceptor; acceptor.bind(QHostAddress::LocalHost, 58488, QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress); // Attempt to connect to the LocalServer socket->connectToHost(QHostAddress::LocalHost, 58487); QString isServerRuns; if(socket->waitForConnected(100)) { socket->write(QString("CMD:Is editor running?").toUtf8()); socket->flush(); if(acceptor.waitForReadyRead(100)) { //QByteArray dataGram;//Yes, I'm runs! QByteArray datagram; datagram.resize(acceptor.pendingDatagramSize()); QHostAddress sender; quint16 senderPort; acceptor.readDatagram(datagram.data(), datagram.size(), &sender, &senderPort); if(QString::fromUtf8(datagram)=="Yes, I'm runs!") { isServerRuns="Yes!"; } } } if(args.contains("--force-run", Qt::CaseInsensitive)) { isServerRuns.clear(); args.removeAll("--force-run"); } _arguments = args; if(!isServerRuns.isEmpty()) { QString str = QString("CMD:showUp"); QByteArray bytes; for(int i=1; i<_arguments.size(); i++) { str.append(QString("\n%1").arg(_arguments[i])); } bytes = str.toUtf8(); socket->write(bytes); socket->flush(); QThread::msleep(100); socket->close(); } else { // The attempt was insuccessful, so we continue the program _shouldContinue = true; server = new LocalServer(); server->start(); QObject::connect(server, SIGNAL(showUp()), this, SLOT(slotShowUp())); QObject::connect(server, SIGNAL(dataReceived(QString)), this, SLOT(slotOpenFile(QString))); QObject::connect(server, SIGNAL(acceptedCommand(QString)), this, SLOT(slotAcceptedCommand(QString))); QObject::connect(this, SIGNAL(stopServer()), server, SLOT(stopServer())); } }