void BinaryWidget::download(QString path)
{
QNetworkAccessManager networkManager(this);
QObject::connect(&networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(onNetworkReply(QNetworkReply*)));
QNetworkRequest request = QNetworkRequest(QUrl(path));
networkManager.get(request);
}
void EnginioClientConnectionPrivate::uploadChunk(EnginioReplyState *ereply, QIODevice *device, qint64 startPos)
{
QUrl serviceUrl = _serviceUrl;
{
QString path;
QByteArray errorMsg;
if (!getPath(ereply->data(), Enginio::FileChunkUploadOperation, &path, &errorMsg).successful())
Q_UNREACHABLE(); // sequential upload can not have an invalid path!
serviceUrl.setPath(path);
}
QNetworkRequest req = prepareRequest(serviceUrl);
req.setHeader(QNetworkRequest::ContentTypeHeader, EnginioString::Application_octet_stream);
// Content-Range: bytes {chunkStart}-{chunkEnd}/{totalFileSize}
qint64 size = device->size();
qint64 endPos = qMin(startPos + _uploadChunkSize, size);
req.setRawHeader(EnginioString::Content_Range,
QByteArray::number(startPos) + EnginioString::Minus
+ QByteArray::number(endPos) + EnginioString::Div
+ QByteArray::number(size));
// qDebug() << "Uploading chunk from " << startPos << " to " << endPos << " of " << size;
Q_ASSERT(device->isOpen());
ChunkDevice *chunkDevice = new ChunkDevice(device, startPos, _uploadChunkSize);
chunkDevice->open(QIODevice::ReadOnly);
QNetworkReply *reply = networkManager()->put(req, chunkDevice);
chunkDevice->setParent(reply);
_chunkedUploads.insert(reply, qMakePair(device, endPos));
ereply->setNetworkReply(reply);
_connections.append(QObject::connect(reply, &QNetworkReply::uploadProgress, UploadProgressFunctor(this, reply)));
}
ret_t dongleMainThread()
{
// Local variables
char msgBuf[sizeof(discPack_t) + 1];
char buffer[sizeof(discPack_t) + 1];
ret_t ret;
uint8_t i;
uint8_t j;
discPack_p pkt2 = (discPack_p)buffer;
discPack_p pkt = (discPack_p)msgBuf;
i = DATA_FROM_PC;
memset(buffer, 0, sizeof(buffer));
dongleDebugPrint("DEBUG=dongleMainThread: Start.\n");
while(1)
{
ret = networkManager(&(pkt2->header), pkt2->data, DATA_SIZE);
if(ret != SUCCESS && ret != WARNING)
{
dongleDebugPrint("DEBUG=dongleMainThread: networkManager failed.\n");
}
if (ret == WARNING)
{
//networkManager read a locatioRequest_t
dongleDebugPrint("DEBUG=dongleMainThread: Data recieved.\n");
//dumpPacket((discPack_p)buffer);
for(j = 0; j < sizeof(discPack_t); j++)
putchar(buffer[j]);
memset(buffer, 0, sizeof(buffer));
}
if (isPaired && DATA_FROM_PC)
{
msgBuf[0] = RX_BUF;
dongleDebugPrint("DEBUG=dongleMainThread: reading RESPONSE.\n");
for(i = 1; i <sizeof(discPack_t); i++)
{
//dongleDebugPrint("DEBUG=i=%d.\n", i);
msgBuf[i] = getchar();
}
//dumpPacket((discPack_p)msgBuf);
pkt->header.checksum = checksumCalculator(&(pkt->header),
pkt->data,
sizeof(locationRequest_t));
dongleDebugPrint("DEBUG=dongleMainThread: calling microSendMessage.\n");
microSendMessage(&(pkt->header), pkt->data, sizeof(locationRequest_t));
// Clean buffer and index
memset(msgBuf, 0, sizeof(msgBuf));
}
}
return SUCCESS;
}
QNetworkReply *NineGagRequest::createRequest(const QString §ion, const QString &lastId)
{
QUrl requestUrl("http://9gag.com/" + section);
if (!lastId.isEmpty()) {
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
requestUrl.addQueryItem("id", lastId);
#else
QUrlQuery q;
q.addQueryItem("id", lastId);
requestUrl.setQuery(q.query());
#endif
}
return networkManager()->createGetRequest(requestUrl, NetworkManager::HTML);
}
void
GrooveClient::Private::processPHPSessionId ()
{
LDEBUG << "processing";
QList<QNetworkCookie> cookieList = networkManager ().cookieJar ()->cookiesForUrl (QUrl (GroovePrivRequest::LOGIN_URL));
foreach (QNetworkCookie const &cookie, cookieList)
if (cookie.name () == "PHPSESSID")
{
m_phpCookie = cookie.value ();
LDEBUG << "Got PHP cookie: " << qPrintable (m_phpCookie);
fetchSessionToken ();
return;
}
/* FIXME */
GROOVE_VERIFY_OR_DIE (m_phpCookie.length (), "PHP cookie couldn't be set");
}
void QWifiManagerPrivateUnix::startScan() {
if (wirelessDevice != NULL) {
updateAccessPoints();
return;
}
QDBusInterface networkManager(NM_DBUS_SERVICE, NM_DBUS_PATH,
NM_DBUS_INTERFACE, QDBusConnection::systemBus());
if (!networkManager.isValid()) {
emit scanFinished(QWifiManager::ERROR_NO_NM);
return;
}
QDBusReply<QList<QDBusObjectPath> > devices = networkManager.call(
"GetDevices");
if (!devices.isValid()) {
emit scanFinished(QWifiManager::ERROR);
return;
}
bool foundWifi = false;
foreach (const QDBusObjectPath& connection, devices.value()) {
//qDebug() << connection.path();
QDBusInterface device(NM_DBUS_SERVICE, connection.path(),
NM_DBUS_INTERFACE_DEVICE, QDBusConnection::systemBus());
if (!device.isValid()) {
emit scanFinished(QWifiManager::ERROR);
return;
}
QVariant deviceType = device.property("DeviceType");
if (!deviceType.isValid()) {
emit scanFinished(QWifiManager::ERROR);
return;
}
//qDebug() << deviceType.toUInt();
if (deviceType.toUInt() == NM_DEVICE_TYPE_WIFI) {
foundWifi = true;
QVariant deviceState = device.property("State");
if (!deviceState.isValid()) {
emit scanFinished(QWifiManager::ERROR);
return;
}
if (deviceState.toUInt() <= NM_DEVICE_STATE_UNAVAILABLE)
continue; // we are only interested in enabled wifi devices
wirelessDevice = new QDBusInterface(NM_DBUS_SERVICE,
connection.path(), NM_DBUS_INTERFACE_DEVICE_WIRELESS,
QDBusConnection::systemBus());
if (!wirelessDevice->isValid()) {
emit scanFinished(QWifiManager::ERROR);
return;
}
QDBusConnection::systemBus().connect(NM_DBUS_SERVICE,
connection.path(), NM_DBUS_INTERFACE_DEVICE_WIRELESS,
"AccessPointAdded", this, SLOT(updateAccessPoints()));
QDBusConnection::systemBus().connect(NM_DBUS_SERVICE,
connection.path(), NM_DBUS_INTERFACE_DEVICE_WIRELESS,
"AccessPointRemoved", this, SLOT(updateAccessPoints()));
QDBusConnection::systemBus().connect(NM_DBUS_SERVICE,
connection.path(), NM_DBUS_INTERFACE_DEVICE_WIRELESS,
"PropertiesChanged", this, SLOT(updateAccessPoints()));
QDBusReply<QList<QDBusObjectPath> > accessPoints =
wirelessDevice->call("GetAccessPoints");
if (!accessPoints.isValid()) {
emit scanFinished(QWifiManager::ERROR);
return;
}
clearPreviousScanResults();
foreach (const QDBusObjectPath& connection, accessPoints.value()) {
//qDebug() << connection.path();
QDBusInterface accessPoint(NM_DBUS_SERVICE, connection.path(),
NM_DBUS_INTERFACE_ACCESS_POINT,
QDBusConnection::systemBus());
QVariant mac = accessPoint.property("HwAddress");
QVariant ssid = accessPoint.property("Ssid");
QVariant frequency = accessPoint.property("Frequency");
QVariant strengh = accessPoint.property("Strength");
QVariant capabilitiesWPA = accessPoint.property("WpaFlags");
QVariant capabilitiesRSN = accessPoint.property("RsnFlags");
QVariant flags = accessPoint.property("Flags");
if (!ssid.isValid() || !mac.isValid() || !frequency.isValid()
|| !strengh.isValid() || !capabilitiesRSN.isValid()
|| !capabilitiesWPA.isValid() || !flags.isValid() ) {
emit scanFinished(QWifiManager::ERROR);
return;
}
unsigned int capabilities = capabilitiesWPA.toUInt()
| capabilitiesRSN.toUInt() | flags.toUInt();
QString enc;
if (capabilities
& (NM_802_11_AP_SEC_PAIR_TKIP
| NM_802_11_AP_SEC_PAIR_CCMP
| NM_802_11_AP_SEC_GROUP_TKIP
| NM_802_11_AP_SEC_GROUP_CCMP
| NM_802_11_AP_SEC_KEY_MGMT_PSK
| NM_802_11_AP_SEC_KEY_MGMT_802_1X))
enc = QWifiManager::PSK;
else if (capabilities
& (NM_802_11_AP_SEC_PAIR_WEP40
| NM_802_11_AP_SEC_PAIR_WEP104
| NM_802_11_AP_SEC_GROUP_WEP40
| NM_802_11_AP_SEC_GROUP_WEP104))
enc = QWifiManager::WEP;
else
enc = QWifiManager::OPEN;
//qDebug() << ssid.toString() << " " << mac.toString() << " "
// << frequency.toString() << "Mhz Strength:"
// << strengh.toUInt();
scanResults.append(
new QScanResult(ssid.toString(), mac.toString(), enc,
frequency.toInt(), strengh.toInt()));
}
emit scanFinished(QWifiManager::SCAN_OK);
return;
}
}
int main()
{
tin::controllers::main::ControllerQueue ctrlQueue;
tin::network::websocket::ManagerQueue netManagerQueue;
tin::network::bsdsocket::ManagerQueue bsdManagerQueue;
tin::supervisor::models::StatsQueue statsQueue;
tin::controllers::terminal::TerminalQueue terminalQueue;
tin::controllers::main::MainModule mainCtrl(ctrlQueue, netManagerQueue, bsdManagerQueue, statsQueue, terminalQueue);
tin::network::websocket::Manager networkManager(netManagerQueue, ctrlQueue, 3338);
tin::network::bsdsocket::Manager bsdManager(bsdManagerQueue, ctrlQueue);
tin::supervisor::models::Stats stats(statsQueue, ctrlQueue, mainCtrl.machines);
// Terminal Server
boost::asio::io_service io_service;
boost::asio::io_service::work work(io_service);
std::thread terminalServiceThread([&io_service]() { io_service.run(); });
tin::controllers::terminal::TerminalModule terminalCtrl(terminalQueue, ctrlQueue, io_service);
std::cout << "Hello supervisor!\n";
auto mainCtrlThread = mainCtrl.createThread();
auto terminalCtrlThread = terminalCtrl.createThread();
auto netManager = networkManager.createThread();
auto bsdManagerThread = bsdManager.createThread();
auto statsThread = stats.createThread();
// auto statsRequestorThread = stats.createRequestorThread(2500, ctrlQueue);
// netManagerQueue.push(std::make_shared<tin::network::websocket::events::MessageReceived>(1, "{\"route\":\"stats-per-day\",\"type\":\"POST\",\"uid\":1}"));
try
{
/*
while (true)
{
std::this_thread::sleep_for (std::chrono::seconds(1));
nlohmann::json msgJson = nlohmann::json::object();
std::string data;
std::cout << "[Supervisor] Type command to send:" << std::endl;
std::getline(std::cin, data);
msgJson["cmd"] = data;
while (true)
{
std::string key;
std::cout << "? Pass next argument [Y/N] " << std::endl;
std::getline(std::cin, data);
if (data != "Y" && data != "y")
{
break;
}
std::cout << "? Key " << std::endl;
std::getline(std::cin, key);
std::cout << "? Type [string/number/bool] " << std::endl;
std::getline(std::cin, data);
if (data == "string")
{
std::cout << "? Value (string) " << std::endl;
std::getline(std::cin, data);
msgJson[key] = data;
}
else if (data == "number")
{
std::cout << "? Value (number) " << std::endl;
std::getline(std::cin, data);
msgJson[key] = std::stoi(data);
}
else if (data == "bool")
{
std::cout << "? Value (bool) [true/false] " << std::endl;
std::getline(std::cin, data);
if (data == "true")
{
msgJson[key] = true;
}
else
{
msgJson[key] = false;
}
}
else
{
std::cout << "! Invalid input " << std::endl;
}
}
bsdManagerQueue.push(
std::make_shared<tin::network::bsdsocket::events::MessageRequest>(
"localhost",
3333,
std::make_shared<nlohmann::json>(msgJson),
true
)
);
}
*/
mainCtrlThread.join();
netManager.join();
bsdManagerThread.join();
statsThread.join();
terminalCtrlThread.join();
terminalServiceThread.join();
// statsRequestorThread.join();
}
catch (std::system_error& e)
{
std::cout << e.what();
}
return 0;
}
