File indexing completed on 2023-10-03 03:17:48

 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 2003 Apple Computer, Inc.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #include "xmlhttprequest.h"
 #include "xmlhttprequest.lut.h"
 #include "kjs_window.h"
 #include "kjs_events.h"
 
 #include "dom/dom_doc.h"
 #include "dom/dom_exception.h"
 #include "dom/dom_string.h"
 #include "misc/loader.h"
 #include "misc/translator.h"
 #include "html/html_documentimpl.h"
 #include "xml/dom2_eventsimpl.h"
 
 #include "khtml_part.h"
 #include "khtmlview.h"
 
 #include <kio/scheduler.h>
 #include <kio/job.h>
 #include <QObject>
 #include "khtml_debug.h"
 
 using namespace KJS;
 using namespace DOM;
 //
 ////////////////////// XMLHttpRequest Object ////////////////////////
 
 /* Source for XMLHttpRequestProtoTable.
 @begin XMLHttpRequestProtoTable 7
   abort         XMLHttpRequest::Abort           DontDelete|Function 0
   getAllResponseHeaders XMLHttpRequest::GetAllResponseHeaders   DontDelete|Function 0
   getResponseHeader XMLHttpRequest::GetResponseHeader   DontDelete|Function 1
   open          XMLHttpRequest::Open            DontDelete|Function 5
   overrideMimeType  XMLHttpRequest::OverrideMIMEType    DontDelete|Function 1
   send          XMLHttpRequest::Send            DontDelete|Function 1
   setRequestHeader  XMLHttpRequest::SetRequestHeader    DontDelete|Function 2
 @end
 */
 
 namespace KJS
 {
 
 KJS_DEFINE_PROTOTYPE(XMLHttpRequestProto)
 KJS_IMPLEMENT_PROTOFUNC(XMLHttpRequestProtoFunc)
 KJS_IMPLEMENT_PROTOTYPE("XMLHttpRequest", XMLHttpRequestProto, XMLHttpRequestProtoFunc, ObjectPrototype)
 
 XMLHttpRequestQObject::XMLHttpRequestQObject(XMLHttpRequest *_jsObject)
 {
     jsObject = _jsObject;
 }
 
 #ifdef APPLE_CHANGES
 void XMLHttpRequestQObject::slotData(KIO::Job *job, const char *data, int size)
 {
     jsObject->slotData(job, data, size);
 }
 #else
 void XMLHttpRequestQObject::slotData(KIO::Job *job, const QByteArray &data)
 {
     jsObject->slotData(job, data);
 }
 #endif
 
 void XMLHttpRequestQObject::slotFinished(KJob *job)
 {
     jsObject->slotFinished(job);
 }
 
 void XMLHttpRequestQObject::slotRedirection(KIO::Job *job, const QUrl &url)
 {
     jsObject->slotRedirection(job, url);
 }
 
 XMLHttpRequestConstructorImp::XMLHttpRequestConstructorImp(ExecState *exec, DOM::DocumentImpl *d)
     : JSObject(exec->lexicalInterpreter()->builtinObjectPrototype()), doc(d)
 {
     JSObject *proto = XMLHttpRequestProto::self(exec);
     putDirect(exec->propertyNames().prototype, proto, DontDelete | ReadOnly);
 }
 
 bool XMLHttpRequestConstructorImp::implementsConstruct() const
 {
     return true;
 }
 
 JSObject *XMLHttpRequestConstructorImp::construct(ExecState *exec, const List &)
 {
     return new XMLHttpRequest(exec, doc.get());
 }
 
 const ClassInfo XMLHttpRequest::info = { "XMLHttpRequest", nullptr, &XMLHttpRequestTable, nullptr };
 
 /* Source for XMLHttpRequestTable.
 @begin XMLHttpRequestTable 7
   readyState        XMLHttpRequest::ReadyState      DontDelete|ReadOnly
   responseText      XMLHttpRequest::ResponseText        DontDelete|ReadOnly
   responseXML       XMLHttpRequest::ResponseXML     DontDelete|ReadOnly
   status        XMLHttpRequest::Status          DontDelete|ReadOnly
   statusText        XMLHttpRequest::StatusText      DontDelete|ReadOnly
   onreadystatechange    XMLHttpRequest::Onreadystatechange  DontDelete
   onload        XMLHttpRequest::Onload          DontDelete
 @end
 */
 
 bool XMLHttpRequest::getOwnPropertySlot(ExecState *exec, const Identifier &propertyName, PropertySlot &slot)
 {
     return getStaticValueSlot<XMLHttpRequest, DOMObject>(exec, &XMLHttpRequestTable, this, propertyName, slot);
 }
 
 JSValue *XMLHttpRequest::getValueProperty(ExecState *exec, int token) const
 {
     switch (token) {
     case ReadyState:
         return jsNumber(m_state);
     case ResponseText:
         return ::getStringOrNull(DOM::DOMString(response));
     case ResponseXML:
         if (m_state != XHRS_Loaded) {
             return jsNull();
         }
         if (!createdDocument) {
             QString mimeType = "text/xml";
 
             if (!m_mimeTypeOverride.isEmpty()) {
                 mimeType = m_mimeTypeOverride;
             } else {
                 int dummy;
                 JSValue *header = getResponseHeader("Content-Type", dummy);
                 if (!header->isUndefinedOrNull()) {
                     mimeType = header->toString(exec).qstring().split(";")[0].trimmed();
                 }
             }
 
             if (mimeType == "text/xml" || mimeType == "application/xml" || mimeType == "application/xhtml+xml") {
                 responseXML = doc->implementation()->createDocument();
 
                 responseXML->open();
                 responseXML->setURL(url.url());
                 responseXML->write(response);
                 responseXML->finishParsing();
                 responseXML->close();
 
                 typeIsXML = true;
             } else {
                 typeIsXML = false;
             }
             createdDocument = true;
         }
 
         if (!typeIsXML) {
             return jsNull();
         }
 
         return getDOMNode(exec, responseXML.get());
     case Status:
         return getStatus();
     case StatusText:
         return getStatusText();
     case Onreadystatechange:
         if (onReadyStateChangeListener && onReadyStateChangeListener->listenerObj()) {
             return onReadyStateChangeListener->listenerObj();
         } else {
             return jsNull();
         }
     case Onload:
         if (onLoadListener && onLoadListener->listenerObj()) {
             return onLoadListener->listenerObj();
         } else {
             return jsNull();
         }
     default:
         qCWarning(KHTML_LOG) << "XMLHttpRequest::getValueProperty unhandled token " << token;
         return nullptr;
     }
 }
 
 void XMLHttpRequest::put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr)
 {
     lookupPut<XMLHttpRequest, DOMObject>(exec, propertyName, value, attr, &XMLHttpRequestTable, this);
 }
 
 void XMLHttpRequest::putValueProperty(ExecState *exec, int token, JSValue *value, int /*attr*/)
 {
     switch (token) {
     case Onreadystatechange:
         if (onReadyStateChangeListener) {
             onReadyStateChangeListener->deref();
         }
         onReadyStateChangeListener = Window::retrieveActive(exec)->getJSEventListener(value, true);
         if (onReadyStateChangeListener) {
             onReadyStateChangeListener->ref();
         }
         break;
     case Onload:
         if (onLoadListener) {
             onLoadListener->deref();
         }
         onLoadListener = Window::retrieveActive(exec)->getJSEventListener(value, true);
         if (onLoadListener) {
             onLoadListener->ref();
         }
         break;
     default:
         qCWarning(KHTML_LOG) << "XMLHttpRequest::putValue unhandled token " << token;
     }
 }
 
 // Token according to RFC 2616
 static bool isValidFieldName(const QString &name)
 {
     const int l = name.length();
     if (l == 0) {
         return false;
     }
 
     const QChar *c = name.constData();
     for (int i = 0; i < l; ++i, ++c) {
         ushort u = c->unicode();
         if (u < 32 || u > 126) {
             return false;
         }
         switch (u) {
         case '(': case ')': case '<': case '>':
         case '@': case ',': case ';': case ':':
         case '\\': case '"': case '/':
         case '[': case ']': case '?': case '=':
         case '{': case '}': case '\t': case ' ':
             return false;
         default:
             break;
         }
     }
     return true;
 }
 
 static bool isValidFieldValue(const QString &name)
 {
     const int l = name.length();
     if (l == 0) {
         return true;
     }
 
     const QChar *c = name.constData();
     for (int i = 0; i < l; ++i, ++c) {
         ushort u = c->unicode();
         if (u == '\n' || u == '\r') {
             return false;
         }
     }
 
     // ### what is invalid?
     return true;
 }
 
 static bool canSetRequestHeader(const QString &name)
 {
     if (name.startsWith(QLatin1String("sec-"), Qt::CaseInsensitive) ||
         name.startsWith(QLatin1String("proxy-"), Qt::CaseInsensitive)) {
         return false;
     }
 
     static QSet<CaseInsensitiveString> forbiddenHeaders;
     if (forbiddenHeaders.isEmpty()) {
         static const char *const hdrs[] = {
             "accept-charset",
             "accept-encoding",
             "access-control-request-headers",
             "access-control-request-method",
             "connection",
             "content-length",
             "content-transfer-encoding",
             "cookie",
             "cookie2",
             "date",
             "dnt",
             "expect",
             "host",
             "keep-alive",
             "origin",
             "referer",
             "te",
             "trailer",
             "transfer-encoding",
             "upgrade",
             "user-agent",
             "via"
         };
         for (size_t i = 0; i < sizeof(hdrs) / sizeof(char *); ++i) {
             forbiddenHeaders.insert(CaseInsensitiveString(hdrs[i]));
         }
     }
 
     return !forbiddenHeaders.contains(name);
 }
 
 XMLHttpRequest::XMLHttpRequest(ExecState *exec, DOM::DocumentImpl *d)
     : qObject(new XMLHttpRequestQObject(this)),
       doc(d),
       async(true),
       contentType(QString()),
       job(nullptr),
       m_state(XHRS_Uninitialized),
       onReadyStateChangeListener(nullptr),
       onLoadListener(nullptr),
       decoder(nullptr),
       binaryMode(false),
       response(QString::fromLatin1("")),
       createdDocument(false),
       aborted(false)
 {
     ref(); // we're a GC point, so refcount pin.
     setPrototype(XMLHttpRequestProto::self(exec));
 }
 
 XMLHttpRequest::~XMLHttpRequest()
 {
     if (job && m_method != QLatin1String("POST")) {
         job->kill();
         job = nullptr;
     }
     if (onLoadListener) {
         onLoadListener->deref();
     }
     if (onReadyStateChangeListener) {
         onReadyStateChangeListener->deref();
     }
     delete qObject;
     qObject = nullptr;
     delete decoder;
     decoder = nullptr;
 }
 
 void XMLHttpRequest::changeState(XMLHttpRequestState newState)
 {
     // Other engines cancel transfer if the controlling document doesn't
     // exist anymore. Match that, though being paranoid about post
     // (And don't emit any events w/o a doc, if we're kept alive otherwise).
     if (!doc) {
         if (job && m_method != QLatin1String("POST")) {
             job->kill();
             job = nullptr;
         }
         return;
     }
 
     if (m_state != newState) {
         m_state = newState;
         ProtectedPtr<JSObject> ref(this);
 
         if (onReadyStateChangeListener != nullptr && doc->view() && doc->view()->part()) {
             DOM::Event ev = doc->view()->part()->document().createEvent("HTMLEvents");
             ev.initEvent("readystatechange", true, true);
             ev.handle()->setTarget(this);
             ev.handle()->setCurrentTarget(this);
             onReadyStateChangeListener->handleEvent(ev);
 
             // Make sure the event doesn't point to us, since it can't prevent
             // us from being collecte.
             ev.handle()->setTarget(nullptr);
             ev.handle()->setCurrentTarget(nullptr);
         }
 
         if (m_state == XHRS_Loaded && onLoadListener != nullptr && doc->view() && doc->view()->part()) {
             DOM::Event ev = doc->view()->part()->document().createEvent("HTMLEvents");
             ev.initEvent("load", true, true);
             ev.handle()->setTarget(this);
             ev.handle()->setCurrentTarget(this);
             onLoadListener->handleEvent(ev);
             ev.handle()->setTarget(nullptr);
             ev.handle()->setCurrentTarget(nullptr);
         }
     }
 }
 
 bool XMLHttpRequest::urlMatchesDocumentDomain(const QUrl &_url) const
 {
     // No need to do work if _url is not valid...
     if (!_url.isValid()) {
         return false;
     }
 
     QUrl documentURL(doc->URL());
 
     // a local file can load anything
     if (documentURL.isLocalFile()) {
         return true;
     }
 
     // but a remote document can only load from the same port on the server
     if (documentURL.scheme() == _url.scheme() &&
             documentURL.host().toLower() == _url.host().toLower() &&
             documentURL.port() == _url.port()) {
         return true;
     }
 
     return false;
 }
 
 // Methods we're to recognize per the XHR spec (3.6.1, #3).
 // We map it to whether the method should be permitted or not (#4)
 static const IDTranslator<QByteArray, bool, const char *>::Info methodsTable[] = {
     {"CONNECT", false},
     {"DELETE", true},
     {"GET", true},
     {"HEAD", true},
     {"OPTIONS", true},
     {"POST", true},
     {"PUT", true},
     {"TRACE", false},
     {"TRACK", false},
     {nullptr, false}
 };
 
 MAKE_TRANSLATOR(methodsLookup, QByteArray, bool, const char *, methodsTable)
 
 void XMLHttpRequest::open(const QString &_method, const QUrl &_url, bool _async, int &ec)
 {
     abort();
     aborted = false;
 
     // clear stuff from possible previous load
     m_requestHeaders.clear();
     responseHeaders.clear();
     response = QString::fromLatin1("");
     createdDocument = false;
     responseXML = nullptr;
 
     if (!urlMatchesDocumentDomain(_url)) {
         ec = DOMException::SECURITY_ERR;
         return;
     }
 
     // ### potentially raise a SYNTAX_ERR
 
     // Lookup if the method is well-known, and if so check if it's OK
     QByteArray methodNormalized = _method.toUpper().toUtf8();
     if (methodsLookup()->hasLeft(methodNormalized)) {
         if (methodsLookup()->toRight(methodNormalized)) {
             // OK, replace with the canonical version...
             m_method = _method.toUpper();
         } else {
             // Scary stuff like CONNECT
             ec = DOMException::SECURITY_ERR;
             return;
         }
     } else {
         // Unknown -> pass through unchanged
         m_method = _method;
     }
 
     url = _url;
     async = _async;
 
     changeState(XHRS_Open);
 }
 
 void XMLHttpRequest::send(const QString &_body, int &ec)
 {
     aborted = false;
 
     if (m_state != XHRS_Open) {
         ec =  DOMException::INVALID_STATE_ERR;
         return;
     }
 
     const QString protocol = url.scheme();
     // Abandon the request when the protocol is other than "http",
     // instead of blindly doing a KIO::get on other protocols like file:/.
     if (!protocol.startsWith(QLatin1String("http")) &&
             !protocol.startsWith(QLatin1String("webdav"))) {
         ec = DOMException::INVALID_ACCESS_ERR;
         abort();
         return;
     }
 
     // We need to use a POST-like setup even for non-post whenever we
     // have a payload.
     const bool havePayload = !_body.isEmpty();
     if (m_method == QLatin1String("POST") || havePayload) {
         // FIXME: determine post encoding correctly by looking in headers
         // for charset.
         QByteArray buf = _body.toUtf8();
         job = KIO::storedHttpPost(buf, url, KIO::HideProgressInfo);
     } else {
         job = KIO::storedGet(url, KIO::NoReload, KIO::HideProgressInfo);
     }
 
     // Regardless of job type, make sure the method is set
     job->addMetaData("CustomHTTPMethod", m_method);
 
     // Set headers
 
     if (!contentType.isNull()) {
         job->addMetaData("content-type", contentType);
     } else if (havePayload) {
         job->addMetaData("content-type", "Content-type: text/plain");
     }
 
     if (!m_requestHeaders.isEmpty()) {
         QString rh;
         HTTPHeaderMap::ConstIterator begin = m_requestHeaders.constBegin();
         HTTPHeaderMap::ConstIterator end = m_requestHeaders.constEnd();
         for (HTTPHeaderMap::ConstIterator i = begin; i != end; ++i) {
             QString key = i.key().original();
             QString value = i.value();
             if (key.toLower() == "accept") {
                 // The HTTP KIO worker supports an override this way
                 job->addMetaData("accept", value);
             } else {
                 if (!rh.isEmpty()) {
                     rh += "\r\n";
                 }
                 rh += key + ": " + value;
             }
         }
 
         job->addMetaData("customHTTPHeader", rh);
     }
 
     job->addMetaData("PropagateHttpHeader", "true");
 
     // Set the default referrer. NOTE: the user can still disable
     // this feature at the protocol level (kio_http).
     QUrl documentURL(doc->URL());
     documentURL.setPassword(QString());
     documentURL.setUserName(QString());
     job->addMetaData("referrer", documentURL.url());
     // qCDebug(KHTML_LOG) << "Adding referrer: " << documentURL;
 
     if (!async) {
         QByteArray data;
         QUrl finalURL;
         QString headers;
 
 #ifdef APPLE_CHANGES
         data = KWQServeSynchronousRequest(khtml::Cache::loader(), doc->docLoader(), job, finalURL, headers);
 #else
         QMap<QString, QString> metaData;
 
         if (job->exec()) {
             data = job->data();
             finalURL = job->redirectUrl().isEmpty() ? job->url() : job->redirectUrl();
             headers = metaData[ "HTTP-Headers" ];
         }
 #endif
         job = nullptr;
         processSyncLoadResults(data, finalURL, headers);
         return;
     }
 
     qObject->connect(job, SIGNAL(result(KJob*)),
                      SLOT(slotFinished(KJob*)));
 #ifdef APPLE_CHANGES
     qObject->connect(job, SIGNAL(data(KIO::Job*,const char*,int)),
                      SLOT(slotData(KIO::Job*,const char*,int)));
 #else
     qObject->connect(job, SIGNAL(data(KIO::Job*,QByteArray)),
                      SLOT(slotData(KIO::Job*,QByteArray)));
 #endif
     qObject->connect(job, SIGNAL(redirection(KIO::Job*,QUrl)),
                      SLOT(slotRedirection(KIO::Job*,QUrl)));
 
 #ifdef APPLE_CHANGES
     KWQServeRequest(khtml::Cache::loader(), doc->docLoader(), job);
 #else
     KIO::Scheduler::setJobPriority(job, 1);
 #endif
 }
 
 void XMLHttpRequest::clearDecoder()
 {
     delete decoder;
     decoder = nullptr;
     binaryMode = false;
 }
 
 void XMLHttpRequest::abort()
 {
     if (job) {
         job->kill();
         job = nullptr;
     }
     aborted = true;
     clearDecoder();
     changeState(XHRS_Uninitialized);
 }
 
 void XMLHttpRequest::overrideMIMEType(const QString &override)
 {
     m_mimeTypeOverride = override;
 }
 
 void XMLHttpRequest::setRequestHeader(const QString &_name, const QString &_value, int &ec)
 {
     // throw exception if connection is not open or the send flag is set
     if (m_state != XHRS_Open || job != nullptr) {
         ec = DOMException::INVALID_STATE_ERR;
         return;
     }
 
     if (!isValidFieldName(_name) || !isValidFieldValue(_value)) {
         ec = DOMException::SYNTAX_ERR;
         return;
     }
 
     QString value = _value.trimmed();
 
     // Content-type needs to be set separately from the other headers
     if (_name.compare(QLatin1String("content-type"), Qt::CaseInsensitive) == 0) {
         contentType = "Content-type: " + value;
         return;
     }
 
     // Reject all banned headers.
     if (!canSetRequestHeader(_name)) {
         qCWarning(KHTML_LOG) << "Refusing to set unsafe XMLHttpRequest header" << _name;
         return;
     }
 
     if (m_requestHeaders.contains(_name)) {
         m_requestHeaders[_name] += (QLatin1String(", ") + value);
     } else {
         m_requestHeaders[_name] = value;
     }
 }
 
 JSValue *XMLHttpRequest::getAllResponseHeaders(int &ec) const
 {
     if (m_state < XHRS_Receiving) {
         ec = DOMException::INVALID_STATE_ERR;
         return jsString("");
     }
 
     // ### test error flag, return jsNull
 
     if (responseHeaders.isEmpty()) {
         return jsUndefined();
     }
 
     int endOfLine = responseHeaders.indexOf("\n");
 
     if (endOfLine == -1) {
         return jsUndefined();
     }
 
     return jsString(responseHeaders.mid(endOfLine + 1) + '\n');
 }
 
 JSValue *XMLHttpRequest::getResponseHeader(const QString &name, int &ec) const
 {
     if (m_state < XHRS_Receiving) {
         ec = DOMException::INVALID_STATE_ERR;
         return jsString("");
     }
 
     if (!isValidFieldName(name)) {
         return jsString("");
     }
 
     // ### test error flag, return jsNull
 
     if (responseHeaders.isEmpty()) {
         return jsUndefined();
     }
 
     QRegExp headerLinePattern(name + ':', Qt::CaseInsensitive);
 
     int matchLength;
     int headerLinePos = headerLinePattern.indexIn(responseHeaders, 0);
     matchLength = headerLinePattern.matchedLength();
     while (headerLinePos != -1) {
         if (headerLinePos == 0 || responseHeaders[headerLinePos - 1] == '\n') {
             break;
         }
 
         headerLinePos = headerLinePattern.indexIn(responseHeaders, headerLinePos + 1);
         matchLength = headerLinePattern.matchedLength();
     }
 
     if (headerLinePos == -1) {
         return jsNull();
     }
 
     int endOfLine = responseHeaders.indexOf("\n", headerLinePos + matchLength);
 
     return jsString(responseHeaders.mid(headerLinePos + matchLength, endOfLine - (headerLinePos + matchLength)).trimmed());
 }
 
 static JSValue *httpStatus(const QString &response, bool textStatus = false)
 {
     if (response.isEmpty()) {
         return jsUndefined();
     }
 
     int endOfLine = response.indexOf("\n");
     QString firstLine = (endOfLine == -1) ? response : response.left(endOfLine);
     int codeStart = firstLine.indexOf(" ");
     int codeEnd = firstLine.indexOf(" ", codeStart + 1);
 
     if (codeStart == -1 || codeEnd == -1) {
         return jsUndefined();
     }
 
     if (textStatus) {
         QString statusText = firstLine.mid(codeEnd + 1, endOfLine - (codeEnd + 1)).trimmed();
         return jsString(statusText);
     }
 
     QString number = firstLine.mid(codeStart + 1, codeEnd - (codeStart + 1));
 
     bool ok = false;
     int code = number.toInt(&ok);
     if (!ok) {
         return jsUndefined();
     }
 
     return jsNumber(code);
 }
 
 JSValue *XMLHttpRequest::getStatus() const
 {
     return httpStatus(responseHeaders);
 }
 
 JSValue *XMLHttpRequest::getStatusText() const
 {
     return httpStatus(responseHeaders, true);
 }
 
 void XMLHttpRequest::processSyncLoadResults(const QByteArray &data, const QUrl &finalURL, const QString &headers)
 {
     if (!urlMatchesDocumentDomain(finalURL)) {
         abort();
         return;
     }
 
     responseHeaders = headers;
     changeState(XHRS_Sent);
     if (aborted) {
         return;
     }
 
 #ifdef APPLE_CHANGES
     const char *bytes = (const char *)data.data();
     int len = (int)data.size();
 
     slotData(0, bytes, len);
 #else
     slotData(nullptr, data);
 #endif
 
     if (aborted) {
         return;
     }
 
     slotFinished(nullptr);
 }
 
 void XMLHttpRequest::slotFinished(KJob *)
 {
     if (decoder) {
         response += decoder->flush();
     }
 
     // make sure to forget about the job before emitting completed,
     // since changeState triggers JS code, which might e.g. call abort.
     job = nullptr;
     changeState(XHRS_Loaded);
 
     clearDecoder();
 }
 
 void XMLHttpRequest::slotRedirection(KIO::Job *, const QUrl &url)
 {
     if (!urlMatchesDocumentDomain(url)) {
         abort();
     }
 }
 
 static QString encodingFromContentType(const QString &type)
 {
     QString encoding;
     int index = type.indexOf(';');
     if (index > -1) {
         encoding = type.mid(index + 1).remove(QRegExp("charset[ ]*=[ ]*", Qt::CaseInsensitive)).trimmed();
     }
     return encoding;
 }
 
 #ifdef APPLE_CHANGES
 void XMLHttpRequest::slotData(KIO::Job *, const char *data, int len)
 #else
 void XMLHttpRequest::slotData(KIO::Job *, const QByteArray &_data)
 #endif
 {
     if (m_state < XHRS_Sent) {
         responseHeaders = job->queryMetaData("HTTP-Headers");
 
         // NOTE: Replace a 304 response with a 200! Both IE and Mozilla do this.
         // Problem first reported through bug# 110272.
         int codeStart = responseHeaders.indexOf("304");
         if (codeStart != -1) {
             int codeEnd = responseHeaders.indexOf("\n", codeStart + 3);
             if (codeEnd != -1) {
                 responseHeaders.replace(codeStart, (codeEnd - codeStart), "200 OK");
             }
         }
 
         changeState(XHRS_Sent);
     }
 
 #ifndef APPLE_CHANGES
     const char *data = (const char *)_data.data();
     int len = (int)_data.size();
 #endif
 
     if (!decoder && !binaryMode) {
         if (!m_mimeTypeOverride.isEmpty()) {
             encoding = encodingFromContentType(m_mimeTypeOverride);
         }
 
         if (encoding.isEmpty()) {
             int pos = responseHeaders.indexOf(QLatin1String("content-type:"), 0, Qt::CaseInsensitive);
             if (pos > -1) {
                 pos += 13;
                 int index = responseHeaders.indexOf('\n', pos);
                 QString type = responseHeaders.mid(pos, (index - pos));
                 encoding = encodingFromContentType(type);
             }
         }
 
         if (encoding == QLatin1String("x-user-defined")) {
             binaryMode = true;
         } else {
             decoder = new KEncodingDetector;
             if (!encoding.isEmpty()) {
                 decoder->setEncoding(encoding.toLatin1().constData(), KEncodingDetector::EncodingFromHTTPHeader);
             } else {
                 decoder->setEncoding("UTF-8", KEncodingDetector::DefaultEncoding);
             }
         }
     }
 
     if (len == 0) {
         return;
     }
 
     if (len == -1) {
         len = strlen(data);
     }
 
     QString decoded;
     if (binaryMode) {
         decoded = QString::fromLatin1(data, len);
     } else {
         decoded = decoder->decodeWithBuffering(data, len);
     }
 
     response += decoded;
 
     if (!aborted) {
         changeState(XHRS_Receiving);
     }
 }
 
 JSValue *XMLHttpRequestProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
 {
     if (!thisObj->inherits(&XMLHttpRequest::info)) {
         return throwError(exec, TypeError);
     }
 
     XMLHttpRequest *request = static_cast<XMLHttpRequest *>(thisObj);
 
     if (!request->doc) {
         setDOMException(exec, DOMException::INVALID_STATE_ERR);
         return jsUndefined();
     }
 
     int ec = 0;
 
     switch (id) {
     case XMLHttpRequest::Abort:
         request->abort();
         return jsUndefined();
     case XMLHttpRequest::GetAllResponseHeaders: {
         JSValue *ret = request->getAllResponseHeaders(ec);
         setDOMException(exec, ec);
         return ret;
     }
     case XMLHttpRequest::GetResponseHeader: {
         if (args.size() < 1) {
             return throwError(exec, SyntaxError, "Not enough arguments");
         }
         JSValue *ret = request->getResponseHeader(args[0]->toString(exec).qstring(), ec);
         setDOMException(exec, ec);
         return ret;
     }
     case XMLHttpRequest::Open: {
         if (args.size() < 2) {
             return throwError(exec, SyntaxError, "Not enough arguments");
         }
 
         QString method = args[0]->toString(exec).qstring();
         DOMString urlArg = args[1]->toString(exec).domString().trimSpaces();
         QUrl url = QUrl(request->doc->completeURL(urlArg.string()));
 
         bool async = true;
         if (args.size() >= 3) {
             async = args[2]->toBoolean(exec);
         }
 
         // Set url userinfo
         if (args.size() >= 4 && !args[3]->isUndefinedOrNull()) {
             QString user = args[3]->toString(exec).qstring();
             if (!user.isEmpty()) {
                 url.setUserName(user);
                 if (args.size() >= 5 && !args[4]->isUndefinedOrNull()) {
                     url.setPassword(args[4]->toString(exec).qstring());
                 }
             }
         }
 
         request->open(method, url, async, ec);
         setDOMException(exec, ec);
         return jsUndefined();
     }
     case XMLHttpRequest::Send: {
         QString body;
         if (!args[0]->isUndefinedOrNull()
                 // make sure we don't marshal "undefined" or such;
                 && request->m_method != QLatin1String("GET")
                 && request->m_method != QLatin1String("HEAD")) {
             // ... or methods that don't have payload
 
             DOM::NodeImpl *docNode = toNode(args[0]);
             if (docNode && docNode->isDocumentNode()) {
                 DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl *>(docNode);
                 body = doc->toString().string();
                 // FIXME: also need to set content type, including encoding!
             } else {
                 body = args[0]->toString(exec).qstring();
             }
         }
 
         request->send(body, ec);
         setDOMException(exec, ec);
         return jsUndefined();
     }
     case XMLHttpRequest::SetRequestHeader: {
         if (args.size() < 2) {
             return throwError(exec, SyntaxError, "Not enough arguments");
         }
 
         QString headerFieldName = args[0]->toString(exec).qstring();
         QString headerFieldValue = args[1]->toString(exec).qstring();
         request->setRequestHeader(headerFieldName, headerFieldValue, ec);
         setDOMException(exec, ec);
         return jsUndefined();
     }
 
     case XMLHttpRequest::OverrideMIMEType:
         if (args.size() < 1) {
             return throwError(exec, SyntaxError, "Not enough arguments");
         }
 
         request->overrideMIMEType(args[0]->toString(exec).qstring());
         return jsUndefined();
     }
 
     return jsUndefined();
 }
 
 } // end namespace
 
 #include "moc_xmlhttprequest.cpp"