void QNetworkAccessHttpBackend::open()
{
QUrl url = request().url();
bool encrypt = url.scheme() == QLatin1String("https");
setAttribute(QNetworkRequest::ConnectionEncryptedAttribute, encrypt);
// set the port number in the reply if it wasn't set
url.setPort(url.port(encrypt ? DefaultHttpsPort : DefaultHttpPort));
// check if we have an open connection to this host
QByteArray cacheKey = makeCacheKey(this->url());
QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getCache(this);
if ((http = static_cast<QNetworkAccessHttpBackendCache *>(cache->requestEntryNow(cacheKey))) == 0) {
// no entry in cache; create an object
http = new QNetworkAccessHttpBackendCache(url.host(), url.port(), encrypt);
#ifndef QT_NO_NETWORKPROXY
QNetworkProxy networkProxy = proxy();
if (encrypt || networkProxy.type() == QNetworkProxy::HttpProxy)
http->setTransparentProxy(networkProxy);
else
http->setCacheProxy(networkProxy);
#endif
cache->addEntry(cacheKey, http);
}
setupConnection();
postRequest();
}
int
SmugMug::WebService::_httpGet (const QUrl &Url, QIODevice *to) {
int id = 0;
if (Url.port (80) == 443) {
_ssl = true;
_https.setHost (Url.host (), Url.port (443));
id = _https.get (Url.toEncoded (), to);
}
else {
_ssl = false;
_http.setHost (Url.host (), Url.port (80));
id = _http.get (Url.toEncoded (), to);
}
if (id) {
emit actionStarted ();
qDebug () << "actionStarted: " << id;
}
return id;
}
void SwitchAccountDialog::initAccountList()
{
accounts_ = seafApplet->accountManager()->loadAccounts();
int i, n = accounts_.size();
for (i = 0; i < n; i++) {
Account account = accounts_[i];
QIcon icon = QIcon(":/images/account.svg");
QUrl url = account.serverUrl;
QString text = account.username + "\t" + url.host();
if (url.port() > 0) {
text += QString().sprintf(":%d", url.port());
}
if (url.path().length() > 0) {
text += url.path();
}
QListWidgetItem *item = new QListWidgetItem(icon, text);
mAccountsList->addItem(item);
}
if (!accounts_.empty()) {
mAccountsList->setCurrentRow(0);
}
mAccountsList->setSelectionMode(QAbstractItemView::SingleSelection);
}
int
SmugMug::WebService::_httpRequest (
const QUrl &Url,
const QHttpRequestHeader &Header,
const QByteArray &Data) {
int id = 0;
if (Url.port (80) == 443) {
_ssl = true;
_https.setHost (Url.host (), Url.port (80));
id = _https.request (Header, Data);
}
else {
_ssl = false;
_http.setHost (Url.host (), Url.port (80));
id = _http.request (Header, Data);
}
if (id) {
emit actionStarted ();
qDebug () << "actionStarted: " << id;
}
return id;
}
void RtspSocket::stream(QUrl url,QString chid, bool aud)
{
qDebug("Start Streaming");
audioEnabled = aud;
channelid = chid;
if(url.port() == -1 || url.port()==0 )
url.setPort(554);
QDEBUG << url.toString();
qWarning() << tr("Stream: ") + url.toString();
if( state == statePlay || state == statePlaying || state == stateTeardown )
{
state = stateTeardown;
// set this after the teardown message
_url = url;
} else
{
_url = url;
// restart the state machine
state = stateInit;
}
slotStateMachine();
}
void VagrantProviderWidget::loadData()
{
VagrantSettings vagrantSettings;
QUrl url;
QString temp;
m_cloudDialog->m_iAcceptCheckBox->setChecked(vagrantSettings.userAgreementSigned());
bool isChecked = true;
m_runOnStartUpCheckBox->setChecked(isChecked);
m_serverUsernameLineEdit->setText(vagrantSettings.username().c_str());
m_serverPasswordLineEdit->setText(vagrantSettings.password().c_str());
url = vagrantSettings.serverUrl();
m_serverAddressIpLineEdit->setText(url.host());
m_serverPortIpLineEdit->setText(temp.setNum(url.port()));
m_serverDirLineEdit->setText(toQString(vagrantSettings.serverPath()));
url = vagrantSettings.serverUrl();
m_workerAddressIpLineEdit->setText(url.host());
m_workerPortIpLineEdit->setText(temp.setNum(url.port()));
m_workerDirLineEdit->setText(toQString(vagrantSettings.workerPath()));
//m_waitCheckBox->setChecked(vagrantSettings.terminationDelayEnabled());
//m_waitLineEdit->setText(temp.setNum(vagrantSettings.terminationDelay()));
}
bool Http::get(QUrl url, QByteArray data, QByteArray &result, QMap<QString, QString> cookies, int timeout)
{
QByteArray body;
QByteArray cookiesData = convertData(cookies);
QString urlstr;
if (!data.isEmpty()) {
urlstr.append(url.toEncoded());
urlstr.append('?');
urlstr.append(data);
} else {
urlstr = url.toEncoded();
}
body.append(QString("GET %1 HTTP/1.1\r\n").arg(urlstr));
body.append(QString("Host: %1:%2\r\n").arg(url.host()).arg(url.port()));
body.append("Connection: close\r\n");
if (!cookies.isEmpty()) {
body.append("Cookie: ");
body.append(cookiesData);
body.append("\r\n");
}
body.append("\r\n");
return send(url.host(),url.port(),body,result,timeout);
}
void MediaCaptureDevicesDispatcher::handleMediaAccessPermissionResponse(content::WebContents *webContents, const QUrl &securityOrigin
, WebContentsAdapterClient::MediaRequestFlags authorizationFlags)
{
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
content::MediaStreamDevices devices;
std::map<content::WebContents*, RequestsQueue>::iterator it = m_pendingRequests.find(webContents);
if (it == m_pendingRequests.end())
// WebContents has been destroyed. Don't need to do anything.
return;
RequestsQueue &queue(it->second);
if (queue.empty())
return;
content::MediaStreamRequest &request = queue.front().request;
const QUrl requestSecurityOrigin(toQt(request.security_origin));
bool securityOriginsMatch = (requestSecurityOrigin.host() == securityOrigin.host()
&& requestSecurityOrigin.scheme() == securityOrigin.scheme()
&& requestSecurityOrigin.port() == securityOrigin.port());
if (!securityOriginsMatch)
qWarning("Security origin mismatch for media access permission: %s requested and %s provided\n", qPrintable(requestSecurityOrigin.toString())
, qPrintable(securityOrigin.toString()));
bool microphoneRequested =
(request.audio_type && authorizationFlags & WebContentsAdapterClient::MediaAudioCapture);
bool webcamRequested =
(request.video_type && authorizationFlags & WebContentsAdapterClient::MediaVideoCapture);
if (securityOriginsMatch && (microphoneRequested || webcamRequested)) {
switch (request.request_type) {
case content::MEDIA_OPEN_DEVICE:
Q_UNREACHABLE(); // only speculative as this is for Pepper
getDefaultDevices("", "", microphoneRequested, webcamRequested, &devices);
break;
case content::MEDIA_DEVICE_ACCESS:
case content::MEDIA_GENERATE_STREAM:
case content::MEDIA_ENUMERATE_DEVICES:
getDefaultDevices(request.requested_audio_device_id, request.requested_video_device_id,
microphoneRequested, webcamRequested, &devices);
break;
}
}
content::MediaResponseCallback callback = queue.front().callback;
queue.pop_front();
if (!queue.empty()) {
// Post a task to process next queued request. It has to be done
// asynchronously to make sure that calling infobar is not destroyed until
// after this function returns.
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE, base::Bind(&MediaCaptureDevicesDispatcher::ProcessQueuedAccessRequest, base::Unretained(this), webContents));
}
callback.Run(devices, devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE : content::MEDIA_DEVICE_OK, scoped_ptr<content::MediaStreamUI>());
}
void LocalQmlProfilerRunnerTest::testFindFreePort()
{
QUrl serverUrl = Utils::urlFromLocalHostAndFreePort();
QVERIFY(serverUrl.port() != -1);
QVERIFY(!serverUrl.host().isEmpty());
QTcpServer server;
QVERIFY(server.listen(QHostAddress(serverUrl.host()), serverUrl.port()));
}
CetonRTSP::CetonRTSP(const QUrl &url) :
_ip(url.host()),
_port((url.port() >= 0) ? url.port() : 554),
_sequenceNumber(0),
_sessionId("0"),
_responseCode(-1)
{
_requestUrl = url.toString();
}
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
QStringList args = app.arguments();
QString appName = args.takeFirst();
bool notification = args.contains("-n");
if (notification)
args.removeAll("-n");
if (args.size() < 2) {
qDebug("usage: %s [-n] <service> <method> <arguments>", appName.toLocal8Bit().data());
return -1;
}
// try to process socket
QIODevice *device = 0;
QScopedPointer<QIODevice> devicePtr(device);
QString service = args.takeFirst();
QUrl serviceUrl = QUrl::fromUserInput(service);
QHostAddress serviceAddress(serviceUrl.host());
if (serviceAddress.isNull()) {
QLocalSocket *localSocket = new QLocalSocket;
device = localSocket;
localSocket->connectToServer(service);
if (!localSocket->waitForConnected(5000)) {
qDebug("could not connect to service: %s", service.toLocal8Bit().data());
return -1;
}
} else {
QTcpSocket *tcpSocket = new QTcpSocket;
device = tcpSocket;
int servicePort = serviceUrl.port() ? serviceUrl.port() : 5555;
tcpSocket->connectToHost(serviceAddress, servicePort);
if (!tcpSocket->waitForConnected(5000)) {
qDebug("could not connect to host at %s:%d", serviceUrl.host().toLocal8Bit().data(),
servicePort);
return -1;
}
}
QJsonRpcSocket socket(device);
QString method = args.takeFirst();
QVariantList arguments;
foreach (QString arg, args)
arguments.append(arg);
QJsonRpcMessage request = notification ? QJsonRpcMessage::createNotification(method, arguments) :
QJsonRpcMessage::createRequest(method, arguments);
QJsonRpcMessage response = socket.sendMessageBlocking(request, 5000);
if (response.type() == QJsonRpcMessage::Error) {
qDebug("error(%d): %s", response.errorCode(), response.errorMessage().toLocal8Bit().data());
return -1;
}
qDebug() << response.result();
}
static void setApplicationProxy(QUrl url)
{
if (!url.isEmpty())
{
if (url.port() == -1)
url.setPort(8080);
QNetworkProxy proxy(QNetworkProxy::HttpProxy, url.host(), url.port(), url.userName(), url.password());
QNetworkProxy::setApplicationProxy(proxy);
}
}
void NfcHandler::ndefMessageRead(QNdefMessage message)
{
foreach (const QNdefRecord &record, message) {
if (record.isRecordType<QNdefNfcUriRecord>()) {
QNdefNfcUriRecord uriRecord(record);
qDebug() << "********** Got URI record:" << uriRecord.uri();
QUrl uri = uriRecord.uri();
if(uri.scheme() == "kodi") {
qDebug() << "Got and xmbc:// uri" << uri.host() << uri.port() << uri.path();
KodiHost host;
host.setAddress(uri.host());
host.setPort(uri.port());
QString path = uri.path().right(uri.path().length() - 1);
if(path.split('/').count() >= 1) {
host.setHostname(path.split('/').first());
}
if(path.split('/').count() >= 2) {
host.setHwAddr(path.split('/').at(1));
}
qDebug() << "Should connect to" << host.address() << ':' << host.port() << host.hostname() << host.hwAddr();
int index = Kodi::instance()->hostModel()->insertOrUpdateHost(host);
Kodi::instance()->hostModel()->connectToHost(index);
} else {
qDebug() << "NDEF uri record not compatible with kodimote:" << uriRecord.uri();
emit tagError(tr("NFC tag is not compatible with Kodimote. In order to use it with Kodimote you need to write connection information to it."));
}
} else if (record.isRecordType<QNdefNfcTextRecord>()) {
QNdefNfcTextRecord textRecord(record);
qDebug() << "********** Got Text record:" << textRecord.text();
if(textRecord.text().startsWith("kodi:")) {
qDebug() << "outdated tag detected";
emit tagError(tr("NFC tag is outdated. In order to use it with Kodimote you need to update it by rewriting connection information to it."));
} else {
emit tagError(tr("NFC tag is not compatible with Kodimote. In order to use it with Kodimote you need to write connection information to it."));
}
}else {
if (record.typeNameFormat() == QNdefRecord::Mime &&
record.type().startsWith("image/")) {
qDebug() << "got image...";
}else if (record.typeNameFormat() == QNdefRecord::NfcRtd ) {
qDebug() << "Got Rtd tag" << record.payload();
QNdefNfcUriRecord uri(record);
qDebug() << "uri:" << uri.uri();
}else if (record.typeNameFormat() == QNdefRecord::ExternalRtd ){
qDebug() << "Got ExtRtd tag";
} else if (record.isEmpty()) {
qDebug() << "got empty record...";
} else {
qDebug() << "got unknown ndef message type";
}
emit tagError(tr("NFC tag is not compatible with Kodimote. In order to use it with Kodimote you need to write connection information to it."));
}
}
}
void FileDownloader::download(QUrl url) {
QHttp::ConnectionMode mode = url.scheme().toLower() == "https" ? QHttp::ConnectionModeHttps : QHttp::ConnectionModeHttp;
http->setHost(url.host(), mode, url.port() == -1 ? 0 : url.port());
if (!url.userName().isEmpty())
http->setUser(url.userName(), url.password());
http_request_aborted = false;
http_get_id = http->get(url.path(), &buffer);
setLabelText(tr("Downloading %1").arg(url.toString()));
}
void setup(const QUrl &uri, const HttpHeaders &_headers, const QHostAddress &connectAddr = QHostAddress(), int connectPort = -1, int _maxRedirects = -1)
{
assert(!method.isEmpty());
QUrl tmp = uri;
if(connectPort != -1)
tmp.setPort(connectPort);
else if(tmp.port() == -1)
{
if(uri.scheme() == "https")
tmp.setPort(443);
else
tmp.setPort(80);
}
curl_easy_setopt(easy, CURLOPT_URL, tmp.toEncoded().data());
if(!connectAddr.isNull())
{
curl_slist_free_all(dnsCache);
QByteArray cacheEntry = tmp.encodedHost() + ':' + QByteArray::number(tmp.port()) + ':' + connectAddr.toString().toUtf8();
dnsCache = curl_slist_append(dnsCache, cacheEntry.data());
curl_easy_setopt(easy, CURLOPT_RESOLVE, dnsCache);
}
HttpHeaders headers = _headers;
bool chunked = false;
if(headers.contains("Content-Length"))
{
curl_off_t content_len = (curl_off_t)headers.get("Content-Length").toLongLong();
/*if(method == "POST")
curl_easy_setopt(easy, CURLOPT_POSTFIELDSIZE_LARGE, content_len);
else*/
curl_easy_setopt(easy, CURLOPT_INFILESIZE_LARGE, content_len);
// curl will set this for us
headers.removeAll("Content-Length");
}
else
{
if(expectBody)
chunked = true;
else if(alwaysSetBody)
curl_easy_setopt(easy, CURLOPT_INFILESIZE_LARGE, (curl_off_t)0);
}
curl_slist_free_all(headersList);
foreach(const HttpHeader &h, headers)
{
QByteArray i = h.first + ": " + h.second;
headersList = curl_slist_append(headersList, i.data());
}
int Url::port ( lua_State * L )// const : int
{
QUrl* lhs = ValueInstaller2<QUrl>::check( L, 1 );
if(Util::isNum( L, 2 ))
{
Util::push( L, lhs->port(Util::toInt( L, 2 )) );
}
else
{
Util::push( L, lhs->port() );
}
return 1;
}
HttpEngine::HttpEngine(QUrl url, QUrl referrer, QUuid proxyUuid) : m_pRemote(0), m_url(url)
{
QString user_info;
QString query, host;
// QList<Proxy> listProxy = Proxy::loadProxys();
m_proxyData.nType = Proxy::ProxyNone;
host = url.host();
if(url.port(80) != 80)
host += QString(":") + QString::number(url.port(80));
if (Proxy::isProxyEnabled()){
Proxy p = Proxy:: loadProxy();
if(p.uuid == proxyUuid)
{
m_proxyData = p;
}
}
if(!url.hasQuery())
query = url.path();
else
query = url.path()+"?"+url.encodedQuery();
if(query.isEmpty())
query = "/";
if(m_proxyData.nType == Proxy::ProxyHttp)
{
m_header.setRequest("GET", QString("%1://%2%3").arg(url.scheme()).arg(host).arg(query));
if(!m_proxyData.strUser.isEmpty())
m_header.addValue("Proxy-Authorization", QString("Basic %1").arg((QString) (m_proxyData.strUser+":"+m_proxyData.strPassword).toUtf8().toBase64()) );
}
else
m_header.setRequest("GET", query);
user_info = url.userInfo();
if(!user_info.isEmpty())
m_header.addValue("Authorization", QString("Basic %1").arg( QString(user_info.toUtf8().toBase64()) ));
if(referrer.isValid())
m_header.addValue("Referrer", referrer.toString());
m_header.addValue("Host", host);
m_header.addValue("Connection", "close");
}
void Config::setSystemProxy(bool checked)
{
ui.proxyPort->setEnabled(!checked);
ui.proxyHost->setEnabled(!checked);
ui.proxyUser->setEnabled(!checked);
ui.proxyPass->setEnabled(!checked);
if(checked) {
// save values in input box
proxy.setScheme("http");
proxy.setUserName(ui.proxyUser->text());
proxy.setPassword(ui.proxyPass->text());
proxy.setHost(ui.proxyHost->text());
proxy.setPort(ui.proxyPort->text().toInt());
// show system values in input box
QUrl envproxy = System::systemProxy();
qDebug() << "[Config] setting system proxy" << envproxy;
ui.proxyHost->setText(envproxy.host());
ui.proxyPort->setText(QString("%1").arg(envproxy.port()));
ui.proxyUser->setText(envproxy.userName());
ui.proxyPass->setText(envproxy.password());
if(envproxy.host().isEmpty() || envproxy.port() == -1) {
qDebug() << "[Config] sytem proxy is invalid.";
QMessageBox::warning(this, tr("Proxy Detection"),
tr("The System Proxy settings are invalid!\n"
"Rockbox Utility can't work with this proxy settings. "
"Make sure the system proxy is set correctly. Note that "
"\"proxy auto-config (PAC)\" scripts are not supported by "
"Rockbox Utility. If your system uses this you need "
"to use manual proxy settings."),
QMessageBox::Ok ,QMessageBox::Ok);
// the current proxy settings are invalid. Check the saved proxy
// type again.
if(RbSettings::value(RbSettings::ProxyType).toString() == "manual")
ui.radioManualProxy->setChecked(true);
else
ui.radioNoProxy->setChecked(true);
}
}
else {
ui.proxyHost->setText(proxy.host());
if(proxy.port() > 0)
ui.proxyPort->setText(QString("%1").arg(proxy.port()));
else ui.proxyPort->setText("");
ui.proxyUser->setText(proxy.userName());
ui.proxyPass->setText(proxy.password());
}
}
void HttpPoll::connectToHost(const QString &proxyHost, int proxyPort, const QUrl &url)
{
resetConnection(true);
bool useSsl = false;
d->port = 80;
// using proxy?
if(!proxyHost.isEmpty()) {
d->host = proxyHost;
d->port = proxyPort;
d->url = url;
d->use_proxy = true;
}
else {
d->host = url.host();
if(url.port() != -1)
d->port = url.port();
else if (url.scheme() == "https") {
d->port = 443;
useSsl = true;
}
#if QT_VERSION < 0x050000
d->url = url.path() + "?" + url.encodedQuery();
#else
d->url.setUrl(url.path() + "?" + url.query(QUrl::FullyEncoded), QUrl::StrictMode);
#endif
d->use_proxy = false;
}
resetKey();
bool last;
QString key = getKey(&last);
#ifdef PROX_DEBUG
fprintf(stderr, "HttpPoll: Connecting to %s:%d [%s]", d->host.latin1(), d->port, d->url.latin1());
if(d->user.isEmpty())
fprintf(stderr, "\n");
else
fprintf(stderr, ", auth {%s,%s}\n", d->user.latin1(), d->pass.latin1());
#endif
QPointer<QObject> self = this;
syncStarted();
if(!self)
return;
d->state = 1;
d->http.setUseSsl(useSsl);
d->http.setAuth(d->user, d->pass);
d->http.post(d->host, d->port, d->url, makePacket("0", key, "", QByteArray()), d->use_proxy);
}
int
LastFmParser::make_request (const QString &artist,
const QUrl &url)
{
QBuffer *buff = new QBuffer (this);
buff->open (QIODevice::WriteOnly);
m_http->setHost (url.host (), url.port () != -1 ? url.port () : 80);
int id = m_http->get (QString (url.toEncoded ()), buff);
m_requests[id] = buff;
m_cache_map[id] = artist;
return id;
}
QList<QNetworkProxy> PackageManagerProxyFactory::queryProxy(const QNetworkProxyQuery &query)
{
const Settings &settings = m_core->settings();
QList<QNetworkProxy> list;
if (settings.proxyType() == Settings::SystemProxy) {
#if defined(Q_OS_UNIX) && !defined(Q_OS_OSX)
QUrl proxyUrl = QUrl::fromUserInput(QString::fromUtf8(qgetenv("http_proxy")));
if (proxyUrl.isValid()) {
return list << QNetworkProxy(QNetworkProxy::HttpProxy, proxyUrl.host(), proxyUrl.port(),
proxyUrl.userName(), proxyUrl.password());
}
#endif
return QNetworkProxyFactory::systemProxyForQuery(query);
}
if ((settings.proxyType() == Settings::NoProxy))
return list << QNetworkProxy(QNetworkProxy::NoProxy);
if (query.queryType() == QNetworkProxyQuery::UrlRequest) {
if (query.url().scheme() == QLatin1String("ftp"))
return list << settings.ftpProxy();
if ((query.url().scheme() == QLatin1String("http"))
|| (query.url().scheme() == QLatin1String("https"))) {
return list << settings.httpProxy();
}
}
return list << QNetworkProxy(QNetworkProxy::DefaultProxy);
}
bool ConnectionBackend::connectToRemote(const QUrl &url)
{
Q_ASSERT(state == Idle);
Q_ASSERT(!socket);
Q_ASSERT(!localServer); // !tcpServer as well
if (mode == LocalSocketMode) {
KLocalSocket *sock = new KLocalSocket(this);
QString path = url.path();
#if 0
// TODO: Activate once abstract socket support is implemented in Qt.
KLocalSocket::LocalSocketType type = KLocalSocket::UnixSocket;
if (url.queryItem(QLatin1String("abstract")) == QLatin1String("1")) {
type = KLocalSocket::AbstractUnixSocket;
}
#endif
sock->connectToPath(path);
socket = sock;
} else {
socket = new QTcpSocket(this);
socket->connectToHost(url.host(), url.port());
if (!socket->waitForConnected(1000)) {
state = Idle;
qCDebug(KIO_CORE) << "could not connect to" << url;
return false;
}
}
connect(socket, SIGNAL(readyRead()), SLOT(socketReadyRead()));
connect(socket, SIGNAL(disconnected()), SLOT(socketDisconnected()));
state = Connected;
return true;
}
void HttpGet::downloadFile(const QUrl &url,const QString &path)
{
qDebug()<<url.path();
file = new QFile(path);
if (!file->open(QIODevice::WriteOnly))
{
delete file;
file = 0;
return;
}
QHttp::ConnectionMode mode = url.scheme().toLower() == "https" ? QHttp::ConnectionModeHttps : QHttp::ConnectionModeHttp;
http->setHost(url.host(),mode,url.port()==-1? 0:url.port());
http->get(url.path(),file);
http->close();
}
void NewsFeed::getUpdates() {
QMap<QString, QUrl>::iterator it = m_urls.begin();
while (it != m_urls.end()) {
QString title = it.key();
logDebug("Getting updates for feed " + title);
QUrl url = it.value();
if (m_links[title]) {
m_links[title]->deleteLater();
}
m_links[title] = new QHttp(url.host(), url.port(80), this);
m_reqs[m_links[title]->get(url.path())] = title;
connect(
m_links[title], SIGNAL(requestStarted(int)),
SLOT(requestStarted(int))
);
connect(
m_links[title], SIGNAL(requestFinished(int, bool)),
SLOT(requestFinished(int, bool))
);
++it;
}
QSettings conf(confDir() + "gui.ini", QSettings::IniFormat);
conf.setValue(
objectName() + "Updated",
QDateTime::currentDateTime().toString(Qt::ISODate)
);
if (!m_timer->isActive()) {
logDebug("Next feeds update in one hour.");
m_timer->start(1000 * 60 * 60);
}
}
int QUrlProto::port(int defaultPort) const
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
return item->port(defaultPort);
return 0;
}
void AccessManager::slotAuthenticationRequired(QNetworkReply *reply, QAuthenticator *authenticator)
{
#ifndef TOKEN_AUTH_ONLY
// do not handle 401 created by the networkjobs. We may want
// to eventually exempt some, but for now we need
// it only for other things, e.g. the browser. Would we handle
// network jobs, this would break the wizard logic
if (reply->property("doNotHandleAuth").toBool()) {
return;
}
QUrl url = reply->url();
// show only scheme, host and port
QUrl reducedUrl;
reducedUrl.setScheme(url.scheme());
reducedUrl.setHost(url.host());
reducedUrl.setPort(url.port());
AuthenticationDialog dialog(authenticator->realm(), reducedUrl.toString());
if (dialog.exec() == QDialog::Accepted) {
authenticator->setUser(dialog.user());
authenticator->setPassword(dialog.password());
}
#else
Q_UNUSED(reply) Q_UNUSED(authenticator)
Q_ASSERT(!"OCC::AccessManager::slotAuthenticationRequired called");
#endif
}
void BrisaControlPoint::replyFinished(QNetworkReply *reply) {
QTemporaryFile *rootXml = new QTemporaryFile();
if (!rootXml->open()) {
qWarning() << "Brisa Control Point: Failed to open file for writing root XML.";
} else {
rootXml->write(reply->readAll());
rootXml->seek(0);
QUrl *urlBase = new QUrl(reply->url());
BrisaControlPointDevice *device = new BrisaControlPointDevice(rootXml, urlBase);
/* Fix embedded devices host/port attributes */
QList<BrisaControlPointService*> serviceList = device->getServiceList();
foreach(BrisaControlPointService *s, serviceList) {
s->setAttribute(BrisaControlPointService::Host, urlBase->host());
s->setAttribute(BrisaControlPointService::Port,
QString().setNum(urlBase->port()));
}
rootXml->remove();
delete rootXml;
delete urlBase;
// deleteLater as per Qt documentation (see Detailed Description section of
// QNetworkAccessManager class documentation for more details;
reply->deleteLater();
emit deviceFound(device);
}
bool ImageWidget::getFile(const QUrl &url)
{
if (!url.isValid()) {
qDebug() << "Error: Invalid URL";
return false;
}
if (url.scheme() != "http") {
qDebug() << "Error: URL must start with 'http:'";
return false;
}
if (url.path().isEmpty()) {
qDebug() << "Error: URL has no path";
return false;
}
QString localFileName = QFileInfo(url.path()).fileName();
if (localFileName.isEmpty())
localFileName = "httpget.out";
file.setFileName(QDir::tempPath()+"/"+localFileName);
if (!file.open(QIODevice::WriteOnly)) {
qDebug() << "Error: Cannot open " << qPrintable(file.fileName())
<< " for writing: " << qPrintable(file.errorString());
return false;
}
http.setHost(url.host(), url.port(80));
http.get(url.path(), &file);
http.close();
return true;
}
bool WebPage::acceptNavigationRequest(QWebFrame*,
const QNetworkRequest& request,
NavigationType navType)
{
QUrl url = request.url();
if (url.toString() == QString::fromAscii("about:blank"))
return true;
if (url.scheme() != QString::fromAscii("http")
&& url.scheme() != QString::fromAscii("https")
&& url.scheme() != QString::fromAscii("mailto"))
{
return false;
}
if (baseUrl_.isEmpty() ||
(url.scheme() == baseUrl_.scheme()
&& url.host() == baseUrl_.host()
&& url.port() == baseUrl_.port()))
{
navigated_ = true;
return true;
}
else
{
QDesktopServices::openUrl(url);
if (!navigated_)
this->view()->window()->deleteLater();
return false;
}
}
/*!
\a url points to the new WAP gateway.
\sa gateway()
*/
void QWapAccount::setGateway( const QUrl& url )
{
d->conf->setValue( QLatin1String("Wap/Gateway"), url.host() );
d->conf->setValue( QLatin1String("Wap/UserName"), url.userName() );
d->conf->setValue( QLatin1String("Wap/Password"), url.password() );
d->conf->setValue( QLatin1String("Wap/Port"), url.port() );
}
