void QXmppSocksClient::slotReadyRead()
{
    if (m_step == ConnectState)
    {
        m_step++;

        // receive connect to server response
        QByteArray buffer = readAll();
        if (buffer.size() != 2 || buffer.at(0) != SocksVersion || buffer.at(1) != NoAuthentication)
        {
            qWarning("QXmppSocksClient received an invalid response during handshake");
            close();
            return;
        }

        // send CONNECT command
        buffer.resize(3);
        buffer[0] = SocksVersion;
        buffer[1] = ConnectCommand;
        buffer[2] = 0x00; // reserved
        buffer.append(encodeHostAndPort(
            DomainName,
            m_hostName.toLatin1(),
            m_hostPort));
        write(buffer);

    } else if (m_step == CommandState) {
        m_step++;

        // disconnect from signal
        disconnect(this, SIGNAL(readyRead()), this, SLOT(slotReadyRead()));

        // receive CONNECT response
        QByteArray buffer = readAll();
        if (buffer.size() < 6 ||
            buffer.at(0) != SocksVersion ||
            buffer.at(1) != Succeeded ||
            buffer.at(2) != 0)
        {
            qWarning("QXmppSocksClient received an invalid response to CONNECT command");
            close();
            return;
        }

        // parse host
        quint8 hostType;
        QByteArray hostName;
        quint16 hostPort;
        if (!parseHostAndPort(buffer.mid(3), hostType, hostName, hostPort))
        {
            qWarning("QXmppSocksClient could not parse type/host/port");
            close();
            return;
        }
        // FIXME : what do we do with the resulting name / port?

        // notify of connection
        emit ready();
    }
}

std::shared_ptr<Shader> ResourceManager::shader(const Arx::String &path) {
    return inst().shaders.getOrElseUpdate(path,[&](){
        auto ret = std::make_shared<Shader>();

        auto vpath = ResourceManager::adjustedPath(path + ".vertex");
        Arx::String vsrc = readAll(vpath.path.raw());
        auto fpath = ResourceManager::adjustedPath(path + ".fragment");
        Arx::String fsrc = readAll(fpath.path.raw());

        ret->load(vsrc.raw(),fsrc.raw());
        return ret;
    });
}

bool Socket::receive(void *data, int dataSize) {
	readAll();
	if (buffer.readBytes(data, dataSize)) {
		return true;
	}
	return false;
}

void
ScrobSocket::onReadyRead()
{
    QByteArray bytes = readAll();
    if (bytes != "OK\n") qWarning() << bytes.trimmed();
    disconnectFromHost();
}

void MyCtl::reply_finished(QNetworkReply *reply) {
    if (!reply->property(kAuthGetSalt).isNull()) {
        reply->deleteLater(); // let's not leak the reply
        if (reply->error() == QNetworkReply::NoError) {
            auto salt = reply->readAll();
            auto email = reply->property(kEmail).toString();
            auto password = reply->property(kPassword).toString();
            Q_ASSERT(!password.isEmpty() && !email.isEmpty());
            QCryptographicHash hasher{QCryptographicHash::Sha1};
            hasher.addData(salt); // the server must hash the same way
            hasher.addData("----");
            hasher.addData(password.toUtf8());
            auto hash = hasher.result().toBase64(QByteArray::Base64UrlEncoding);
            auto url = doAuthUrl.arg(email).arg(QString::fromLatin1(hash));
            auto reply = manager.get(QNetworkRequest{url});
            reply->setProperty(kDoAuth, true);
            reply->setProperty(kEmail, email);
        }
    }
    else if (!reply->property(kDoAuth).isNull()) {
        if (reply->error() == QNetworkReply::NoError) {
            auto email = reply->property(kEmail).toString();
            // ...
        }
    }
}

 bool LLWebRequest::request(const char* httpMethod, const char* url, const char* contentData, char* readBuffer, size_t readBufferLength)
 {
     bool result = FALSE;
     if (readBuffer) readBuffer[0] = 0; // terminate result buffer in case of failure
     
     if (sendRequest(httpMethod, url, contentData))
     {
         if (readBuffer)
         {
             // read HTTP headers:
             if (readHeaders())
             {
                 // read content data as c-string, keep 1 byte for termination:
                 int bytesRead = readAll(readBuffer, readBufferLength - 1);
                 
                 readBuffer[bytesRead] = 0; // Terminate read buffer with \0
                 result = TRUE;
             }
         }
         else
         {
             // okay, not expecting any result
             readHeaders(); // at least read headers
             result = TRUE;
         }
         stop();
     }
     return result;
 }

void ModelBaker::handleModelNetworkReply() {
    auto requestReply = qobject_cast<QNetworkReply*>(sender());

    if (requestReply->error() == QNetworkReply::NoError) {
        qCDebug(model_baking) << "Downloaded" << _modelURL;

        // grab the contents of the reply and make a copy in the output folder
        QFile copyOfOriginal(_originalOutputModelPath);

        qDebug(model_baking) << "Writing copy of original model file to" << _originalOutputModelPath << copyOfOriginal.fileName();

        if (!copyOfOriginal.open(QIODevice::WriteOnly)) {
            // add an error to the error list for this model stating that a duplicate of the original model could not be made
            handleError("Could not create copy of " + _modelURL.toString() + " (Failed to open " + _originalOutputModelPath + ")");
            return;
        }
        if (copyOfOriginal.write(requestReply->readAll()) == -1) {
            handleError("Could not create copy of " + _modelURL.toString() + " (Failed to write)");
            return;
        }

        // close that file now that we are done writing to it
        copyOfOriginal.close();

        // emit our signal to start the import of the model source copy
        emit modelLoaded();
    } else {
        // add an error to our list stating that the model could not be downloaded
        handleError("Failed to download " + _modelURL.toString());
    }
}

MainWidget::MainWidget(QWidget *parent)
	: QWidget(parent)
{
	ui.setupUi(this);

	ui.tree->deserialize(readAll(treeFileName()));
}

void
IrcSocket::Receive ()
{
  QByteArray bytes = readAll ();
qDebug () << __PRETTY_FUNCTION__ << " got " << bytes.size() << " bytes " << bytes;
  numBytesIn += bytes.size();
  QByteArray last2 = lineData.right(2);
  if (last2.size () < 2) {
    last2.prepend ("??");
    last2 = last2.right (2);
  }
  int nb = bytes.size();
  char byte;
  char last0, last1;
  last0 = last2[0];
  last1 = last2[1];
  for (int b=0; b< nb; b++) {
    byte = bytes[b];
    lineData.append (byte);
    last0 = last1;
    last1 = byte;
    if (last0 == '\r' && last1 == '\n') {
      emit ReceivedLine (this, lineData);
      lineData.clear ();
    }
  }
  emit IOActivity ();
}

	void RecentReleasesFetcher::handleReplyFinished ()
	{
		auto reply = qobject_cast<QNetworkReply*> (sender ());
		reply->deleteLater ();

		const auto& data = reply->readAll ();
		qDebug () << data;
		QDomDocument doc;
		if (!doc.setContent (data))
		{
			qWarning () << Q_FUNC_INFO
					<< "error parsing reply";
			return;
		}

		const auto& docElem = doc.documentElement ();
		if (docElem.attribute ("status") != "ok")
		{
			qWarning () << Q_FUNC_INFO
					<< "reply is not ok:"
					<< docElem.attribute ("status");
			return;
		}

		QList<Media::AlbumRelease> releases;

		static auto months = { "Jan", "Feb", "Mar",
				"Apr", "May", "Jun",
				"Jul", "Aug", "Sep",
				"Oct", "Nov", "Dec" };
		const auto monthsBegin = months.begin ();
		const auto monthsEnd = months.end ();
		auto album = docElem.firstChildElement ("albums").firstChildElement ("album");
		while (!album.isNull ())
		{
			const auto& strs = album.attribute ("releasedate").split (' ', QString::SkipEmptyParts);
			const int day = strs.value (1).toInt ();
			const int month = std::distance (monthsBegin,
						std::find (monthsBegin, monthsEnd, strs.value (2))) + 1;
			const int year = strs.value (3).toInt ();

			const QUrl& thumb = GetImage (album, "large");
			const QUrl& full = GetImage (album, "extralarge");

			Media::AlbumRelease release =
			{
				album.firstChildElement ("name").text (),
				album.firstChildElement ("artist").firstChildElement ("name").text (),
				QDateTime (QDate (year, month, day)),
				thumb,
				full,
				QUrl (album.firstChildElement ("url").text ())
			};
			releases << release;

			album = album.nextSiblingElement ("album");
		}

		emit gotRecentReleases (releases);
	}

unsigned int CC3DataReader::readUnsignedInteger()
{
	unsigned int value;
	readAll( sizeof(value), (char*)&value );
	// return _isBigEndian ? NSSwapBigIntToHost(value) : NSSwapLittleIntToHost(value);
	return value;
}

void DialogNewCamera::login(std::function<void(const QString &sid)> cb)
{
    QString url = authUrl;
    url += QStringLiteral("&format=2&account=%1&passwd=%2").arg(ui->dsm_username->text()).arg(ui->dsm_password->text());

    QUrl u(url);
    QNetworkRequest request(u);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

    auto reply = nm->get(request);
    connect(reply, &QNetworkReply::finished, [=]()
    {
        reply->deleteLater();
        if (reply->error() != QNetworkReply::NoError)
        {
            QMessageBox::warning(this, tr("Calaos Installer"), reply->errorString());
            cb({});
            return;
        }

        QByteArray bytes = reply->readAll();
        bool err;
        QJsonObject jdata = parseResult(bytes, err);

        if (err || !jdata["sid"].isString())
        {
            cb({});
            return;
        }

        cb(jdata["sid"].toString());
    });
}

	void SelfAvatarFetcher::handleGetFinished ()
	{
		auto reply = qobject_cast<QNetworkReply*> (sender ());
		reply->deleteLater ();
		const QImage& image = QImage::fromData (reply->readAll ());
		emit gotImage (image);
	}

quint8 ma_log::get_hash( QString *hash)
{
    if( init() )
    {
        emit log_message( QString( Q_FUNC_INFO ), QString("Fail on init file log activity: ") + fileName() );
        return 1;
    }

    hash->clear();
    if( save() ) return 3;

    if( !exists() )
    {
        emit log_message( QString( Q_FUNC_INFO ), QString("file not exists, filename: ") + fileName() );
        return 1;
    }

    if( !open( QIODevice::ReadOnly | QIODevice::Text ) )
    {
        emit log_message( QString( Q_FUNC_INFO ), QString("can't open file: ") + fileName() );
        return 2;
    }

    QByteArray file_data = readAll();
    close();
    QByteArray md5 = QCryptographicHash::hash( file_data, QCryptographicHash::Md5 );
    file_data.append( md5 );

    *hash = ( QCryptographicHash::hash( file_data, QCryptographicHash::Sha1 ) ).toHex();
    return 0;
}

void Script::setUrl(QUrl url)
{
    if (url == m_url)
        return;

    QNetworkRequest request(url);
    auto reply = m_networkAccessManager.get(request);
    m_status = Loading;
    emit statusChanged(m_status);
    connect(reply, &QNetworkReply::finished, [=] () {
        if (m_status == Loading) {
            if (reply->error() == QNetworkReply::NoError) {
                m_source = QString::fromUtf8(reply->readAll());
                emit sourceChanged(m_source);

                m_status = Loaded;
                emit statusChanged(m_status);
            } else {
                emit error(nullptr, QString("Failed to load “").append(url.toString()).append("”"));

                m_status = Error;
                emit statusChanged(m_status);
            }
        }

        reply->deleteLater();
    });
}

	void AuthManager::handleAuthReplyFinished ()
	{
		auto reply = qobject_cast<QNetworkReply*> (sender ());
		reply->deleteLater ();

		const auto& login = reply->property ("Login").toString ();

		const auto& data = reply->readAll ();
		QDomDocument doc;
		if (!doc.setContent (data))
		{
			emit sidError (login, tr ("Unable to parse authentication reply."));
			return;
		}

		const auto& docElem = doc.documentElement ();
		if (docElem.firstChildElement ("status").text () != "1")
		{
			FailedAuth_ << login;
			emit sidError (login, docElem.firstChildElement ("errorMessage").text ());
			return;
		}

		Login2Sid_ [login] = docElem.firstChildElement ("session_id").text ();
		FailedAuth_.remove (login);

		emit sidReady (login);
	}

void PremiumizeMeDownloadHandler::generateLinkReplyFinished()
{
    auto reply = static_cast< QNetworkReply *>(sender());

    QString data(QString::fromLatin1(reply->readAll()));
    reply->deleteLater();

    QRegularExpressionMatch match = LOCATION_REGEXP.match(data);
    if(!match.hasMatch()) {
        m_download->setMessage("No download url found: "+data);
        m_download->setEnabled(false);
        return;
    }

    QString downloadUrl = match.captured(1);
    downloadUrl.replace(QLatin1String("\\/"), QLatin1String("/"));

    m_download->setRedirectedUrl(QUrl(downloadUrl));
    m_download->setMessage("Getting file information...");
    Controller::downloadsDao()->update(m_download);

    m_downloader->setUrl(m_download->redirectedUrl());
    m_downloader->getMetaData();

    QObject::connect(m_downloader, &Downloader::metaDataChanged, [&]() {
        m_download->setRedirectedUrl(m_downloader->redirectedUrl());
        m_download->setFileName(m_downloader->fileName());
        m_download->setFileSize(m_downloader->fileSize());
        m_download->setMessage("");
        Controller::downloadsDao()->update(m_download);

        emit downloadInformationReady();
    });
}

	void FinalPage::handleReplyFinished ()
	{
		auto reply = qobject_cast<QNetworkReply*> (sender ());
		reply->deleteLater ();
		QString text;

		QDomDocument doc;
		if (!doc.setContent (reply->readAll ()))
		{
			text = tr ("I'm very sorry to say that, but seems like "
					"we're unable to handle your report at the time :(");
			Ui_.Status_->setText (text);
			return;
		}

		auto root = doc.documentElement ();
		const auto& id = root.firstChildElement ("id").text ();
		text = tr ("Report has been sent successfully. Thanks for your time!");
		if (!id.isEmpty ())
		{
			text += "<br />";
			text += (tr ("Your issue number is %1. You can view it here:") +
						" <a href='http://dev.leechcraft.org/issues/%1'>#%1</a>").arg (id);
		}
		Ui_.Status_->setText (text);
	}

	void CurrenciesManager::gotRateReply ()
	{
		auto reply = qobject_cast<QNetworkReply*> (sender ());
		reply->deleteLater ();

		const auto& data = reply->readAll ();

		QDomDocument doc;
		if (!doc.setContent (data))
		{
			qWarning () << Q_FUNC_INFO
					<< "unable to parse"
					<< data;
			return;
		}

		const auto& now = QDateTime::currentDateTime ();

		bool changed = false;
		auto rateElem = doc.documentElement ()
				.firstChildElement ("results")
				.firstChildElement ("rate");
		while (!rateElem.isNull ())
		{
			std::shared_ptr<void> guard (nullptr,
					[&rateElem] (void*) { rateElem = rateElem.nextSiblingElement ("rate"); });

			const auto& toValue = rateElem.attribute ("id").mid (3);
			if (toValue.size () != 3)
			{
				qWarning () << "incorrect `to` value"
						<< toValue;
				continue;
			}

			const auto newRate = rateElem.firstChildElement ("Rate").text ().toDouble ();
			if (std::fabs (newRate - RatesFromUSD_ [toValue]) > std::numeric_limits<double>::epsilon ())
			{
				RatesFromUSD_ [toValue] = newRate;
				changed = true;
			}

			Rate rate { 0, toValue, now, newRate };
			Core::Instance ().GetStorage ()->AddRate (rate);
		}

		LastFetch_ = QDateTime::currentDateTime ();

		QSettings settings (QCoreApplication::organizationName (),
			QCoreApplication::applicationName () + "_Poleemery");
		settings.beginGroup ("Currencies");
		settings.setValue ("LastFetch", LastFetch_);
		if (changed)
		{
			emit currenciesUpdated ();
			for (auto i = RatesFromUSD_.constBegin (); i != RatesFromUSD_.constEnd (); ++i)
				settings.setValue (i.key (), *i);
		}
		settings.endGroup ();
	}

	void SingleAccAuth::handleSubmission ()
	{
		const auto reply = qobject_cast<QNetworkReply*> (sender ());
		reply->deleteLater ();

		const auto& data = reply->readAll ();
		const auto& split = data.split ('\n');

		int timeout = 10 * 1000;
		if (split.value (0).trimmed () != "OK")
		{
			Queue_ << LastSubmit_;
			timeout *= 6;
		}
		else
			qDebug () << Q_FUNC_INFO
					<< "submitted to"
					<< BaseURL_
					<< Login_;

		LastSubmit_.Clear ();
		SaveQueue ();
		QTimer::singleShot (timeout,
				this,
				SLOT (rotateSubmitQueue ()));
	}