void MusicRadioPlayListThread::startToDownload(const QString &id)
{
m_manager = new QNetworkAccessManager(this);
QNetworkRequest request;
request.setUrl(QUrl(playListUrl + id));
#ifndef QT_NO_SSL
connect(m_manager, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)),
SLOT(sslErrors(QNetworkReply*,QList<QSslError>)));
M_LOGGER_INFO(QString("MusicRadioPlayListThread Support ssl: %1").arg(QSslSocket::supportsSsl()));
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
request.setSslConfiguration(sslConfig);
#endif
if(m_cookJar)
{
m_manager->setCookieJar(m_cookJar);
m_cookJar->setParent(nullptr);
}
m_reply = m_manager->get(request);
connect(m_reply, SIGNAL(finished()), SLOT(downLoadFinished()));
connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(replyError(QNetworkReply::NetworkError)));
}
void AcceptandPayOfferListPage::RefreshImage()
{
QIcon ButtonIcon(m_placeholderImage);
ui->imageButton->setIcon(ButtonIcon);
if(m_imageList.size() > 0 && m_imageList.at(0) != QString(""))
{
QString parsedURL = m_imageList.at(0).simplified();
m_url = QUrl(parsedURL);
if(m_url.isValid())
{
QNetworkRequest request(m_url);
request.setRawHeader("Accept", "q=0.9,image/webp,*/*;q=0.8");
request.setRawHeader("Cache-Control", "no-cache");
request.setRawHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.71 Safari/537.36");
QSslConfiguration conf = request.sslConfiguration();
conf.setPeerVerifyMode(QSslSocket::VerifyNone);
conf.setProtocol(QSsl::TlsV1_0);
request.setSslConfiguration(conf);
QNetworkReply *reply = m_netwManager->get(request);
reply->ignoreSslErrors();
connect(reply, SIGNAL(finished()), this, SLOT(netwManagerFinished()));
}
}
}
void QMQTT::ClientPrivate::init(const QString& hostName, const quint16 port, const bool ssl,
const bool ignoreSelfSigned)
{
_hostName = hostName;
_port = port;
if (ssl)
{
#ifndef QT_NO_SSL
QSslConfiguration sslConf = QSslConfiguration::defaultConfiguration();
QList<QSslCertificate> certs = QSslCertificate::fromPath(QStringLiteral("./cert.crt"));
if (!certs.isEmpty())
sslConf.setLocalCertificate(certs.first());
QFile file(QStringLiteral("./cert.key"));
if (file.open(QIODevice::ReadOnly)) {
sslConf.setPrivateKey(QSslKey(file.readAll(), QSsl::Rsa));
}
sslConf.setPeerVerifyMode(QSslSocket::VerifyNone);
#if QT_VERSION < 0x050000
sslConf.setProtocol(QSsl::TlsV1);
#endif
init(hostName, port, sslConf, ignoreSelfSigned);
#else
Q_UNUSED(ignoreSelfSigned)
qCritical() << "SSL not supported in this QT build";
#endif // QT_NO_SSL
}
else
{
init(new Network);
}
}
void HeadlessApplication::getFavoriteThreads() {
// list green + yellow flags
const QUrl url(DefineConsts::FORUM_URL + "/forum1f.php?owntopic=1");
qDebug() << "getFavoriteThreads()";
CookieJar *cookies = new CookieJar();
cookies->loadFromDisk();
QNetworkAccessManager *accessManager = new QNetworkAccessManager();
accessManager->setCookieJar(cookies);
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfig.setPeerVerifyDepth(1);
sslConfig.setProtocol(QSsl::TlsV1);
sslConfig.setSslOption(QSsl::SslOptionDisableSessionTickets, true);
QNetworkReply* reply = accessManager->get(request);
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(checkReplyFav()));
Q_ASSERT(ok);
Q_UNUSED(ok);
}
QNetworkReply* NetworkAccessManager::createRequest(Operation op, const QNetworkRequest& request, QIODevice *outgoingData)
{
QNetworkRequest req(request);
if(!QSslSocket::supportsSsl()) {
if(req.url().scheme().toLower() == QLatin1String("https"))
qCritical() << "Request using https scheme without SSL support";
} else {
QSslConfiguration sslConfig = req.sslConfiguration();
#ifdef U_NAM_DEBUG
qDebug() << Q_FUNC_INFO << "NAM: ssl support, configuring it now.";
#endif
sslConfig.setProtocol(QSsl::TlsV1SslV3);
sslConfig.setPeerVerifyMode(QSslSocket::AutoVerifyPeer);
req.setSslConfiguration(sslConfig);
}
if(op == QNetworkAccessManager::PostOperation) {
QString contentType = req.header(QNetworkRequest::ContentTypeHeader).toString();
if(contentType.isEmpty()) {
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
}
}
return QNetworkAccessManager::createRequest(op, req, outgoingData);
}
//-----------------------------------------------------------------------------
void
UrlFactory::_tryCorrectGoogleVersions(QNetworkAccessManager* networkManager)
{
QMutexLocker locker(&_googleVersionMutex);
if (_googleVersionRetrieved) {
return;
}
_googleVersionRetrieved = true;
if(networkManager)
{
QNetworkRequest qheader;
QNetworkProxy proxy = networkManager->proxy();
QNetworkProxy tProxy;
tProxy.setType(QNetworkProxy::DefaultProxy);
networkManager->setProxy(tProxy);
QSslConfiguration conf = qheader.sslConfiguration();
conf.setPeerVerifyMode(QSslSocket::VerifyNone);
qheader.setSslConfiguration(conf);
QString url = "http://maps.google.com/maps/api/js?v=3.2&sensor=false";
qheader.setUrl(QUrl(url));
QByteArray ua;
ua.append(getQGCMapEngine()->userAgent());
qheader.setRawHeader("User-Agent", ua);
_googleReply = networkManager->get(qheader);
connect(_googleReply, &QNetworkReply::finished, this, &UrlFactory::_googleVersionCompleted);
connect(_googleReply, &QNetworkReply::destroyed, this, &UrlFactory::_replyDestroyed);
connect(_googleReply, static_cast<void (QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
this, &UrlFactory::_networkReplyError);
networkManager->setProxy(proxy);
}
}
QNetworkReply* NetworkAccessManager::createRequest(QNetworkAccessManager::Operation oparation, const QNetworkRequest &request, QIODevice * outgoingData = 0) {
QNetworkRequest new_request(request);
// emulate Firefox, allowing to disable certificate
// verification using an environment variable
if (!strcmp(getenv("IGNORECERT"), "1")) {
QSslConfiguration config = request.sslConfiguration();
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1);
QNetworkRequest new_request(request);
new_request.setSslConfiguration(config);
}
QHashIterator<QString, QString> item(m_headers);
while (item.hasNext()) {
item.next();
new_request.setRawHeader(item.key().toAscii(), item.value().toAscii());
}
QNetworkReply *reply = QNetworkAccessManager::createRequest(oparation, new_request, outgoingData);
// not sure 100% if this is needed, but just in case
if (!strcmp(getenv("IGNORECERT"), "1"))
reply->ignoreSslErrors();
return reply;
};
QT_USE_NAMESPACE
//! [constructor]
SslEchoServer::SslEchoServer(quint16 port, QObject *parent) :
QObject(parent),
m_pWebSocketServer(Q_NULLPTR),
m_clients()
{
m_pWebSocketServer = new QWebSocketServer(QStringLiteral("SSL Echo Server"),
QWebSocketServer::SecureMode,
this);
QSslConfiguration sslConfiguration;
QFile certFile(QStringLiteral("./localhost.cert"));
QFile keyFile(QStringLiteral("./localhost.key"));
certFile.open(QIODevice::ReadOnly);
keyFile.open(QIODevice::ReadOnly);
QSslCertificate certificate(&certFile, QSsl::Pem);
QSslKey sslKey(&keyFile, QSsl::Rsa, QSsl::Pem);
certFile.close();
keyFile.close();
sslConfiguration.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfiguration.setLocalCertificate(certificate);
sslConfiguration.setPrivateKey(sslKey);
sslConfiguration.setProtocol(QSsl::TlsV1SslV3);
m_pWebSocketServer->setSslConfiguration(sslConfiguration);
if (m_pWebSocketServer->listen(QHostAddress::Any, port))
{
qDebug() << "SSL Echo Server listening on port" << port;
connect(m_pWebSocketServer, &QWebSocketServer::newConnection,
this, &SslEchoServer::onNewConnection);
connect(m_pWebSocketServer, &QWebSocketServer::sslErrors,
this, &SslEchoServer::onSslErrors);
}
}
QNetworkReply * CustomNetworkAccessManager ::createRequest ( Operation op, const QNetworkRequest &req, QIODevice * outgoingData ){
QSslConfiguration config = req.sslConfiguration();
config.setPeerVerifyMode(mode);
config.setProtocol(protocol);
QNetworkRequest request(req);
request.setSslConfiguration(config);
return QNetworkAccessManager::createRequest(op, request, outgoingData);
}
void SubsonicService::Send(const QUrl &url, const char *slot)
{
QNetworkRequest request(url);
// Don't try and check the authenticity of the SSL certificate - it'll almost
// certainly be self-signed.
QSslConfiguration sslconfig = QSslConfiguration::defaultConfiguration();
sslconfig.setPeerVerifyMode(QSslSocket::VerifyNone);
request.setSslConfiguration(sslconfig);
QNetworkReply *reply = network_->get(request);
connect(reply, SIGNAL(finished()), slot);
}
void SslClient::ConfigureForLMAX()
{
// configure required session protocol
QSslConfiguration config = ssl_->sslConfiguration();
QSsl::SslProtocol p = config.sessionProtocol();
if( p != proto_ )
config.setProtocol(proto_);
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setSslOption(QSsl::SslOptionDisableServerNameIndication, true);
ssl_->setSslConfiguration(config);
}
QNetworkReply* SubsonicService::Send(const QUrl& url) {
QNetworkRequest request(url);
// Don't try and check the authenticity of the SSL certificate - it'll almost
// certainly be self-signed.
QSslConfiguration sslconfig = QSslConfiguration::defaultConfiguration();
sslconfig.setPeerVerifyMode(QSslSocket::VerifyNone);
if (usesslv3_) {
sslconfig.setProtocol(QSsl::SslV3);
}
request.setSslConfiguration(sslconfig);
QNetworkReply *reply = network_->get(request);
return reply;
}
void FayeConnector::open(QString url, int port)
{
status = OPENING;
emit statusChanged(OPENING);
#ifdef SSL
QSslConfiguration sslConf;
sslConf.setPeerVerifyMode(QSslSocket::VerifyNone);
faye->setSslConfiguration(sslConf);
faye->open(QUrl(QString("wss://%1:%2/faye").arg(url).arg(port)));
#else
faye->open(QUrl(QString("ws://%1:%2/faye").arg(url).arg(port)));
#endif
}
void NetworkManager::loadSettings()
{
Settings settings;
settings.beginGroup("Web-Browser-Settings");
if (settings.value("AllowLocalCache", true).toBool()) {
m_diskCache = mApp->networkCache();
m_diskCache->setCacheDirectory(mApp->getActiveProfilPath() + "/networkcache");
m_diskCache->setMaximumCacheSize(settings.value("MaximumCacheSize", 50).toInt() * 1024 * 1024); //MegaBytes
setCache(m_diskCache);
}
m_doNotTrack = settings.value("DoNotTrack", false).toBool();
m_sendReferer = settings.value("SendReferer", true).toBool();
settings.endGroup();
m_acceptLanguage = AcceptLanguage::generateHeader(settings.value("Language/acceptLanguage", AcceptLanguage::defaultLanguage()).toStringList());
#ifdef Q_WS_WIN
// From doc:
// QSslSocket::VerifyNone ... The connection will still be encrypted, and your socket
// will still send its local certificate to the peer if it's requested.
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
config.setPeerVerifyMode(QSslSocket::VerifyNone);
QSslConfiguration::setDefaultConfiguration(config);
#endif
QString certDir = mApp->PROFILEDIR + "certificates";
QString bundlePath = certDir + "/ca-bundle.crt";
QString bundleVersionPath = certDir + "/bundle_version";
if (!QDir(certDir).exists()) {
QDir dir(mApp->PROFILEDIR);
dir.mkdir("certificates");
}
if (!QFile::exists(bundlePath)) {
QFile(":data/ca-bundle.crt").copy(bundlePath);
QFile(bundlePath).setPermissions(QFile::ReadUser | QFile::WriteUser);
QFile(":data/bundle_version").copy(bundleVersionPath);
QFile(bundleVersionPath).setPermissions(QFile::ReadUser | QFile::WriteUser);
}
QSslSocket::setDefaultCaCertificates(QSslCertificate::fromPath(bundlePath));
m_proxyFactory->loadSettings();
}
QNetworkReply *NetworkAccessManager::createRequest(Operation op, const QNetworkRequest &request, QIODevice *outgoingData)
{
QNetworkRequest req(request);
QSslConfiguration config;
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1_0);
req.setSslConfiguration(config);
// set user-agent
if (op == PostOperation){
req.setRawHeader("User-Agent", "IDP");
} else {
req.setRawHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.66 Safari/537.36 LBBROWSER");
}
QNetworkReply *reply = QNetworkAccessManager::createRequest(op, req, outgoingData);
return reply;
}
Server::Server(int port, QtWebsocket::Protocol protocol)
{
if(protocol == QtWebsocket::Tcp)
server = new QtWebsocket::QWsServer(this, protocol);
else
{
QFile file("server-key.pem");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
qDebug() << "can't open key server-key.pem";
throw -1;
}
QSslKey key(&file, QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey, QByteArray("qtwebsocket-server-key"));
file.close();
QFile file2("server-crt.pem");
if (!file2.open(QIODevice::ReadOnly | QIODevice::Text))
{
qDebug() << "cant load server certificate server-crt.pem";
throw -2;
}
QSslCertificate localCert(&file2, QSsl::Pem);
file2.close();
QSslConfiguration sslConfiguration;
sslConfiguration.setPrivateKey(key);
sslConfiguration.setLocalCertificate(localCert);
sslConfiguration.setPeerVerifyMode(QSslSocket::VerifyNone);
QList<QSslCertificate> caCerts = QSslCertificate::fromPath("ca.pem");
server = new QtWebsocket::QWsServer(this, protocol, sslConfiguration, caCerts);
}
if (! server->listen(QHostAddress::Any, port))
{
qDebug() << tr("Error: Can't launch server");
qDebug() << tr("QWsServer error : %1").arg(server->errorString());
}
else
{
qDebug() << tr("Server is listening on port %1").arg(port);
}
QObject::connect(server, SIGNAL(newConnection()), this, SLOT(processNewConnection()));
}
void MusicSourceDownloadThread::startToDownload(const QString &url)
{
m_manager = new QNetworkAccessManager(this);
QNetworkRequest request;
request.setUrl(url);
#ifndef QT_NO_SSL
connect(m_manager, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)),
SLOT(sslErrors(QNetworkReply*,QList<QSslError>)));
M_LOGGER_INFO(QString("%1 Support ssl: %2").arg(getClassName()).arg(QSslSocket::supportsSsl()));
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
request.setSslConfiguration(sslConfig);
#endif
m_reply = m_manager->get( request );
connect(m_reply, SIGNAL(finished()), SLOT(downLoadFinished()));
}
QString downloadWebPage(const QUrl &url)
{
QNetworkRequest request;
QSslConfiguration config;
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1SslV3);
request.setSslConfiguration(config);
request.setUrl(url);
QNetworkAccessManager manager;
QNetworkReply *reply = manager.get(request);
QEventLoop eventLoop;
QObject::connect(&manager, SIGNAL(finished(QNetworkReply*)), &eventLoop, SLOT(quit()));
eventLoop.exec(); //block until finish
return reply->readAll();
}
//! Authorization request
void GoogleReader::requestSidAuth()
{
QNetworkRequest request(QUrl("https://www.google.com/accounts/ClientLogin"));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QSslConfiguration sslconf;
sslconf.setPeerVerifyMode(QSslSocket::VerifyNone);
request.setSslConfiguration(sslconf);
QUrl params;
params.addQueryItem("Email", email_);
params.addQueryItem("Passwd", passwd_);
params.addQueryItem("service", "reader");
connect(&managerAuth_, SIGNAL(finished(QNetworkReply *)),
this, SLOT(replySidAuth(QNetworkReply *)));
managerAuth_.post(request, params.encodedQuery());
}
QT_USE_NAMESPACE
//! [constructor]
BCWebSocketServer::BCWebSocketServer(quint16 port, QObject *parent) :
QObject(parent),
m_pWebSocketServer(Q_NULLPTR),
m_clients()
{
m_pWebSocketServer = new QWebSocketServer(QStringLiteral("Bitcoin Exchange Server"),
QWebSocketServer::NonSecureMode, //**** To be Changed after setting up OpenSSL
this);
QSslConfiguration sslConfiguration;
QFile certFile(QStringLiteral("./localhost.cert"));
QFile keyFile(QStringLiteral("./localhost.key"));
/*if ( */
certFile.open(stderr, QIODevice::ReadOnly | QIODevice::Text ) ; //&&
keyFile.open(stderr, QIODevice::ReadOnly | QIODevice::Text) ; // )
{
QSslCertificate certificate(&certFile, QSsl::Pem);
QSslKey sslKey(&keyFile, QSsl::Rsa, QSsl::Pem);
certFile.close();
keyFile.close();
sslConfiguration.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfiguration.setLocalCertificate(certificate);
sslConfiguration.setPrivateKey(sslKey);
sslConfiguration.setProtocol(QSsl::TlsV1SslV3);
m_pWebSocketServer->setSslConfiguration(sslConfiguration);
if (m_pWebSocketServer->listen(QHostAddress::Any, port))
{
qDebug() << "Bitcoin Exchange Server listening on port" << port;
connect(m_pWebSocketServer, &QWebSocketServer::newConnection,
this, &BCWebSocketServer::onNewConnection);
connect(m_pWebSocketServer, &QWebSocketServer::sslErrors,
this, &BCWebSocketServer::onSslErrors);
}
_logged = false;
_lang = NULL;
this->data.rank = 0;
}
}
/* Keeps a reference to config, do not delete while Server exists */
bool Server::setConfig(ServerConfig *config_)
{
config = config_;
/* Enable/disable SSL certificate verification */
QSslConfiguration sslConfig = QSslConfiguration::defaultConfiguration();
sslConfig.setPeerVerifyMode(config->sslVerify ?
QSslSocket::AutoVerifyPeer :
QSslSocket::QueryPeer);
QSslConfiguration::setDefaultConfiguration(sslConfig);
group->m_max_users = config->maxUsers;
if (!group->m_topictext.Get()[0]) {
group->m_topictext.Set(config->defaultTopic.Get());
}
group->m_keepalive = config->keepAlive;
group->m_voting_threshold = config->votingThreshold;
group->m_voting_timeout = config->votingTimeout;
group->m_allow_hidden_users = config->allowHiddenUsers;
/* Only set certain settings when not active */
if (!listener.isListening()) {
group->SetProtocol(config->jammrApiUrl.isEmpty() ?
JAM_PROTO_NINJAM :
JAM_PROTO_JAMMR);
group->SetConfig(config->defaultBPI, config->defaultBPM);
}
enforceACL();
group->SetLicenseText(config->license.Get());
updateNextSession();
listener.close();
if (!listener.listen(QHostAddress::Any, config->port)) {
qWarning("Error listening on port %d!", config->port);
return false;
}
qDebug("Port: %d", config->port);
return true;
}
bool CardReader::setupSsl(QString certificatePath, QString keyPath)
{
// FIXME: This function leaks both QFile objects
QFile *certificateFile = new QFile(certificatePath);
certificateFile->open(QIODevice::ReadOnly);
if(!certificateFile->exists()) {
frontend_error("Certificate file doesn't exist", false);
return false;
}
QList<QSslCertificate> certificateChain = QSslCertificate::fromDevice(certificateFile);
certificateFile->close();
if (certificateChain.size() == 0) {
frontend_error("Invalid certificate chain specified", false);
return false;
}
QFile *keyFile = new QFile(keyPath);
keyFile->open(QIODevice::ReadOnly);
if(!keyFile->exists()) {
frontend_error("Key file doesn't exist", false);
return false;
}
QSslKey key(keyFile, QSsl::Rsa);
keyFile->close();
if(key.isNull()) {
frontend_error("Invalid key specified", false);
return false;
}
QSslConfiguration sslConfiguration = QSslConfiguration::defaultConfiguration();
sslConfiguration.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfiguration.setProtocol(QSsl::SecureProtocols);
sslConfiguration.setLocalCertificateChain(certificateChain);
sslConfiguration.setPrivateKey(key);
server = new QWebSocketServer(QStringLiteral("Arago Card Reader"), QWebSocketServer::SecureMode, this);
server->setSslConfiguration(sslConfiguration);
return true;
}
void MusicTranslationThread::startToTranslation(TranslationType from, TranslationType to, const QString &data)
{
m_manager = new QNetworkAccessManager(this);
QNetworkRequest request;
request.setUrl( TRANSLATION_URL.arg(mapTypeFromEnumToString(from))
.arg(data).arg(mapTypeFromEnumToString(to)) );
#ifndef QT_NO_SSL
connect(m_manager, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)),
SLOT(sslErrors(QNetworkReply*,QList<QSslError>)));
M_LOGGER_INFO(QString("%1 Support ssl: %2").arg(getClassName()).arg(QSslSocket::supportsSsl()));
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
request.setSslConfiguration(sslConfig);
#endif
m_reply = m_manager->get( request );
connect(m_reply, SIGNAL(finished()), SLOT(downLoadFinished()));
}
void ProfileController::loadProfile(const QString& url) {
// -----------------------------------------------------------------------------------------
// request page
QNetworkRequest request(DefineConsts::FORUM_URL+url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfig.setPeerVerifyDepth(1);
sslConfig.setProtocol(QSsl::TlsV1);
sslConfig.setSslOption(QSsl::SslOptionDisableSessionTickets, true);
request.setSslConfiguration(sslConfig);
QNetworkReply* reply = HFRNetworkAccessManager::get()->get(request);
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(checkReply()));
Q_ASSERT(ok);
Q_UNUSED(ok);
}
//! [1]
void PostHttp::post(const QString &body)
{
const QUrl url("http://httpbin.org/post");
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/plain");
if (AppSettings::isUsingHttps()) {
request.setUrl(QUrl("https://httpbin.org/post"));
QSslConfiguration config = request.sslConfiguration();
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1);
request.setSslConfiguration(config);
}
QNetworkReply* reply = m_networkAccessManager->post(request, body.toAscii());
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(onGetReply()));
Q_ASSERT(ok);
Q_UNUSED(ok);
}
//! [1]
void PostHttp::post(const QString &body, const QString &body2)
{
const QUrl url("http://kreativeco.com/marsh/actions/webservices.php?task=login&user="******"&password="******"text/plain");
if (AppSettings::isUsingHttps()) {
request.setUrl(QUrl("http://kreativeco.com/marsh/actions/webservices.php?task=login&user="******"&password=" +body2));
QSslConfiguration config = request.sslConfiguration();
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(QSsl::TlsV1);
request.setSslConfiguration(config);
}
QNetworkReply* reply = m_networkAccessManager->post(request, body.toAscii());
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(onGetReply()));
Q_ASSERT(ok);
Q_UNUSED(ok);
}
void SmileyPickerController::getSmiley(const QString &keyword) {
if(keyword.isEmpty())
return;
// list green + yellow flags
const QUrl url(DefineConsts::FORUM_URL + "/message-smi-mp-aj.php?config=hfr.inc&findsmilies=" + keyword);
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfig.setPeerVerifyDepth(1);
sslConfig.setProtocol(QSsl::TlsV1);
sslConfig.setSslOption(QSsl::SslOptionDisableSessionTickets, true);
request.setSslConfiguration(sslConfig);
QNetworkReply* reply = HFRNetworkAccessManager::get()->get(request);
bool ok = connect(reply, SIGNAL(finished()), this, SLOT(checkReply()));
Q_ASSERT(ok);
Q_UNUSED(ok);
// ----------------------------------------------------------------------------------------------
// get the dataModel of the listview if not already available
using namespace bb::cascades;
if(m_ListView == NULL) {
qWarning() << "did not received the listview. quit.";
return;
}
GroupDataModel* dataModel = dynamic_cast<GroupDataModel*>(m_ListView->dataModel());
dataModel->clear();
}
QNetworkReply * SalorNetwork::createRequest(
QNetworkAccessManager::Operation operation,
const QNetworkRequest & originalRequest,
QIODevice * device)
{
QNetworkRequest request = originalRequest;
qDebug() << "[SalorNetwork]" << "[createRequest] Beginning.";
if (
(originalRequest.url().toString().indexOf(".css") != -1) ||
(originalRequest.url().toString().indexOf(".png") != -1) ||
(originalRequest.url().toString().indexOf(".js") != -1)
) {
request.setAttribute(QNetworkRequest::CacheLoadControlAttribute,
QNetworkRequest::PreferCache);
} else {
qDebug() << originalRequest.url().toString() << " : " << QDateTime::currentDateTime();
}
QSslConfiguration c = request.sslConfiguration();
c.setPeerVerifyMode(QSslSocket::VerifyNone);
request.setSslConfiguration(c);
qDebug() << "[SalorNetwork]" << "[createRequest] setting of ssl crap complete. ";
return QNetworkAccessManager::createRequest(operation, request, device);
}
//===================
// PRIVATE
//===================
bool WebServer::setupWebSocket(quint16 port){
WSServer = new QWebSocketServer("sysadm-server", QWebSocketServer::SecureMode, this);
//SSL Configuration
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
QFile CF( QStringLiteral(SSLCERTFILE) );
if(CF.open(QIODevice::ReadOnly) ){
QSslCertificate CERT(&CF,QSsl::Pem);
config.setLocalCertificate( CERT );
CF.close();
}else{
qWarning() << "Could not read WS certificate file:" << CF.fileName();
}
QFile KF( QStringLiteral(SSLKEYFILE));
if(KF.open(QIODevice::ReadOnly) ){
QSslKey KEY(&KF, QSsl::Rsa, QSsl::Pem);
config.setPrivateKey( KEY );
KF.close();
}else{
qWarning() << "Could not read WS key file:" << KF.fileName();
}
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(SSLVERSION);
WSServer->setSslConfiguration(config);
//Setup Connections
connect(WSServer, SIGNAL(newConnection()), this, SLOT(NewSocketConnection()) );
connect(WSServer, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(NewConnectError(QAbstractSocket::SocketError)) );
// -- websocket specific signals
connect(WSServer, SIGNAL(closed()), this, SLOT(ServerClosed()) );
connect(WSServer, SIGNAL(serverError(QWebSocketProtocol::CloseCode)), this, SLOT(ServerError(QWebSocketProtocol::CloseCode)) );
connect(WSServer, SIGNAL(originAuthenticationRequired(QWebSocketCorsAuthenticator*)), this, SLOT(OriginAuthRequired(QWebSocketCorsAuthenticator*)) );
connect(WSServer, SIGNAL(peerVerifyError(const QSslError&)), this, SLOT(PeerVerifyError(const QSslError&)) );
connect(WSServer, SIGNAL(sslErrors(const QList<QSslError>&)), this, SLOT(SslErrors(const QList<QSslError>&)) );
connect(WSServer, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(ConnectError(QAbstractSocket::SocketError)) );
//Now start the server
return WSServer->listen(QHostAddress::Any, port);
}
void MusicDataDownloadThread::startRequest(const QUrl &url)
{
m_timer.start(1000);
QNetworkRequest request;
request.setUrl(url);
#ifndef QT_NO_SSL
QSslConfiguration sslConfig = request.sslConfiguration();
sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
request.setSslConfiguration(sslConfig);
#endif
m_reply = m_manager->get( request );
connect(m_reply, SIGNAL(finished()), this, SLOT(downLoadFinished()));
connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
SLOT(replyError(QNetworkReply::NetworkError)) );
connect(m_reply, SIGNAL(readyRead()),this, SLOT(downLoadReadyRead()));
connect(m_reply, SIGNAL(downloadProgress(qint64, qint64)), SLOT(downloadProgress(qint64, qint64)));
/// only download music data can that show progress
if(m_downloadType == Download_Music && !m_redirection)
{
M_CONNECTION_PTR->connectMusicDownload(this);
m_createItemTime = QDateTime::currentMSecsSinceEpoch();
emit createDownloadItem(m_savePathName, m_createItemTime);
}
}
