void
FingerprintCollector::onFingerprintSent( Request* req )
{
SubmitFullFingerprintRequest* submitreq = dynamic_cast<SubmitFullFingerprintRequest*>( req );
Q_ASSERT(submitreq);
QMutexLocker emitLocker( &m_networkErrorEmitMutex );
if ( req && req->failed() )
{
qDebug() << "Network error: " << submitreq->errorMessage();
if ( req->aborted() )
emit networkError( FingerprintCollector::RequestAborted, QString() );
else if ( req->responseHeaderCode() == 400 )
{
emit cantFingerprintTrack( submitreq->track(), tr( "Getting bad request with this track, skipping." ) );
emit networkError( FingerprintCollector::BadRequest, submitreq->errorMessage() );
}
else
emit networkError( FingerprintCollector::OtherError, submitreq->errorMessage() );
// Removed this because it caused several result signals to be emitted which led to
// deadlocks when the FingerprinterApplication tried to grab a mutex.
//if (!m_stop)
//{
// qDebug() << "Resending fingerprint";
// SubmitFingerprintRequest* newsubmitreq = new SubmitFingerprintRequest( submitreq->track(), submitreq->data());
// newsubmitreq->setSha256( submitreq->sha256() );
// newsubmitreq->setUsername( username() );
// newsubmitreq->setPasswordMd5( passwordMd5() );
// newsubmitreq->setPasswordMd5Lower( passwordMd5Lower() );
// newsubmitreq->setFpVersion( FINGERPRINT_LIB_VERSION );
// connect ( newsubmitreq, SIGNAL( result( Request* ) ), this, SLOT (onFingerprintSent( Request* ) ) );
// newsubmitreq->start();
//}
return;
}
emitLocker.unlock();
emit trackFingerprinted( submitreq->track() );
//qDebug() << "Fingerprint has been sent, writing to DB";
tryStartThreads();
QMutexLocker locker_pr ( &m_ongoingRequestsMutex );
m_ongoingRequests.removeAt( m_ongoingRequests.indexOf( submitreq->track().path() ) );
}
void Http::post(QString url, QString user, QString password, QString data)
{
QSslConfiguration config(QSslConfiguration::defaultConfiguration());
QNetworkRequest request;
request.setSslConfiguration(config);
request.setRawHeader("Authorization", "Basic " +
QByteArray(QString("%1:%2").arg(user).arg(password).toAscii().toBase64())
);
request.setRawHeader("Accept", "application/xml");
request.setRawHeader("Content-Type", "application/xml");
request.setUrl(QUrl(url));
connect(netManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(finished(QNetworkReply*)));
reply = netManager->post(request, data.toUtf8());
connect(reply, SIGNAL(downloadProgress(qint64,qint64)), this, SIGNAL(progress(qint64,qint64)));
connect(reply, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslError(QList<QSslError>)));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(networkError(QNetworkReply::NetworkError)));
}
void MusicBrainzClient::requestFinished() {
QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
if (!reply)
return;
reply->deleteLater();
if (!m_requests.contains(reply))
return;
int id = m_requests.take(reply);
ResultList ret;
if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() != 200) {
emit(networkError(
reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(),
"Musicbrainz"));
return;
}
QXmlStreamReader reader(reply);
while (!reader.atEnd()) {
if (reader.readNext() == QXmlStreamReader::StartElement
&& reader.name() == "recording") {
ResultList tracks = parseTrack(reader);
foreach (const Result& track, tracks) {
if (!track.m_title.isEmpty()) {
ret << track;
}
}
}
}
void
StationsPluginSimple::request(const QUrl & url, int id, const QByteArray & data)
{
if (url.isEmpty())
return ;
qDebug() << "Loading url" << url.toString()
<< "( online:" << Tools::isOnline() << ")";
QNetworkReply *rep;
QNetworkRequest req(url);
initNetwork();
Tools::fixupRequest(&req);
if (data.isEmpty())
rep = nm->get(req);
else {
req.setHeader(QNetworkRequest::ContentTypeHeader,
"application/x-www-form-urlencoded");
rep = nm->post(req, data);
}
connect(rep, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(networkError(QNetworkReply::NetworkError)));
if (count == 0) {
emit started();
step = 0;
}
replies[rep] = id;
count++;
}
void XMLHttpRequest::loadRequestSynchronously(ResourceRequest& request, ExceptionCode& ec)
{
ASSERT(!m_async);
Vector<char> data;
ResourceError error;
ResourceResponse response;
unsigned long identifier = ThreadableLoader::loadResourceSynchronously(scriptExecutionContext(), request, error, response, data);
m_loader = 0;
// No exception for file:/// resources, see <rdar://problem/4962298>.
// Also, if we have an HTTP response, then it wasn't a network error in fact.
if (error.isNull() || request.url().isLocalFile() || response.httpStatusCode() > 0) {
processSyncLoadResults(identifier, data, response, ec);
return;
}
if (error.isCancellation()) {
abortError();
ec = XMLHttpRequestException::ABORT_ERR;
return;
}
networkError();
ec = XMLHttpRequestException::NETWORK_ERR;
}
PendingDisco::PendingDisco (Util::QueueManager *queue, const QString& artist,
const QString& release, QNetworkAccessManager *nam, QObject *parent)
: QObject (parent)
, ReleaseName_ (release.toLower ())
, Queue_ (queue)
, NAM_ (nam)
, PendingReleases_ (0)
{
Queue_->Schedule ([this, artist, nam] () -> void
{
auto idLookup = new ArtistLookup (artist, nam, this);
connect (idLookup,
SIGNAL(gotID (QString)),
this,
SLOT (handleGotID (QString)));
connect (idLookup,
SIGNAL (replyError ()),
this,
SLOT (handleIDError ()));
connect (idLookup,
SIGNAL (networkError ()),
this,
SLOT (handleIDError ()));
}, this);
}
void XMLHttpRequest::makeSimpleCrossOriginAccessRequest(ExceptionCode& ec)
{
ASSERT(isSimpleCrossOriginAccessRequest(m_method, m_requestHeaders));
// Cross-origin requests are only defined for HTTP. We would catch this when checking response headers later, but there is no reason to send a request that's guaranteed to be denied.
if (!m_url.protocolInHTTPFamily()) {
ec = XMLHttpRequestException::NETWORK_ERR;
networkError();
return;
}
KURL url = m_url;
url.setUser(String());
url.setPass(String());
ResourceRequest request(url);
request.setHTTPMethod(m_method);
request.setAllowHTTPCookies(m_includeCredentials);
request.setHTTPOrigin(scriptExecutionContext()->securityOrigin()->toString());
if (m_requestHeaders.size() > 0)
request.addHTTPHeaderFields(m_requestHeaders);
if (m_requestEntityBody) {
ASSERT(m_method != "GET");
ASSERT(m_method != "HEAD");
request.setHTTPBody(m_requestEntityBody.release());
}
if (m_async)
loadRequestAsynchronously(request);
else
loadRequestSynchronously(request, ec);
}
void SeafileApiClient::httpRequestFinished()
{
int code = reply_->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (code == 0 && reply_->error() != QNetworkReply::NoError) {
if (!shouldIgnoreRequestError(reply_)) {
qDebug("[api] network error: %s\n", reply_->errorString().toUtf8().data());
}
emit networkError(reply_->error(), reply_->errorString());
return;
}
if (handleHttpRedirect()) {
return;
}
if ((code / 100) == 4 || (code / 100) == 5) {
if (!shouldIgnoreRequestError(reply_)) {
qDebug("request failed for %s: status code %d\n",
reply_->url().toString().toUtf8().data(), code);
}
emit requestFailed(code);
return;
}
emit requestSuccess(*reply_);
}
void XMLHttpRequest::loadRequestSynchronously(ResourceRequest& request, ExceptionCode& ec)
{
ASSERT(!m_async);
Vector<char> data;
ResourceError error;
ResourceResponse response;
{
// avoid deadlock in case the loader wants to use JS on a background thread
KJS::JSLock::DropAllLocks dropLocks;
if (m_doc->frame())
m_identifier = m_doc->frame()->loader()->loadResourceSynchronously(request, error, response, data);
}
m_loader = 0;
// No exception for file:/// resources, see <rdar://problem/4962298>.
// Also, if we have an HTTP response, then it wasn't a network error in fact.
if (error.isNull() || request.url().isLocalFile() || response.httpStatusCode() > 0) {
processSyncLoadResults(data, response, ec);
return;
}
if (error.isCancellation()) {
abortError();
ec = XMLHttpRequestException::ABORT_ERR;
return;
}
networkError();
ec = XMLHttpRequestException::NETWORK_ERR;
}
video::video()
{
handler = new http_handler;
connect(handler, SIGNAL(allDownloadsFinished()), this, SLOT(handleDownloads()));
connect(handler, SIGNAL(error(QString)), this, SLOT(networkError(QString)));
_treeItem = NULL;
}
dialogOauthSetup::dialogOauthSetup(QWidget *parent) :
QDialog(parent),
ui(new Ui::dialogOauthSetup)
{
ui->setupUi(this);
profileimageUrl = "";
if (genericHelper::getOAuthAccessToken().length() > 3) {
tw = new TwitchApi(this, genericHelper::getOAuthAccessToken());
} else {
tw = new TwitchApi(this, "");
}
// init the image loader
imgl = new imageLoader(this);
QObject::connect(tw, SIGNAL(twitchReady(const QJsonDocument)), this, SLOT(on_AuthSuccess(const QJsonDocument)));
QObject::connect(tw, SIGNAL(networkError(QString)), this, SLOT(errorPopup(QString)));
QObject::connect(imgl, SIGNAL(downloaded()), this, SLOT(loadProfileImage()));
}
void WARequest::sendRequest(QString url)
{
qDebug()<< "SENDING";
QNetworkRequest request;
request.setUrl(QUrl(url+"?"+encodeUrl(params)));
request.setRawHeader("User-Agent", userAgent.toAscii());
//request.setRawHeader("Content-Type","application/x-www-form-urlencoded");
//request.setRawHeader("Accept","text/xml");
//QNetworkReply *reply = manager->post(request,encodeUrl(params));
QNetworkReply *reply = manager->get(request);
reply->ignoreSslErrors();
//connect(reply, SIGNAL(readyRead()), this, SLOT(readyRead()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(networkError(QNetworkReply::NetworkError)));
connect(reply, SIGNAL(sslErrors(QList<QSslError>)),
this, SLOT(sslError(QList<QSslError>)));
// qDebug()<<encodeUrl(params);
// manager->get(request);
//manager->post(request,encodeUrl(params));
}
void PreFlightWeatherPage::downloadWeatherData( QList<QString>& stations )
{
if( stations.size() == 0 )
{
return;
}
if( m_updateIsRunning == true )
{
// Do not allow multiple calls, if download is already running.
return;
}
// set update marker
m_updateIsRunning = true;
// Disable update buttons.
switchUpdateButtons( false );
if( m_downloadManger == 0 )
{
m_downloadManger = new DownloadManager(this);
connect( m_downloadManger, SIGNAL(finished( int, int )),
this, SLOT(slotDownloadsFinished( int, int )) );
connect( m_downloadManger, SIGNAL(networkError()),
this, SLOT(slotNetworkError()) );
connect( m_downloadManger, SIGNAL(fileDownloaded(QString&)),
this, SLOT(slotNewWeaterReport(QString&)) );
// connect( m_downloadManger, SIGNAL(status( const QString& )),
// _globalMapView, SLOT(slot_info( const QString& )) );
}
void MainWindow::startConnection()
{
Client *client = new Client(this);
connect(client, SIGNAL(version_checked(QString, QString)), SLOT(checkVersion(QString, QString)));
connect(client, SIGNAL(error_message(QString)), SLOT(networkError(QString)));
}
void MainWindow::startConnection(){
Client *client = new Client(this);
connect(client, SIGNAL(error_message(QString)), SLOT(networkError(QString)));
connect(client, SIGNAL(server_connected()), SLOT(enterRoom()));
//client->signup();
}
bool DownloadManager::checkError(QNetworkReply *finished)
{
if (finished->error() != QNetworkReply::NoError)
{
emit networkError(finished->error());
return true;
}
return false;
}
void Download::download( QNetworkRequest const &request)
{
m_networkReply = m_networkManager->get( request );
QObject::connect( m_networkReply, SIGNAL( downloadProgress( qint64,qint64 ) ),
this, SLOT( downloadProgress( qint64,qint64 )) );
QObject::connect( m_networkReply, SIGNAL( finished() ), this, SLOT( finished() ) );
QObject::connect( m_networkReply, SIGNAL( error( QNetworkReply::NetworkError ) ),
this, SLOT( networkError( QNetworkReply::NetworkError ) ) );
}
video::video()
{
handler = new http_handler;
connect(handler, SIGNAL(allDownloadsFinished()), this, SLOT(handleDownloads()));
connect(handler, SIGNAL(error(QString)), this, SLOT(networkError(QString)));
connect(this, SIGNAL(downloadFinished()), this, SLOT(startConvert()));
_treeItem = NULL;
_downloadPaused = false;
_isRestarted = false;
}
void NetworkExchange::OkorErrror(QNetworkReply *reply)
{
if (reply->error()==QNetworkReply::NoError)
{
emit networkOk();
}
else
{
emit networkError(reply->errorString());
}
}
/**
* @brief Get this response's error string.
*
* This base implementation returns either the internal network reply object's
* error string (if the reply object has an error), or the internal XML parse
* error (if one was set, eg via set setXmlError), otherwise a null QString.
*
* Derived classes may override this function to support additional error types.
* Typically such derived implementations would check this base implementation's
* result first, or fallback to this base implementation. For example:
*
* @code
* if (weHaveOurOwnCustomError()) {
* return customErrorString();
* } else {
* return AwsAbstractResponse::errorString();
* }
* @endcode
*
* @return An error string, or a null QString if this response has no errors.
*
* @see hasError
* @see networkError
* @see xmlParseError
*/
QString AwsAbstractResponse::errorString() const
{
Q_D(const AwsAbstractResponse);
if (networkError() != QNetworkReply::NoError) {
return d->reply->errorString();
} else if (xmlParseError() != QXmlStreamReader::NoError) {
return xmlParseErrorString();
} else {
return QString();
}
}
void FotoBilderAccount::handleNetworkError (QNetworkReply::NetworkError err)
{
auto reply = qobject_cast<QNetworkReply*> (sender ());
if (!reply)
return;
reply->deleteLater ();
qWarning () << Q_FUNC_INFO
<< err
<< reply->errorString ();
emit networkError (err, reply->errorString ());
CallNextFunctionFromQueue ();
}
void NetworkReader::readData()
{
mTimer.stop();
if(mReply->error() == QNetworkReply::NoError){
parseData(mReply->readAll());
}
else{
qDebug() << "Network error: " << mReply->error();
networkError();
}
deleteLater();//suicide
}
void ListenRISRequests::listen()
{
m_tcpRISServer = new QTcpServer();
if (!m_tcpRISServer->listen(QHostAddress::Any, Settings().getValue(InputOutputSettings::RISRequestsPort).toUInt()))
{
networkError(m_tcpRISServer);
return;
}
connect(m_tcpRISServer, SIGNAL(newConnection()), SLOT(newRISRequest()));
}
void AbstractNetworkJob::slotFinished()
{
_timer.stop();
if( _reply->error() == QNetworkReply::SslHandshakeFailedError ) {
qDebug() << "SslHandshakeFailedError: " << reply()->errorString() << " : can be caused by a webserver wanting SSL client certificates";
}
if( _reply->error() != QNetworkReply::NoError ) {
qDebug() << Q_FUNC_INFO << _reply->error() << _reply->errorString()
<< _reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
if (_reply->error() == QNetworkReply::ProxyAuthenticationRequiredError) {
qDebug() << Q_FUNC_INFO << _reply->rawHeader("Proxy-Authenticate");
}
emit networkError(_reply);
}
// get the Date timestamp from reply
_responseTimestamp = _reply->rawHeader("Date");
_duration = _durationTimer.elapsed();
if (_followRedirects) {
// ### the qWarnings here should be exported via displayErrors() so they
// ### can be presented to the user if the job executor has a GUI
QUrl requestedUrl = reply()->request().url();
QUrl redirectUrl = reply()->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
if (!redirectUrl.isEmpty()) {
_redirectCount++;
if (requestedUrl.scheme() == QLatin1String("https") &&
redirectUrl.scheme() == QLatin1String("http")) {
qWarning() << this << "HTTPS->HTTP downgrade detected!";
} else if (requestedUrl == redirectUrl || _redirectCount >= maxRedirects()) {
qWarning() << this << "Redirect loop detected!";
} else {
resetTimeout();
setReply(getRequest(redirectUrl));
setupConnections(reply());
return;
}
}
}
AbstractCredentials *creds = _account->credentials();
if (!creds->stillValid(_reply) && ! _ignoreCredentialFailure) {
_account->handleInvalidCredentials();
}
bool discard = finished();
if (discard) {
deleteLater();
}
}
void UpdateApplication::connectSignals(QNetworkReply *reply)
// ----------------------------------------------------------------------------
// Connect signals of reply object to 'this'
// ----------------------------------------------------------------------------
{
connect(reply, SIGNAL(metaDataChanged()), this, SLOT(processReply()));
connect(reply, SIGNAL(finished()), this, SLOT(downloadFinished()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(networkError(QNetworkReply::NetworkError)));
connect(reply, SIGNAL(downloadProgress(qint64,qint64)),
this, SLOT(downloadProgress(qint64,qint64)));
}
QT_BEGIN_NAMESPACE
QGeoRouteReplyNokia::QGeoRouteReplyNokia(const QGeoRouteRequest &request,
const QList<QNetworkReply *> &replies,
QObject *parent)
: QGeoRouteReply(request, parent), m_replies(replies), m_parsers(0)
{
qRegisterMetaType<QList<QGeoRoute> >();
foreach (QNetworkReply *reply, m_replies) {
connect(reply, SIGNAL(finished()), this, SLOT(networkFinished()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(networkError(QNetworkReply::NetworkError)));
}
void Folder::slotPollTimerTimeout()
{
qDebug() << "* Polling" << alias() << "for changes. (time since next sync:" << (_timeSinceLastSync.elapsed() / 1000) << "s)";
if (quint64(_timeSinceLastSync.elapsed()) > MirallConfigFile().forceSyncInterval()) {
qDebug() << "* Force Sync now";
evaluateSync(QStringList());
} else {
RequestEtagJob* job = new RequestEtagJob(secondPath(), this);
// check if the etag is different
QObject::connect(job, SIGNAL(etagRetreived(QString)), this, SLOT(etagRetreived(QString)));
QObject::connect(job, SIGNAL(networkError()), this, SLOT(slotNetworkUnavailable()));
}
}
void Download::pause()
{
if( !m_networkReply ) return;
m_file->write( m_networkReply->readAll() );
QObject::disconnect( m_networkReply, SIGNAL(downloadProgress(qint64,qint64)),
this, SLOT(downloadProgress(qint64,qint64)) );
QObject::disconnect( m_networkReply, SIGNAL(finished()), this, SLOT(finished()) );
QObject::disconnect( m_networkReply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(networkError(QNetworkReply::NetworkError)) );
m_networkReply->abort();
m_networkReply = nullptr;
}
QT_BEGIN_NAMESPACE
QGeoRouteReplyNokia::QGeoRouteReplyNokia(const QGeoRouteRequest &request, QNetworkReply *reply, QObject *parent)
: QGeoRouteReply(request, parent),
m_reply(reply)
{
connect(m_reply,
SIGNAL(finished()),
this,
SLOT(networkFinished()));
connect(m_reply,
SIGNAL(error(QNetworkReply::NetworkError)),
this,
SLOT(networkError(QNetworkReply::NetworkError)));
}
QT_BEGIN_NAMESPACE
QGeoCodeReplyNokia::QGeoCodeReplyNokia(QNetworkReply *reply, int limit, int offset,
const QGeoShape &viewport, QObject *parent)
: QGeoCodeReply(parent), m_reply(reply), m_parsing(false)
{
qRegisterMetaType<QList<QGeoLocation> >();
connect(m_reply, SIGNAL(finished()), this, SLOT(networkFinished()));
connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(networkError(QNetworkReply::NetworkError)));
setLimit(limit);
setOffset(offset);
setViewport(viewport);
}
