KIO::MetaData Settings::accountData() const
{
KConfig config("scalixadminrc");
KConfigGroup group(&config, "Account");
KIO::MetaData data;
data.insert("auth", group.readEntry("auth"));
data.insert("tls", group.readBoolEntry("use-tls") ? "on" : "off");
return data;
}
void AccessManager::AccessManagerPrivate::setMetaDataForRequest(QNetworkRequest request, KIO::MetaData& metaData)
{
// Add any meta data specified within request...
QVariant userMetaData = request.attribute (static_cast<QNetworkRequest::Attribute>(MetaData));
if (userMetaData.isValid() && userMetaData.type() == QVariant::Map)
metaData += userMetaData.toMap();
metaData.insert(QL1S("PropagateHttpHeader"), QL1S("true"));
if (request.hasRawHeader("User-Agent")) {
metaData.insert(QL1S("UserAgent"), request.rawHeader("User-Agent"));
request.setRawHeader("User-Agent", QByteArray());
}
if (request.hasRawHeader("Accept")) {
metaData.insert(QL1S("accept"), request.rawHeader("Accept"));
request.setRawHeader("Accept", QByteArray());
}
if (request.hasRawHeader("Accept-Charset")) {
metaData.insert(QL1S("Charsets"), request.rawHeader("Accept-Charset"));
request.setRawHeader("Accept-Charset", QByteArray());
}
if (request.hasRawHeader("Accept-Language")) {
metaData.insert(QL1S("Languages"), request.rawHeader("Accept-Language"));
request.setRawHeader("Accept-Language", QByteArray());
}
if (request.hasRawHeader("Referer")) {
metaData.insert(QL1S("referrer"), request.rawHeader("Referer"));
request.setRawHeader("Referer", QByteArray());
}
if (request.hasRawHeader("Content-Type")) {
metaData.insert(QL1S("content-type"), request.rawHeader("Content-Type"));
request.setRawHeader("Content-Type", QByteArray());
}
if (request.attribute(QNetworkRequest::AuthenticationReuseAttribute) == QNetworkRequest::Manual) {
metaData.insert(QL1S("no-preemptive-auth-reuse"), QL1S("true"));
}
request.setRawHeader("Content-Length", QByteArray());
request.setRawHeader("Connection", QByteArray());
request.setRawHeader("If-None-Match", QByteArray());
request.setRawHeader("If-Modified-Since", QByteArray());
request.setRawHeader("x-kdewebkit-ignore-disposition", QByteArray());
QStringList customHeaders;
Q_FOREACH(const QByteArray &key, request.rawHeaderList()) {
const QByteArray value = request.rawHeader(key);
if (value.length())
customHeaders << (key + QL1S(": ") + value);
}
if (!customHeaders.isEmpty()) {
metaData.insert(QL1S("customHTTPHeader"), customHeaders.join("\r\n"));
}
// Append per request meta data, if any...
if (!requestMetaData.isEmpty()) {
metaData += requestMetaData;
// Clear per request meta data...
requestMetaData.clear();
}
// Append per session meta data, if any...
if (!sessionMetaData.isEmpty()) {
metaData += sessionMetaData;
}
}
QNetworkReply *AccessManager::createRequest(Operation op, const QNetworkRequest &req, QIODevice *outgoingData)
{
const KUrl reqUrl (req.url());
if (!d->externalContentAllowed &&
!KDEPrivate::AccessManagerReply::isLocalRequest(reqUrl) &&
reqUrl.scheme() != QL1S("data")) {
kDebug( 7044 ) << "Blocked: " << reqUrl;
return new KDEPrivate::AccessManagerReply(op, req, QNetworkReply::ContentAccessDenied, i18n("Blocked request."), this);
}
// Check if the internal ignore content disposition header is set.
const bool ignoreContentDisposition = req.hasRawHeader("x-kdewebkit-ignore-disposition");
// Retrieve the KIO meta data...
KIO::MetaData metaData;
d->setMetaDataForRequest(req, metaData);
KIO::SimpleJob *kioJob = 0;
switch (op) {
case HeadOperation: {
//kDebug( 7044 ) << "HeadOperation:" << reqUrl;
kioJob = KIO::mimetype(reqUrl, KIO::HideProgressInfo);
break;
}
case GetOperation: {
//kDebug( 7044 ) << "GetOperation:" << reqUrl;
if (!reqUrl.path().isEmpty() || reqUrl.host().isEmpty())
kioJob = KIO::get(reqUrl, KIO::NoReload, KIO::HideProgressInfo);
else
kioJob = KIO::stat(reqUrl, KIO::HideProgressInfo);
// WORKAROUND: Avoid the brain damaged stuff QtWebKit does when a POST
// operation is redirected! See BR# 268694.
metaData.remove(QL1S("content-type")); // Remove the content-type from a GET/HEAD request!
break;
}
case PutOperation: {
//kDebug( 7044 ) << "PutOperation:" << reqUrl;
if (outgoingData)
kioJob = KIO::storedPut(outgoingData->readAll(), reqUrl, -1, KIO::HideProgressInfo);
else
kioJob = KIO::put(reqUrl, -1, KIO::HideProgressInfo);
break;
}
case PostOperation: {
kioJob = KIO::http_post(reqUrl, outgoingData, sizeFromRequest(req), KIO::HideProgressInfo);
if (!metaData.contains(QL1S("content-type"))) {
const QVariant header = req.header(QNetworkRequest::ContentTypeHeader);
if (header.isValid()) {
metaData.insert(QL1S("content-type"),
(QL1S("Content-Type: ") + header.toString()));
} else {
metaData.insert(QL1S("content-type"),
QL1S("Content-Type: application/x-www-form-urlencoded"));
}
}
break;
}
case DeleteOperation: {
//kDebug(7044) << "DeleteOperation:" << reqUrl;
kioJob = KIO::http_delete(reqUrl, KIO::HideProgressInfo);
break;
}
case CustomOperation: {
const QByteArray& method = req.attribute(QNetworkRequest::CustomVerbAttribute).toByteArray();
//kDebug(7044) << "CustomOperation:" << reqUrl << "method:" << method << "outgoing data:" << outgoingData;
if (method.isEmpty()) {
return new KDEPrivate::AccessManagerReply(op, req, QNetworkReply::ProtocolUnknownError, i18n("Unknown HTTP verb."), this);
}
if (outgoingData)
kioJob = KIO::http_post(reqUrl, outgoingData, sizeFromRequest(req), KIO::HideProgressInfo);
else
kioJob = KIO::get(reqUrl, KIO::NoReload, KIO::HideProgressInfo);
metaData.insert(QL1S("CustomHTTPMethod"), method);
break;
}
default: {
kWarning(7044) << "Unsupported KIO operation requested! Defering to QNetworkAccessManager...";
return QNetworkAccessManager::createRequest(op, req, outgoingData);
}
}
// Set the job priority
switch (req.priority()) {
case QNetworkRequest::HighPriority:
KIO::Scheduler::setJobPriority(kioJob, -5);
break;
case QNetworkRequest::LowPriority:
KIO::Scheduler::setJobPriority(kioJob, 5);
break;
default:
break;
}
KDEPrivate::AccessManagerReply *reply;
/*
NOTE: Here we attempt to handle synchronous XHR requests. Unfortunately,
due to the fact that QNAM is both synchronous and multi-thread while KIO
is completely the opposite (asynchronous and not thread safe), the code
below might cause crashes like the one reported in bug# 287778 (nested
event loops are inherently dangerous).
Unfortunately, all attempts to address the crash has so far failed due to
the many regressions they caused, e.g. bug# 231932 and 297954. Hence, until
a solution is found, we have to live with the side effects of creating
nested event loops.
*/
if (req.attribute(gSynchronousNetworkRequestAttribute).toBool()) {
KUrl finalURL;
QByteArray data;
if (KIO::NetAccess::synchronousRun(kioJob, d->window, &data, &finalURL, &metaData)) {
reply = new KDEPrivate::AccessManagerReply(op, req, data, finalURL, metaData, this);
kDebug(7044) << "Synchronous XHR:" << reply << reqUrl;
} else {
kWarning(7044) << "Failed to create a synchronous XHR for" << reqUrl;
reply = new KDEPrivate::AccessManagerReply(op, req, QNetworkReply::UnknownNetworkError, kioJob->errorText(), this);
}
} else {
// Set the window on the the KIO ui delegate
if (d->window) {
kioJob->ui()->setWindow(d->window);
}
// Disable internal automatic redirection handling
kioJob->setRedirectionHandlingEnabled(false);
// Set the job priority
switch (req.priority()) {
case QNetworkRequest::HighPriority:
KIO::Scheduler::setJobPriority(kioJob, -5);
break;
case QNetworkRequest::LowPriority:
KIO::Scheduler::setJobPriority(kioJob, 5);
break;
default:
break;
}
// Set the meta data for this job...
kioJob->setMetaData(metaData);
// Create the reply...
reply = new KDEPrivate::AccessManagerReply(op, req, kioJob, d->emitReadyReadOnMetaDataChange, this);
//kDebug(7044) << reply << reqUrl;
}
if (ignoreContentDisposition && reply) {
//kDebug(7044) << "Content-Disposition WILL BE IGNORED!";
reply->setIgnoreContentDisposition(ignoreContentDisposition);
}
return reply;
}
void EMailThread::send() {
QStringList listTo;
QString mQuery;
KIO::MetaData slaveConfig;
KURL destination;
int i, count;
_sendOk = false;
KIO::Scheduler::connect(SIGNAL(slaveError(KIO::Slave *, int, const QString &)), this,
SLOT(slaveError(KIO::Slave *, int, const QString &)));
_strBody.insert( 0, QString("Subject:%1\n\n").arg(_strSubject).latin1());
_strBody.insert( 0, QString("To:%1\n").arg(_strTo).latin1());
_bodyOffset = 0;
_bodyLength = _strBody.length();
mQuery = "headers=0&from=";
mQuery += KURL::encode_string(_strFrom);
listTo = QStringList::split(QRegExp("[ ,;]"), _strTo);
count = listTo.count();
if (count > 0) {
for (i=0; i<count; i++) {
mQuery += "&to=";
mQuery += KURL::encode_string(listTo[i]);
}
} else {
mQuery += "&to=";
mQuery += KURL::encode_string(_strTo);
}
mQuery += "&size=";
mQuery += QString::number(_bodyLength);
if (_encryption == EMailEncryptionSSL) {
destination.setProtocol("smtps");
} else {
destination.setProtocol("smtp");
}
destination.setHost(_strSMTPServer);
destination.setPort((short)_iPort);
destination.setPath("/send");
destination.setQuery(mQuery);
if (_useAuthentication) {
destination.setUser(_strUsername);
destination.setPass(_strPassword);
}
if (_encryption == EMailEncryptionTLS) {
slaveConfig.insert("tls", "on");
} else {
slaveConfig.insert("tls", "off");
}
if (_useAuthentication) {
switch (_authentication) {
case EMailAuthenticationPLAIN:
slaveConfig.insert("sasl", "PLAIN");
break;
case EMailAuthenticationLOGIN:
slaveConfig.insert("sasl", "LOGIN");
break;
case EMailAuthenticationCRAMMD5:
slaveConfig.insert("sasl", "CRAM-MD5");
break;
case EMailAuthenticationDIGESTMD5:
slaveConfig.insert("sasl", "DIGEST-MD5");
break;
default:
slaveConfig.insert("sasl", "PLAIN");
break;
}
}
_slave = KIO::Scheduler::getConnectedSlave(destination, slaveConfig);
if (_slave) {
_job = KIO::put(destination, -1, false, false, false);
if (_job) {
_job->addMetaData("lf2crlf+dotstuff", "slave");
connect(_job, SIGNAL(result(KIO::Job *)), this, SLOT(result(KIO::Job *)));
connect(_job, SIGNAL(dataReq(KIO::Job *, QByteArray &)), this, SLOT(dataReq(KIO::Job *, QByteArray &)));
KIO::Scheduler::assignJobToSlave(_slave, _job);
_sendOk = true;
}
}
}
