diff options
Diffstat (limited to 'packages/konqueror/konqueror-embedded-20030705')
11 files changed, 5974 insertions, 0 deletions
diff --git a/packages/konqueror/konqueror-embedded-20030705/.mtn2git_empty b/packages/konqueror/konqueror-embedded-20030705/.mtn2git_empty new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/packages/konqueror/konqueror-embedded-20030705/.mtn2git_empty diff --git a/packages/konqueror/konqueror-embedded-20030705/flashpart.patch b/packages/konqueror/konqueror-embedded-20030705/flashpart.patch index e69de29bb2..d1bef8043f 100644 --- a/packages/konqueror/konqueror-embedded-20030705/flashpart.patch +++ b/packages/konqueror/konqueror-embedded-20030705/flashpart.patch @@ -0,0 +1,10 @@ +diff -ur konqe.old/konq-embed/add-ons/kflashpart/flashlib/Makefile.am konqueror-embedded-snapshot-20030705/konq-embed/add-ons/kflashpart/flashlib/Makefile.am +--- konqe.old/konq-embed/add-ons/kflashpart/flashlib/Makefile.am 2003-05-29 17:08:45.000000000 +0200 ++++ konqueror-embedded-snapshot-20030705/konq-embed/add-ons/kflashpart/flashlib/Makefile.am 2004-08-22 21:40:24.000000000 +0200 +@@ -1,5 +1,6 @@ + # Comment out the following line if you use egcs : + CXXFLAGS=-O3 -Wall -fno-rtti -fno-exceptions -DDISABLE_NONQIMAGE_DEPTHS ++INCLUDES = $(QTOPIA_INCLUDES) $(all_includes) + + noinst_LTLIBRARIES = libflash.la + diff --git a/packages/konqueror/konqueror-embedded-20030705/include_qconfig.patch b/packages/konqueror/konqueror-embedded-20030705/include_qconfig.patch index e69de29bb2..245d031863 100644 --- a/packages/konqueror/konqueror-embedded-20030705/include_qconfig.patch +++ b/packages/konqueror/konqueror-embedded-20030705/include_qconfig.patch @@ -0,0 +1,14 @@ +We need to have the defines available before +we try to evaluate them + + + +--- konqueror-embedded-snapshot-20030705/konq-embed/src/popuphandler.cc~ 2002-12-05 13:47:07.000000000 +0100 ++++ konqueror-embedded-snapshot-20030705/konq-embed/src/popuphandler.cc 2004-08-22 17:10:44.000000000 +0200 +@@ -1,3 +1,6 @@ ++ ++#include <qnamespace.h> ++ + #include "popuphandler.h" + + #if defined(_WS_QWS_) && defined(QT_NO_QWS_CURSOR) diff --git a/packages/konqueror/konqueror-embedded-20030705/kcookiejar-merge.patch b/packages/konqueror/konqueror-embedded-20030705/kcookiejar-merge.patch index e69de29bb2..d5c1a9a8e5 100644 --- a/packages/konqueror/konqueror-embedded-20030705/kcookiejar-merge.patch +++ b/packages/konqueror/konqueror-embedded-20030705/kcookiejar-merge.patch @@ -0,0 +1,2924 @@ + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiejar.cpp~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiejar.cpp +@@ -1,8 +1,8 @@ + /* This file is part of the KDE File Manager + +- Copyright (C) 1998,1999,2000,2001 Waldo Bastian (bastian@kde.org) +- Copyright (C) 2000,2001 Dawit Alemayehu (adawit@kde.org) +- ++ Copyright (C) 1998-2000 Waldo Bastian (bastian@kde.org) ++ Copyright (C) 2000,2001 Dawit Alemayehu (adawit@kde.org) ++ + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights +@@ -22,17 +22,18 @@ + */ + //---------------------------------------------------------------------------- + // +-// KDE HTTP Cookie Manager +-// $Id: kcookiejar.cpp,v 1.58.2.5 2001/11/04 04:21:39 adawit Exp $ ++// KDE File Manager -- HTTP Cookies ++// $Id: kcookiejar.cpp,v 1.117 2004/07/20 15:29:24 waba Exp $ + + // + // The cookie protocol is a mess. RFC2109 is a joke since nobody seems to +-// use it. Apart from that it is badly written. We try to implement Netscape +-// Cookies and try to behave according to RFC2109 as much as we can. ++// use it. Apart from that it is badly written. ++// We try to implement Netscape Cookies and try to behave us according to ++// RFC2109 as much as we can. ++// ++// We assume cookies do not contain any spaces (Netscape spec.) ++// According to RFC2109 this is allowed though. + // +-// We assume cookies do not contain any spaces (Netscape spec.) According to +-// RFC2109 this is allowed though. +- + + #include <config.h> + #include <sys/types.h> +@@ -44,12 +45,23 @@ + #include <unistd.h> + #include <stdio.h> + #include <string.h> ++ ++#ifdef USE_SOLARIS ++#include <strings.h> ++#endif ++ + #include <stdlib.h> + ++//#include <netinet/in.h> ++//#include <arpa/inet.h> ++ + #include <qstring.h> + #include <qstrlist.h> + #include <qlist.h> + #include <qdict.h> ++#include <qfile.h> ++#include <qdir.h> ++#include <qregexp.h> + + #include <kurl.h> + #include <krfcdate.h> +@@ -61,6 +73,13 @@ + + #define READ_BUFFER_SIZE 8192 + ++// Note with respect to QString::fromLatin1( ) ++// Cookies are stored as 8 bit data and passed to kio_http as ++// latin1 regardless of their actual encoding. ++ ++// L1 is used to indicate latin1 constants ++#define L1(x) QString::fromLatin1(x) ++ + template class QList<KHttpCookie>; + template class QDict<KHttpCookieList>; + +@@ -68,10 +87,10 @@ + { + switch( _advice ) + { +- case KCookieAccept: return "Accept"; +- case KCookieReject: return "Reject"; +- case KCookieAsk: return "Ask"; +- default: return "Dunno"; ++ case KCookieAccept: return L1("Accept"); ++ case KCookieReject: return L1("Reject"); ++ case KCookieAsk: return L1("Ask"); ++ default: return L1("Dunno"); + } + } + +@@ -80,7 +99,7 @@ + if (_str.isEmpty()) + return KCookieDunno; + +- QString advice = _str.lower(); ++ QCString advice = _str.lower().latin1(); + + if (advice == "accept") + return KCookieAccept; +@@ -105,17 +124,20 @@ + const QString &_value, + time_t _expireDate, + int _protocolVersion, +- bool _secure) : ++ bool _secure, ++ bool _httpOnly, ++ bool _explicitPath) : + mHost(_host), + mDomain(_domain), +- mPath(_path), ++ mPath(_path.isEmpty() ? QString::null : _path), + mName(_name), + mValue(_value), + mExpireDate(_expireDate), + mProtocolVersion(_protocolVersion), +- mSecure(_secure) ++ mSecure(_secure), ++ mHttpOnly(_httpOnly), ++ mExplicitPath(_explicitPath) + { +- nextCookie = 0; + } + + // +@@ -135,16 +157,17 @@ + + if (useDOMFormat || (mProtocolVersion == 0)) + { +- result = mName + "=" + mValue; ++ if ( !mName.isEmpty() ) ++ result = mName + '='; ++ result += mValue; + } + else + { +- result.sprintf("$Version=\"%d\"; ", mProtocolVersion); +- result += mName + "=\"" + mValue + "\""; +- if (!mPath.isEmpty()) +- result += "; $Path=\""+ mPath + "\""; ++ result = mName + '=' + mValue; ++ if (mExplicitPath) ++ result += L1("; $Path=\"") + mPath + L1("\""); + if (!mDomain.isEmpty()) +- result += "; $Domain=\""+ mDomain + "\""; ++ result += L1("; $Domain=\"") + mDomain + L1("\""); + } + return result; + } +@@ -157,8 +180,7 @@ + // Cookie domain match check + if (mDomain.isEmpty()) + { +- // No domain set, check hostname. +- if (fqdn != mHost) ++ if (fqdn != mHost) + return false; + } + else if (!domains.contains(mDomain)) +@@ -167,17 +189,30 @@ + return false; + + // Maybe the domain needs an extra dot. +- QString domain = "." + mDomain; ++ QString domain = '.' + mDomain; + if ( !domains.contains( domain ) ) + if ( fqdn != mDomain ) + return false; + } + + // Cookie path match check +- if( !path.isEmpty() && !path.startsWith(mPath) ) +- return false; // Path of URL does not start with cookie-path ++ if (mPath.isEmpty()) ++ return true; + +- return true; ++ // According to the netscape spec both http://www.acme.com/foobar, ++ // http://www.acme.com/foo.bar and http://www.acme.com/foo/bar ++ // match http://www.acme.com/foo. ++ // We only match http://www.acme.com/foo/bar ++ ++ if( path.startsWith(mPath) && ++ ( ++ (path.length() == mPath.length() ) || // Paths are exact match ++ (path[mPath.length()-1] == '/') || // mPath ended with a slash ++ (path[mPath.length()] == '/') // A slash follows. ++ )) ++ return true; // Path of URL starts with cookie-path ++ ++ return false; + } + + // KHttpCookieList +@@ -188,9 +223,9 @@ + int pathLen1 = ((KHttpCookie *)item1)->path().length(); + int pathLen2 = ((KHttpCookie *)item2)->path().length(); + if (pathLen1 > pathLen2) +- return 1; +- if (pathLen1 < pathLen2) + return -1; ++ if (pathLen1 < pathLen2) ++ return 1; + return 0; + } + +@@ -205,10 +240,18 @@ + // + KCookieJar::KCookieJar() + { +- cookieDomains.setAutoDelete( true ); +- globalAdvice = KCookieDunno; +- configChanged = false; +- cookiesChanged = false; ++ m_cookieDomains.setAutoDelete( true ); ++ m_globalAdvice = KCookieDunno; ++ m_configChanged = false; ++ m_cookiesChanged = false; ++ ++ QString twoLevelTLD="name,ai,au,bd,bh,ck,eg,et,fk,il,in,kh,kr,mk,mt,na,np,nz,pg,pk,qa,sa,sb,sg,sv,ua,ug,uk,uy,vn,za,zw"; ++ QStringList countries = QStringList::split(',', twoLevelTLD); ++ for(QStringList::ConstIterator it = countries.begin(); ++ it != countries.end(); ++it) ++ { ++ m_twoLevelTLD.replace(*it, (int *) 1); ++ } + } + + // +@@ -221,89 +264,184 @@ + // Not much to do here + } + ++static void removeDuplicateFromList(KHttpCookieList *list, KHttpCookie *cookiePtr, bool nameMatchOnly=false, bool updateWindowId=false) ++{ ++ QString domain1 = cookiePtr->domain(); ++ if (domain1.isEmpty()) ++ domain1 = cookiePtr->host(); ++ ++ for ( KHttpCookiePtr cookie=list->first(); cookie != 0; ) ++ { ++ QString domain2 = cookie->domain(); ++ if (domain2.isEmpty()) ++ domain2 = cookie->host(); ++ ++ if ( ++ (cookiePtr->name() == cookie->name()) && ++ ( ++ nameMatchOnly || ++ ( (domain1 == domain2) && (cookiePtr->path() == cookie->path()) ) ++ ) ++ ) ++ { ++ if (updateWindowId) ++ { ++ for(QValueList<long>::ConstIterator it = cookie->windowIds().begin(); ++ it != cookie->windowIds().end(); ++it) ++ { ++ long windowId = *it; ++ if (windowId && (cookiePtr->windowIds().find(windowId) == cookiePtr->windowIds().end())) ++ { ++ cookiePtr->windowIds().append(windowId); ++ } ++ } ++ } ++ KHttpCookiePtr old_cookie = cookie; ++ cookie = list->next(); ++ list->removeRef( old_cookie ); ++ break; ++ } ++ else ++ { ++ cookie = list->next(); ++ } ++ } ++} ++ ++ + // + // Looks for cookies in the cookie jar which are appropriate for _url. + // Returned is a string containing all appropriate cookies in a format + // which can be added to a HTTP-header without any additional processing. + // +-QString KCookieJar::findCookies(const QString &_url, bool useDOMFormat) ++QString KCookieJar::findCookies(const QString &_url, bool useDOMFormat, long windowId, KHttpCookieList *pendingCookies) + { + QString cookieStr; + QStringList domains; + QString fqdn; + QString path; + KHttpCookiePtr cookie; +- int protVersion = 1; +- int cookieCount = 0; ++ KCookieAdvice advice = m_globalAdvice; + + if (!parseURL(_url, fqdn, path)) +- { + return cookieStr; +- } ++ ++ bool secureRequest = (_url.find( L1("https://"), 0, false) == 0 || ++ _url.find( L1("webdavs://"), 0, false) == 0); + + extractDomains(fqdn, domains); +- bool secureRequest = (_url.find( "https://", 0, false) == 0); ++ ++ KHttpCookieList allCookies; ++ + for(QStringList::ConstIterator it = domains.begin(); +- it != domains.end(); ++ true; + ++it) + { +- KHttpCookieList *cookieList = cookieDomains[(*it)]; ++ KHttpCookieList *cookieList; ++ if (it == domains.end()) ++ { ++ cookieList = pendingCookies; // Add pending cookies ++ pendingCookies = 0; ++ if (!cookieList) ++ break; ++ } ++ else ++ { ++ QString key = (*it).isNull() ? L1("") : (*it); ++ cookieList = m_cookieDomains[key]; ++ if (!cookieList) ++ continue; // No cookies for this domain ++ } + +- if (!cookieList) +- continue; // No cookies for this domain ++ if (cookieList->getAdvice() != KCookieDunno) ++ advice = cookieList->getAdvice(); ++ ++ // Do not send cookies for this domain if policy is set to reject ++ // and we are not setup to automatically accept all cookies as ++ // session cookies... ++ if (advice == KCookieReject && ++ !(m_ignoreCookieExpirationDate && m_autoAcceptSessionCookies)) ++ { ++ if (it == domains.end()) ++ break; // Finished. ++ continue; ++ } + + for ( cookie=cookieList->first(); cookie != 0; cookie=cookieList->next() ) + { +- if (!cookie->match(fqdn, domains, path) && cookie->domain().isEmpty()) +- { +- // The following code is added because RFC 2109 is completely +- // ambigious when it comes what needs to be done when cookies +- // with empty "domain=" fields are present! The following code +- // makes such cookies available to all the domains/hosts under +- // the TLD of the cookie in question! +- QStringList cookieDomainList; +- extractDomains( cookie->host(), cookieDomainList ); +- +- int fqdnCount = domains.count(); +- int cookieDomainCount = cookieDomainList.count(); +- +- if ( domains[fqdnCount-2] != cookieDomainList[cookieDomainCount-2] && +- domains[fqdnCount-1] != cookieDomainList[cookieDomainCount-1] ) +- continue; +- } ++ if (!cookie->match(fqdn, domains, path)) ++ continue; + + if( cookie->isSecure() && !secureRequest ) + continue; + +- // Use first cookie to determine protocol version +- if (cookieCount == 0) ++ if( cookie->isHttpOnly() && useDOMFormat ) ++ continue; ++ ++ // Do not send expired cookies. ++ if ( cookie->isExpired (time(0)) ) + { +- protVersion = cookie->protocolVersion(); ++ // Note there is no need to actually delete the cookie here ++ // since the cookieserver will invoke ::saveCookieJar because ++ // of the state change below. This will then do the job of ++ // deleting the cookie for us. ++ m_cookiesChanged = true; ++ continue; + } +- if (useDOMFormat) ++ ++ if (windowId && (cookie->windowIds().find(windowId) == cookie->windowIds().end())) + { +- if (cookieCount > 0) +- cookieStr += "; "; +- cookieStr += cookie->cookieStr(true); ++ cookie->windowIds().append(windowId); + } +- else if (protVersion == 0) ++ ++ if (it == domains.end()) // Only needed when processing pending cookies ++ removeDuplicateFromList(&allCookies, cookie); ++ ++ allCookies.append(cookie); ++ } ++ if (it == domains.end()) ++ break; // Finished. ++ } ++ ++ ++ int cookieCount = 0; ++ ++ int protVersion=0; ++ for ( cookie=allCookies.first(); cookie != 0; cookie=allCookies.next() ) ++ { ++ if (cookie->protocolVersion() > protVersion) ++ protVersion = cookie->protocolVersion(); ++ } ++ ++ for ( cookie=allCookies.first(); cookie != 0; cookie=allCookies.next() ) ++ { ++ if (useDOMFormat) ++ { ++ if (cookieCount > 0) ++ cookieStr += L1("; "); ++ cookieStr += cookie->cookieStr(true); ++ } ++ else ++ { ++ if (cookieCount == 0) + { +- if (cookieCount == 0) +- cookieStr += "Cookie: "; +- else +- cookieStr += "; "; +- cookieStr += cookie->cookieStr(false); ++ cookieStr += L1("Cookie: "); ++ if (protVersion > 0) ++ { ++ QString version; ++ version.sprintf("$Version=%d; ", protVersion); // Without quotes ++ cookieStr += version; ++ } + } + else + { +- if (cookieCount > 0) +- cookieStr += "\r\n"; +- cookieStr += "Cookie: "; +- cookieStr += cookie->cookieStr(false); ++ cookieStr += L1("; "); + } +- cookieCount++; ++ cookieStr += cookie->cookieStr(false); + } ++ cookieCount++; + } ++ + return cookieStr; + } + +@@ -323,17 +461,17 @@ + bool keepQuotes=false) + { + const char *s = header; +- + // Parse 'my_name' part + for(; (*s != '='); s++) + { + if ((*s=='\0') || (*s==';') || (*s=='\n')) + { +- // End of Name +- Value = ""; +- Name = header; +- Name.truncate( s - header ); +- Name = Name.stripWhiteSpace(); ++ // No '=' sign -> use string as the value, name is empty ++ // (behavior found in Mozilla and IE) ++ Name = ""; ++ Value = QString::fromLatin1(header); ++ Value.truncate( s - header ); ++ Value = Value.stripWhiteSpace(); + return (s); + } + } +@@ -366,12 +504,12 @@ + if ((*s=='\0') || (*s=='\n')) + { + // End of Name +- Value = header; ++ Value = QString::fromLatin1(header); + Value.truncate(s - header); + return (s); + } + } +- Value = header; ++ Value = QString::fromLatin1(header); + Value.truncate( s - header ); + + // *s == '\"'; +@@ -390,7 +528,7 @@ + while ((*s != '\0') && (*s != ';') && (*s != '\n')) + s++; + // End of Name +- Value = header; ++ Value = QString::fromLatin1(header); + Value.truncate( s - header ); + Value = Value.stripWhiteSpace(); + } +@@ -398,14 +536,14 @@ + + } + +-static void stripDomain(const QString &_fqdn, QString &_domain) ++void KCookieJar::stripDomain(const QString &_fqdn, QString &_domain) + { + QStringList domains; +- KCookieJar::extractDomains(_fqdn, domains); ++ extractDomains(_fqdn, domains); + _domain = domains[0]; + } + +-static QString stripDomain( KHttpCookiePtr cookiePtr) ++QString KCookieJar::stripDomain( KHttpCookiePtr cookiePtr) + { + QString domain; // We file the cookie under this domain. + if (cookiePtr->domain().isEmpty()) +@@ -420,10 +558,18 @@ + QString &_path) + { + KURL kurl(_url); +- if (kurl.isMalformed()) ++ if (!kurl.isValid()) + return false; + + _fqdn = kurl.host().lower(); ++ if (kurl.port()) ++ { ++ if (((kurl.protocol() == L1("http")) && (kurl.port() != 80)) || ++ ((kurl.protocol() == L1("https")) && (kurl.port() != 443))) ++ { ++ _fqdn = L1("%1:%2").arg(kurl.port()).arg(_fqdn); ++ } ++ } + + // Cookie spoofing protection. Since there is no way a path separator + // or escape encoded character is allowed in the hostname according +@@ -435,19 +581,44 @@ + + _path = kurl.path(); + if (_path.isEmpty()) +- _path = "/"; ++ _path = L1("/"); ++ ++ QRegExp exp(L1("[\\\\/]\\.\\.[\\\\/]")); ++ // Weird path, cookie stealing attempt? ++ if (_path.find(exp) != -1) { ++ return false; // Deny everything!! ++ } ++ + return true; + } + + void KCookieJar::extractDomains(const QString &_fqdn, + QStringList &_domains) + { +- // Use fqdn only if the fqdn consists of numbers. +- if ((_fqdn[0] >= '0') && (_fqdn[0] <= '9')) ++ // Return numeric IPv6 addresses as is... ++ if (_fqdn[0] == '[') + { + _domains.append( _fqdn ); + return; + } ++ // Return numeric IPv4 addresses as is... ++ if ((_fqdn[0] >= '0') && (_fqdn[0] <= '9')) ++ { ++ bool allNumeric = true; ++ for(int i = _fqdn.length(); i--;) ++ { ++ if (!strchr("0123456789:.", _fqdn[i].latin1())) ++ { ++ allNumeric = false; ++ break; ++ } ++ } ++ if (allNumeric) ++ { ++ _domains.append( _fqdn ); ++ return; ++ } ++ } + + QStringList partList = QStringList::split('.', _fqdn, false); + +@@ -458,29 +629,36 @@ + { + if (partList.count() == 1) + break; // We only have a TLD left. +- if (partList.count() == 2) ++ ++ if ((partList.count() == 2) && (m_twoLevelTLD[partList[1].lower()])) ++ { ++ // This domain uses two-level TLDs in the form xxxx.yy ++ break; ++ } ++ ++ if ((partList.count() == 2) && (partList[1].length() == 2)) + { + // If this is a TLD, we should stop. (e.g. co.uk) + // We assume this is a TLD if it ends with .xx.yy or .x.yy +- if ((partList[0].length() <= 2) && +- (partList[1].length() == 2)) ++ if (partList[0].length() <= 2) + break; // This is a TLD. ++ ++ // Catch some TLDs that we miss with the previous check ++ // e.g. com.au, org.uk, mil.co ++ QCString t = partList[0].lower().utf8(); ++ if ((t == "com") || (t == "net") || (t == "org") || (t == "gov") || (t == "edu") || (t == "mil") || (t == "int")) ++ break; + } +- QString domain = partList.join("."); +- _domains.append("." + domain); ++ ++ QString domain = partList.join(L1(".")); ++ _domains.append('.' + domain); + _domains.append(domain); + partList.remove(partList.begin()); // Remove part + } + +- // Only URLs that would get in here are of type +- // "host.foo" or "host.co.fo" so simply append +- // a '.' on top to make sure they are stored under +- // the proper cookie domain. +- if (_domains.isEmpty()) +- _domains.append( "." + _fqdn ); +- + // Always add the FQDN at the end of the list for + // hostname == cookie-domainname checks! ++ _domains.append( '.' + _fqdn ); + _domains.append( _fqdn ); + } + +@@ -492,55 +670,73 @@ + // cookie_headers should be a concatenation of all lines of a HTTP-header + // which start with "Set-Cookie". The lines should be separated by '\n's. + // +-KHttpCookiePtr KCookieJar::makeCookies(const QString &_url, ++KHttpCookieList KCookieJar::makeCookies(const QString &_url, + const QCString &cookie_headers, + long windowId) + { +- KHttpCookiePtr cookieChain = 0; ++ KHttpCookieList cookieList; ++ KHttpCookieList cookieList2; + KHttpCookiePtr lastCookie = 0; + const char *cookieStr = cookie_headers.data(); + QString Name; + QString Value; + QString fqdn; + QString path; ++ bool crossDomain = false; + + if (!parseURL(_url, fqdn, path)) + { + // Error parsing _url +- return 0; ++ return KHttpCookieList(); + } ++ QString defaultPath; ++ int i = path.findRev('/'); ++ if (i > 0) ++ defaultPath = path.left(i); + + // The hard stuff :) + for(;;) + { + // check for "Set-Cookie" +- if (strncasecmp(cookieStr, "Set-Cookie:", 11) == 0) ++ if (strncmp(cookieStr, "Cross-Domain\n", 13) == 0) ++ { ++ cookieStr += 13; ++ crossDomain = true; ++ } ++ else if (strncasecmp(cookieStr, "Set-Cookie:", 11) == 0) + { + cookieStr = parseNameValue(cookieStr+11, Name, Value, true); + +- if (Name.isEmpty()) +- continue; +- + // Host = FQDN + // Default domain = "" +- // Default path = "" +- KHttpCookie *cookie = new KHttpCookie(fqdn, "", "", Name, Value); +- cookie->mWindowId = windowId; ++ // Default path according to rfc2109 ++ ++ KHttpCookie *cookie = new KHttpCookie(fqdn, L1(""), defaultPath, Name, Value); ++ if (windowId) ++ cookie->mWindowIds.append(windowId); ++ cookie->mCrossDomain = crossDomain; + + // Insert cookie in chain +- if (lastCookie) +- lastCookie->nextCookie = cookie; +- else +- cookieChain = cookie; ++ cookieList.append(cookie); + lastCookie = cookie; + } +- else if (lastCookie && (strncasecmp(cookieStr, "Set-Cookie2:", 12) == 0)) ++ else if (strncasecmp(cookieStr, "Set-Cookie2:", 12) == 0) + { +- // What the fuck is this? +- // Does anyone invent his own headers these days? +- // Read the fucking RFC guys! This header is not there! +- cookieStr +=12; +- // Continue with lastCookie ++ // Attempt to follow rfc2965 ++ cookieStr = parseNameValue(cookieStr+12, Name, Value, true); ++ ++ // Host = FQDN ++ // Default domain = "" ++ // Default path according to rfc2965 ++ ++ KHttpCookie *cookie = new KHttpCookie(fqdn, L1(""), defaultPath, Name, Value); ++ if (windowId) ++ cookie->mWindowIds.append(windowId); ++ cookie->mCrossDomain = crossDomain; ++ ++ // Insert cookie in chain ++ cookieList2.append(cookie); ++ lastCookie = cookie; + } + else + { +@@ -564,13 +760,12 @@ + // Name-Value pair follows + cookieStr = parseNameValue(cookieStr, Name, Value); + +- Name = Name.lower(); +- +- if (Name == "domain") ++ QCString cName = Name.lower().latin1(); ++ if (cName == "domain") + { + lastCookie->mDomain = Value.lower(); + } +- else if (Name == "max-age") ++ else if (cName == "max-age") + { + int max_age = Value.toInt(); + if (max_age == 0) +@@ -578,23 +773,33 @@ + else + lastCookie->mExpireDate = time(0)+max_age; + } +- else if (Name == "expires") ++ else if (cName == "expires") + { + // Parse brain-dead netscape cookie-format + lastCookie->mExpireDate = KRFCDate::parseDate(Value); + } +- else if (Name == "path") ++ else if (cName == "path") + { +- lastCookie->mPath = Value; ++ if (Value.isEmpty()) ++ lastCookie->mPath = QString::null; // Catch "" <> QString::null ++ else ++ lastCookie->mPath = KURL::decode_string(Value); ++ lastCookie->mExplicitPath = true; + } +- else if (Name == "version") ++ else if (cName == "version") + { + lastCookie->mProtocolVersion = Value.toInt(); + } +- else if (Name == "secure") ++ else if ((cName == "secure") || ++ (cName.isEmpty() && Value.lower() == L1("secure"))) + { + lastCookie->mSecure = true; + } ++ else if ((cName == "httponly") || ++ (cName.isEmpty() && Value.lower() == L1("httponly"))) ++ { ++ lastCookie->mHttpOnly = true; ++ } + } + + if (*cookieStr == '\0') +@@ -604,7 +809,14 @@ + cookieStr++; + } + +- return cookieChain; ++ // RFC2965 cookies come last so that they override netscape cookies. ++ while( !cookieList2.isEmpty() && (lastCookie = cookieList2.take(0)) ) ++ { ++ removeDuplicateFromList(&cookieList, lastCookie, true); ++ cookieList.append(lastCookie); ++ } ++ ++ return cookieList; + } + + /** +@@ -613,12 +825,12 @@ + * pairs. Any whitespace before "name" or around '=' is discarded. + * If no cookies are found, 0 is returned. + */ +-KHttpCookiePtr KCookieJar::makeDOMCookies(const QString &_url, ++KHttpCookieList KCookieJar::makeDOMCookies(const QString &_url, + const QCString &cookie_domstring, + long windowId) + { + // A lot copied from above +- KHttpCookiePtr cookieChain = 0; ++ KHttpCookieList cookieList; + KHttpCookiePtr lastCookie = 0; + + const char *cookieStr = cookie_domstring.data(); +@@ -630,7 +842,7 @@ + if (!parseURL(_url, fqdn, path)) + { + // Error parsing _url +- return 0; ++ return KHttpCookieList(); + } + + // This time it's easy +@@ -638,35 +850,25 @@ + { + cookieStr = parseNameValue(cookieStr, Name, Value); + +- if (Name.isEmpty()) { +- if (*cookieStr != '\0') +- cookieStr++; // Skip ';' or '\n' +- +- continue; +- } +- + // Host = FQDN + // Default domain = "" + // Default path = "" + KHttpCookie *cookie = new KHttpCookie(fqdn, QString::null, QString::null, + Name, Value ); +- cookie->mWindowId = windowId; +- +- // Insert cookie in chain +- if (lastCookie) +- lastCookie->nextCookie = cookie; +- else +- cookieChain = cookie; ++ if (windowId) ++ cookie->mWindowIds.append(windowId); + ++ cookieList.append(cookie); + lastCookie = cookie; + + if (*cookieStr != '\0') + cookieStr++; // Skip ';' or '\n' + } + +- return cookieChain; ++ return cookieList; + } + ++ + // + // This function hands a KHttpCookie object over to the cookie jar. + // +@@ -674,7 +876,6 @@ + // + void KCookieJar::addCookie(KHttpCookiePtr &cookiePtr) + { +- QString domain; + QStringList domains; + KHttpCookieList *cookieList = 0L; + +@@ -686,42 +887,31 @@ + (it != domains.end() && !cookieList); + ++it ) + { +- KHttpCookieList *list= cookieDomains[(*it)]; ++ QString key = (*it).isNull() ? L1("") : (*it); ++ KHttpCookieList *list= m_cookieDomains[key]; + if ( !list ) continue; + +- for ( KHttpCookiePtr cookie=list->first(); cookie != 0; ) +- { +- if ( cookiePtr->name() == cookie->name() && +- cookie->match(cookiePtr->host(),domains,cookiePtr->path()) ) +- { +- KHttpCookiePtr old_cookie = cookie; +- cookie = list->next(); +- list->removeRef( old_cookie ); +- break; +- } +- else +- { +- cookie = list->next(); +- } +- } ++ removeDuplicateFromList(list, cookiePtr, false, true); + } + +- domain = stripDomain( cookiePtr ); +- cookieList = cookieDomains[ domain ]; ++ QString domain = stripDomain( cookiePtr ); ++ QString key = domain.isNull() ? L1("") : domain; ++ cookieList = m_cookieDomains[ key ]; + if (!cookieList) + { + // Make a new cookie list + cookieList = new KHttpCookieList(); ++ cookieList->setAutoDelete(true); + + // All cookies whose domain is not already + // known to us should be added with KCookieDunno. + // KCookieDunno means that we use the global policy. + cookieList->setAdvice( KCookieDunno ); + +- cookieDomains.insert( domain, cookieList); ++ m_cookieDomains.insert( domain, cookieList); + + // Update the list of domains +- domainList.append(domain); ++ m_domainList.append(domain); + } + + // Add the cookie to the cookie list +@@ -729,7 +919,7 @@ + if (!cookiePtr->isExpired(time(0))) + { + cookieList->inSort( cookiePtr ); +- cookiesChanged = true; ++ m_cookiesChanged = true; + } + else + { +@@ -745,12 +935,20 @@ + KCookieAdvice KCookieJar::cookieAdvice(KHttpCookiePtr cookiePtr) + { + QStringList domains; ++ ++ if (m_rejectCrossDomainCookies && cookiePtr->isCrossDomain()) ++ return KCookieReject; ++ ++ if (m_autoAcceptSessionCookies && (cookiePtr->expireDate() == 0 || ++ m_ignoreCookieExpirationDate)) ++ return KCookieAccept; ++ + extractDomains(cookiePtr->host(), domains); +- bool isEmptyDomain = cookiePtr->domain().isEmpty(); + +- if (!isEmptyDomain ) ++ // If the cookie specifies a domain, check whether it is valid and ++ // correct otherwise. ++ if (!cookiePtr->domain().isEmpty()) + { +- // Cookie specifies a domain. Check whether it is valid. + bool valid = false; + + // This checks whether the cookie is valid based on +@@ -764,42 +962,34 @@ + if (!valid) + { + // Maybe the domain doesn't start with a "." +- QString domain = "."+cookiePtr->domain(); ++ QString domain = '.' + cookiePtr->domain(); + if (domains.contains(domain)) + valid = true; + } + + if (!valid) + { +- qWarning("WARNING: Host %s tries to set cookie for domain %s", +- cookiePtr->host().latin1(), cookiePtr->domain().latin1()); + cookiePtr->fixDomain(QString::null); +- isEmptyDomain = true; + } + } + +- // For empty domain use the FQDN to find a +- // matching advice for the pending cookie. +- QString domain; +- if ( isEmptyDomain ) +- domain = domains[0]; +- else +- domain = cookiePtr->domain(); ++ KCookieAdvice advice = KCookieDunno; + +- KHttpCookieList *cookieList = cookieDomains[domain]; +- KCookieAdvice advice; +- if (cookieList) +- { +- advice = cookieList->getAdvice(); +- if (advice == KCookieDunno) +- { +- advice = globalAdvice; +- } +- } +- else ++ QStringList::Iterator it = domains.fromLast(); // Start with FQDN which is last in the list. ++ while( (advice == KCookieDunno) && (it != domains.end())) + { +- advice = globalAdvice; ++ QString domain = *it; ++ // Check if a policy for the FQDN/domain is set. ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; ++ if (cookieList) ++ advice = cookieList->getAdvice(); ++ domains.remove(it); ++ it = domains.begin(); // Continue from begin of remaining list + } ++ ++ if (advice == KCookieDunno) ++ advice = m_globalAdvice; ++ + return advice; + } + +@@ -809,7 +999,7 @@ + // + KCookieAdvice KCookieJar::getDomainAdvice(const QString &_domain) + { +- KHttpCookieList *cookieList = cookieDomains[_domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[_domain]; + KCookieAdvice advice; + + if (cookieList) +@@ -831,13 +1021,13 @@ + void KCookieJar::setDomainAdvice(const QString &_domain, KCookieAdvice _advice) + { + QString domain(_domain); +- KHttpCookieList *cookieList = cookieDomains[domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; + + if (cookieList) + { +- if (cookieList->getAdvice() != _advice); ++ if (cookieList->getAdvice() != _advice) + { +- configChanged = true; ++ m_configChanged = true; + // domain is already known + cookieList->setAdvice( _advice); + } +@@ -846,8 +1036,8 @@ + (_advice == KCookieDunno)) + { + // This deletes cookieList! +- cookieDomains.remove(domain); +- domainList.remove(domain); ++ m_cookieDomains.remove(domain); ++ m_domainList.remove(domain); + } + } + else +@@ -856,13 +1046,14 @@ + if (_advice != KCookieDunno) + { + // We should create a domain entry +- configChanged = true; ++ m_configChanged = true; + // Make a new cookie list + cookieList = new KHttpCookieList(); ++ cookieList->setAutoDelete(true); + cookieList->setAdvice( _advice); +- cookieDomains.insert( domain, cookieList); ++ m_cookieDomains.insert( domain, cookieList); + // Update the list of domains +- domainList.append( domain); ++ m_domainList.append( domain); + } + } + } +@@ -883,9 +1074,9 @@ + // + void KCookieJar::setGlobalAdvice(KCookieAdvice _advice) + { +- if (globalAdvice != _advice) +- configChanged = true; +- globalAdvice = _advice; ++ if (m_globalAdvice != _advice) ++ m_configChanged = true; ++ m_globalAdvice = _advice; + } + + // +@@ -893,7 +1084,7 @@ + // + const QStringList& KCookieJar::getDomainList() + { +- return domainList; ++ return m_domainList; + } + + // +@@ -909,7 +1100,7 @@ + else + domain = _domain; + +- return cookieDomains[domain]; ++ return m_cookieDomains[domain]; + } + + // +@@ -919,86 +1110,97 @@ + void KCookieJar::eatCookie(KHttpCookiePtr cookiePtr) + { + QString domain = stripDomain(cookiePtr); // We file the cookie under this domain. +- KHttpCookieList *cookieList = cookieDomains[domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; + + if (cookieList) + { + // This deletes cookiePtr! + if (cookieList->removeRef( cookiePtr )) +- cookiesChanged = true; ++ m_cookiesChanged = true; + + if ((cookieList->isEmpty()) && + (cookieList->getAdvice() == KCookieDunno)) + { + // This deletes cookieList! +- cookieDomains.remove(domain); ++ m_cookieDomains.remove(domain); + +- domainList.remove(domain); ++ m_domainList.remove(domain); + } + } + } + + void KCookieJar::eatCookiesForDomain(const QString &domain) + { +- KHttpCookieList *cookieList = cookieDomains[domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; + if (!cookieList || cookieList->isEmpty()) return; + + cookieList->clear(); + if (cookieList->getAdvice() == KCookieDunno) + { + // This deletes cookieList! +- cookieDomains.remove(domain); +- domainList.remove(domain); ++ m_cookieDomains.remove(domain); ++ m_domainList.remove(domain); + } +- cookiesChanged = true; ++ m_cookiesChanged = true; + } + +-void KCookieJar::eatSessionCookies( int winId ) ++void KCookieJar::eatSessionCookies( long windowId ) + { +- QStringList::Iterator it=domainList.begin(); +- for ( ; it != domainList.end(); ++it ) +- eatSessionCookies( *it, winId, false ); ++ if (!windowId) ++ return; ++ ++ QStringList::Iterator it=m_domainList.begin(); ++ for ( ; it != m_domainList.end(); ++it ) ++ eatSessionCookies( *it, windowId, false ); + } + +-void KCookieJar::eatSessionCookies( const QString& fqdn, int winId, ++void KCookieJar::eatAllCookies() ++{ ++ for ( QStringList::Iterator it=m_domainList.begin(); ++ it != m_domainList.end();) ++ { ++ QString domain = *it++; ++ // This might remove domain from domainList! ++ eatCookiesForDomain(domain); ++ } ++} ++ ++void KCookieJar::eatSessionCookies( const QString& fqdn, long windowId, + bool isFQDN ) + { + KHttpCookieList* cookieList; +- if ( isFQDN ) ++ if ( !isFQDN ) ++ cookieList = m_cookieDomains[fqdn]; ++ else + { + QString domain; + stripDomain( fqdn, domain ); +- cookieList = cookieDomains[domain]; ++ cookieList = m_cookieDomains[domain]; + } +- else +- cookieList = cookieDomains[fqdn]; + + if ( cookieList ) + { + KHttpCookiePtr cookie=cookieList->first(); + for (; cookie != 0;) + { +- if (cookie->windowId() == winId && +- (cookie->expireDate() == 0)) ++ if ((cookie->expireDate() != 0) && !m_ignoreCookieExpirationDate) + { +- KHttpCookiePtr old_cookie = cookie; +- cookie = cookieList->next(); +- cookieList->removeRef( old_cookie ); ++ cookie = cookieList->next(); ++ continue; + } +- else +- cookie = cookieList->next(); +- } +- } +-} +- + +-void KCookieJar::eatAllCookies() +-{ +- for ( QStringList::Iterator it=domainList.begin(); +- it != domainList.end();) +- { +- QString domain = *it++; +- eatCookiesForDomain(domain); // This might remove domain from domainList! ++ QValueList<long> &ids = cookie->windowIds(); ++ bool empty = (ids.find(windowId) == ids.end() ); ++ ids.remove(windowId); ++ if (!empty || !ids.isEmpty()) ++ { ++ cookie = cookieList->next(); ++ continue; ++ } ++ KHttpCookiePtr old_cookie = cookie; ++ cookie = cookieList->next(); ++ cookieList->removeRef( old_cookie ); ++ } + } + } + +@@ -1008,7 +1210,7 @@ + // On failure 'false' is returned. + bool KCookieJar::saveCookies(const QString &_filename) + { +- KSaveFile saveFile(_filename); ++ KSaveFile saveFile(_filename, 0600); + + if (saveFile.status() != 0) + return false; +@@ -1017,31 +1219,31 @@ + + time_t curTime = time(0); + +- fprintf(fStream, "# KDE Cookie File\n#\n"); ++ fprintf(fStream, "# KDE Cookie File v2\n#\n"); + +- fprintf(fStream, "%-20s %-20s %-12s %-9s %-4s %-10s %s %-4s\n", +- "# Host", "Domain", "Path", "Exp.date", "Prot", "Name", "Value", "Secure"); ++ fprintf(fStream, "%-20s %-20s %-12s %-10s %-4s %-20s %-4s %s\n", ++ "# Host", "Domain", "Path", "Exp.date", "Prot", ++ "Name", "Sec", "Value"); + +- for ( QStringList::Iterator it=domainList.begin(); +- it != domainList.end(); +- it++) ++ for ( QStringList::Iterator it=m_domainList.begin(); it != m_domainList.end(); ++ it++ ) + { + const QString &domain = *it; + bool domainPrinted = false; + +- KHttpCookieList *cookieList = cookieDomains[domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; + KHttpCookiePtr cookie=cookieList->first(); + +- for (; cookie != 0;) ++ for (; cookie != 0;) + { + if (cookie->isExpired(curTime)) +- { +- // Delete expired cookies ++ { ++ // Delete expired cookies + KHttpCookiePtr old_cookie = cookie; + cookie = cookieList->next(); + cookieList->removeRef( old_cookie ); +- } +- else if (cookie->expireDate() != 0) ++ } ++ else if (cookie->expireDate() != 0 && !m_ignoreCookieExpirationDate) + { + if (!domainPrinted) + { +@@ -1049,25 +1251,26 @@ + fprintf(fStream, "[%s]\n", domain.local8Bit().data()); + } + // Store persistent cookies +- QString path("\""); ++ QString path = L1("\""); + path += cookie->path(); +- path += "\""; +- QString domain("\""); ++ path += '"'; ++ QString domain = L1("\""); + domain += cookie->domain(); +- domain += "\""; +- fprintf(fStream, "%-20s %-20s %-12s %9lu %2d %-10s %s %-4i\n", +- cookie->host().local8Bit().data(), domain.local8Bit().data(), path.local8Bit().data(), +- (unsigned long) cookie->expireDate(), cookie->protocolVersion()+100, +- cookie->name().local8Bit().data(), cookie->value().local8Bit().data(), +- cookie->isSecure()); +- cookie = cookieList->next(); +- } +- else +- { +- // Skip session-only cookies +- cookie = cookieList->next(); +- } +- } ++ domain += '"'; ++ fprintf(fStream, "%-20s %-20s %-12s %10lu %3d %-20s %-4i %s\n", ++ cookie->host().latin1(), domain.latin1(), ++ path.latin1(), (unsigned long) cookie->expireDate(), ++ cookie->protocolVersion(), cookie->name().latin1(), ++ (cookie->isSecure() ? 1 : 0) + (cookie->isHttpOnly() ? 2 : 0) + (cookie->hasExplicitPath() ? 4 : 0), ++ cookie->value().latin1()); ++ cookie = cookieList->next(); ++ } ++ else ++ { ++ // Skip session-only cookies ++ cookie = cookieList->next(); ++ } ++ } + } + + return saveFile.close(); +@@ -1080,26 +1283,27 @@ + char *result; + if (!keepQuotes && (*buffer == '\"')) + { +- // Find terminating " ++ // Find terminating " + buffer++; + result = buffer; + while((*buffer != '\"') && (*buffer)) +- buffer++; ++ buffer++; + } + else + { + // Find first white space + result = buffer; + while((*buffer != ' ') && (*buffer != '\t') && (*buffer != '\n') && (*buffer)) +- buffer++; ++ buffer++; + } ++ + if (!*buffer) +- return result; // ++ return result; // + *buffer++ = '\0'; + + // Skip white-space + while((*buffer == ' ') || (*buffer == '\t') || (*buffer == '\n')) +- buffer++; ++ buffer++; + + return result; + } +@@ -1124,7 +1328,18 @@ + bool err = false; + err = (fgets(buffer, READ_BUFFER_SIZE, fStream) == 0); + +- err = err || (strcmp(buffer, "# KDE Cookie File\n") != 0); ++ int version = 1; ++ if (!err) ++ { ++ if (strcmp(buffer, "# KDE Cookie File\n") == 0) ++ { ++ // version 1 ++ } ++ else if (sscanf(buffer, "# KDE Cookie File v%d\n", &version) != 1) ++ { ++ err = true; ++ } ++ } + + if (!err) + { +@@ -1146,13 +1361,31 @@ + int protVer = (time_t) strtoul(verStr, 0, 10); + const char *name( parseField(line) ); + bool keepQuotes = false; +- if (protVer >= 100) ++ bool secure = false; ++ bool httpOnly = false; ++ bool explicitPath = false; ++ const char *value = 0; ++ if ((version == 2) || (protVer >= 200)) + { +- protVer -= 100; +- keepQuotes = true; ++ if (protVer >= 200) ++ protVer -= 200; ++ int i = atoi( parseField(line) ); ++ secure = i & 1; ++ httpOnly = i & 2; ++ explicitPath = i & 4; ++ line[strlen(line)-1] = '\0'; // Strip LF. ++ value = line; ++ } ++ else ++ { ++ if (protVer >= 100) ++ { ++ protVer -= 100; ++ keepQuotes = true; ++ } ++ value = parseField(line, keepQuotes); ++ secure = atoi( parseField(line) ); + } +- const char *value( parseField(line, keepQuotes) ); +- bool secure = atoi( parseField(line) ); + + // Parse error + if (!value) continue; +@@ -1161,15 +1394,18 @@ + if ((expDate == 0) || (expDate < curTime)) + continue; + +- KHttpCookie *cookie = new KHttpCookie(host, domain, path, name, +- value, expDate, protVer, +- secure); +- if ( cookieAdvice( cookie ) ) +- addCookie(cookie); ++ KHttpCookie *cookie = new KHttpCookie(QString::fromLatin1(host), ++ QString::fromLatin1(domain), ++ QString::fromLatin1(path), ++ QString::fromLatin1(name), ++ QString::fromLatin1(value), ++ expDate, protVer, ++ secure, httpOnly, explicitPath); ++ addCookie(cookie); + } + } + delete [] buffer; +- cookiesChanged = false; ++ m_cookiesChanged = false; + + fclose( fStream); + return err; +@@ -1181,19 +1417,18 @@ + + void KCookieJar::saveConfig(KConfig *_config) + { +- if (!configChanged) ++ if (!m_configChanged) + return; + +- _config->setGroup(QString::null); +- _config->writeEntry("DefaultRadioButton", defaultRadioButton); +- _config->writeEntry("ShowCookieDetails", showCookieDetails ); +- +- QStringList domainSettings; ++ _config->setGroup("Cookie Dialog"); ++ _config->writeEntry("PreferredPolicy", m_preferredPolicy); ++ _config->writeEntry("ShowCookieDetails", m_showCookieDetails ); + _config->setGroup("Cookie Policy"); +- _config->writeEntry("CookieGlobalAdvice", adviceToStr( globalAdvice)); ++ _config->writeEntry("CookieGlobalAdvice", adviceToStr( m_globalAdvice)); + +- for ( QStringList::Iterator it=domainList.begin(); +- it != domainList.end(); ++ QStringList domainSettings; ++ for ( QStringList::Iterator it=m_domainList.begin(); ++ it != m_domainList.end(); + it++ ) + { + const QString &domain = *it; +@@ -1208,6 +1443,7 @@ + } + _config->writeEntry("CookieDomainAdvice", domainSettings); + _config->sync(); ++ m_configChanged = false; + } + + +@@ -1217,23 +1453,23 @@ + + void KCookieJar::loadConfig(KConfig *_config, bool reparse ) + { +- QString value; +- QStringList domainSettings; +- + if ( reparse ) + _config->reparseConfiguration(); + +- _config->setGroup(QString::null); +- defaultRadioButton = _config->readNumEntry( "DefaultRadioButton", 0 ); +- showCookieDetails = _config->readBoolEntry( "ShowCookieDetails" ); ++ _config->setGroup("Cookie Dialog"); ++ m_showCookieDetails = _config->readBoolEntry( "ShowCookieDetails" ); ++ m_preferredPolicy = _config->readNumEntry( "PreferredPolicy", 0 ); + + _config->setGroup("Cookie Policy"); +- value = _config->readEntry("CookieGlobalAdvice", "Ask"); +- globalAdvice = strToAdvice(value); +- domainSettings = _config->readListEntry("CookieDomainAdvice"); ++ QStringList domainSettings = _config->readListEntry("CookieDomainAdvice"); ++ m_rejectCrossDomainCookies = _config->readBoolEntry( "RejectCrossDomainCookies", true ); ++ m_autoAcceptSessionCookies = _config->readBoolEntry( "AcceptSessionCookies", true ); ++ m_ignoreCookieExpirationDate = _config->readBoolEntry( "IgnoreExpirationDate", false ); ++ QString value = _config->readEntry("CookieGlobalAdvice", L1("Ask")); ++ m_globalAdvice = strToAdvice(value); + + // Reset current domain settings first. +- for ( QStringList::Iterator it=domainList.begin(); it != domainList.end(); ) ++ for ( QStringList::Iterator it=m_domainList.begin(); it != m_domainList.end(); ) + { + // Make sure to update iterator before calling setDomainAdvice() + // setDomainAdvice() might delete the domain from domainList. +@@ -1241,16 +1477,19 @@ + setDomainAdvice(domain, KCookieDunno); + } + +- // Now apply the ++ // Now apply the domain settings read from config file... + for ( QStringList::Iterator it=domainSettings.begin(); + it != domainSettings.end(); ) + { + const QString &value = *it++; ++ + int sepPos = value.find(':'); +- if (sepPos <= 0) { continue; } ++ ++ if (sepPos <= 0) ++ continue; ++ + QString domain(value.left(sepPos)); + KCookieAdvice advice = strToAdvice( value.mid(sepPos + 1) ); + setDomainAdvice(domain, advice); + } + } +- +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiejar.h~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiejar.h +@@ -20,7 +20,7 @@ + //---------------------------------------------------------------------------- + // + // KDE File Manager -- HTTP Cookies +-// $Id: kcookiejar.h,v 1.21.2.1 2001/09/08 22:03:49 adawit Exp $ ++// $Id: kcookiejar.h,v 1.34 2004/07/20 15:29:24 waba Exp $ + + #ifndef KCOOKIEJAR_H + #define KCOOKIEJAR_H +@@ -59,10 +59,12 @@ + QString mValue; + time_t mExpireDate; + int mProtocolVersion; +- long mWindowId; + bool mSecure; ++ bool mCrossDomain; ++ bool mHttpOnly; ++ bool mExplicitPath; ++ QValueList<long> mWindowIds; + +- KHttpCookiePtr nextCookie; + QString cookieStr(bool useDOMFormat); + + public: +@@ -73,28 +75,32 @@ + const QString &_value=QString::null, + time_t _expireDate=0, + int _protocolVersion=0, +- bool _secure = false); ++ bool _secure = false, ++ bool _httpOnly = false, ++ bool _explicitPath = false); + + QString domain(void) { return mDomain; } + QString host(void) { return mHost; } + QString path(void) { return mPath; } + QString name(void) { return mName; } + QString value(void) { return mValue; } +- long windowId(void) { return mWindowId; } ++ QValueList<long> &windowIds(void) { return mWindowIds; } + void fixDomain(const QString &domain) { mDomain = domain; } + time_t expireDate(void) { return mExpireDate; } + int protocolVersion(void) { return mProtocolVersion; } + bool isSecure(void) { return mSecure; } + bool isExpired(time_t currentDate); ++ bool isCrossDomain(void) { return mCrossDomain; } ++ bool isHttpOnly(void) { return mHttpOnly; } ++ bool hasExplicitPath(void) { return mExplicitPath; } + bool match(const QString &fqdn, const QStringList &domainList, const QString &path); +- KHttpCookiePtr next() { return nextCookie; } + }; + + class KHttpCookieList : public QList<KHttpCookie> + { + public: + KHttpCookieList() : QList<KHttpCookie>(), advice( KCookieDunno ) +- { setAutoDelete(true); } ++ { } + virtual ~KHttpCookieList() { } + + virtual int compareItems( void * item1, void * item2); +@@ -125,7 +131,7 @@ + /** + * Returns whether the cookiejar has been changed + */ +- bool changed() { return cookiesChanged || configChanged; } ++ bool changed() const { return m_cookiesChanged || m_configChanged; } + + /** + * Store all the cookies in a safe(?) place +@@ -154,8 +160,11 @@ + * + * If @p useDOMFormat is true, the string is formatted in a format + * in compliance with the DOM standard. ++ * @p pendingCookies contains a list of cookies that have not been ++ * approved yet by the user but that will be included in the result ++ * none the less. + */ +- QString findCookies(const QString &_url, bool useDOMFormat); ++ QString findCookies(const QString &_url, bool useDOMFormat, long windowId, KHttpCookieList *pendingCookies=0); + + /** + * This function parses cookie_headers and returns a linked list of +@@ -165,17 +174,17 @@ + * cookie_headers should be a concatenation of all lines of a HTTP-header + * which start with "Set-Cookie". The lines should be separated by '\n's. + */ +- KHttpCookiePtr makeCookies(const QString &_url, const QCString &cookie_headers, long windowId); ++ KHttpCookieList makeCookies(const QString &_url, const QCString &cookie_headers, long windowId); + + /** + * This function parses cookie_headers and returns a linked list of + * valid KHttpCookie objects for all cookies found in cookie_headers. + * If no cookies could be found 0 is returned. + * +- * cookie_domstr should be a concatenation of "name=value" pairs, seperated ++ * cookie_domstr should be a concatenation of "name=value" pairs, separated + * by a semicolon ';'. + */ +- KHttpCookiePtr makeDOMCookies(const QString &_url, const QCString &cookie_domstr, long windowId); ++ KHttpCookieList makeDOMCookies(const QString &_url, const QCString &cookie_domstr, long windowId); + + /** + * This function hands a KHttpCookie object over to the cookie jar. +@@ -279,13 +288,13 @@ + * Removes all end of session cookies set by the + * session @p windId. + */ +- void eatSessionCookies( int windId ); ++ void eatSessionCookies( long windowId ); + + /** + * Removes all end of session cookies set by the + * session @p windId. + */ +- void eatSessionCookies( const QString& fqdn, int windId, bool isFQDN = true ); ++ void eatSessionCookies( const QString& fqdn, long windowId, bool isFQDN = true ); + + /** + * Parses _url and returns the FQDN (_fqdn) and path (_path). +@@ -297,21 +306,46 @@ + /** + * Returns a list of domains (_domainList) relevant for this host. + */ +- static void extractDomains(const QString &_fqdn, +- QStringList &_domainList); ++ void extractDomains(const QString &_fqdn, ++ QStringList &_domainList); + + static QString adviceToStr(KCookieAdvice _advice); + static KCookieAdvice strToAdvice(const QString &_str); + +- // Save this in the config file... +- int defaultRadioButton; // 0 = This cookie, 1 = domain, 2 = all cookies +- bool showCookieDetails; // true, false ++ /** Returns the */ ++ int preferredDefaultPolicy() const { return m_preferredPolicy; } ++ ++ /** Returns the */ ++ bool showCookieDetails () const { return m_showCookieDetails; } ++ ++ /** ++ * Sets the user's default preference cookie policy. ++ */ ++ void setPreferredDefaultPolicy (int value) { m_preferredPolicy = value; } ++ ++ /** ++ * Sets the user's preference of level of detail displayed ++ * by the cookie dialog. ++ */ ++ void setShowCookieDetails (bool value) { m_showCookieDetails = value; } + + protected: +- QDict<KHttpCookieList> cookieDomains; +- QStringList domainList; +- KCookieAdvice globalAdvice; +- bool configChanged; +- bool cookiesChanged; ++ void stripDomain(const QString &_fqdn, QString &_domain); ++ QString stripDomain( KHttpCookiePtr cookiePtr); ++ ++protected: ++ QStringList m_domainList; ++ KCookieAdvice m_globalAdvice; ++ QDict<KHttpCookieList> m_cookieDomains; ++ QDict<int> m_twoLevelTLD; ++ ++ bool m_configChanged; ++ bool m_cookiesChanged; ++ bool m_showCookieDetails; ++ bool m_rejectCrossDomainCookies; ++ bool m_autoAcceptSessionCookies; ++ bool m_ignoreCookieExpirationDate; ++ ++ int m_preferredPolicy; + }; + #endif +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver.cpp~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver.cpp +@@ -23,25 +23,30 @@ + //---------------------------------------------------------------------------- + // + // KDE Cookie Server +-// $Id: kcookieserver.cpp,v 1.33.2.1 2001/09/08 22:03:49 adawit Exp $ ++// $Id: kcookieserver.cpp,v 1.52 2004/08/16 14:04:40 lunakl Exp $ + + #define SAVE_DELAY 3 // Save after 3 minutes + +-#include "kcookieserver.h" +-#include "kcookiejar.h" +-#include "kcookiewin.h" ++#include <unistd.h> + +-#include <kdebug.h> +-#include <kapp.h> +-#include <kcmdlineargs.h> +-#include <kstddirs.h> + #include <qtimer.h> +-#include <unistd.h> + #include <qlist.h> + #include <qfile.h> + + #include <dcopclient.h> ++ + #include <kconfig.h> ++#include <kdebug.h> ++#include <kcmdlineargs.h> ++#include <kstddirs.h> ++ ++#ifdef _QT_QPE_ ++#include <qpe/qpeapplication.h> ++#endif ++ ++#include "kcookiejar.h" ++#include "kcookiewin.h" ++#include "kcookieserver.h" + + // Cookie field indexes + enum CookieDetails { CF_DOMAIN=0, CF_PATH, CF_NAME, CF_HOST, +@@ -53,6 +58,7 @@ + DCOPClientTransaction *transaction; + QString url; + bool DOM; ++ long windowId; + }; + + template class QList<CookieRequest>; +@@ -68,10 +74,11 @@ + { + mCookieJar = new KCookieJar; + mPendingCookies = new KHttpCookieList; ++ mPendingCookies->setAutoDelete(true); + mRequestList = new RequestList; + mAdvicePending = false; + mTimer = 0; +- mCookieJar->loadConfig( kapp->config()); ++ mCookieJar->loadConfig( kapp->config() ); + + QString filename = locateLocal("appdata", "cookies"); + +@@ -89,12 +96,16 @@ + { + mCookieJar->loadCookies( filename); + } ++ ++ QWidget *wid = qApp->desktop(); ++ mBigScreen = (wid->width() > 320 || wid->height() > 320); + } + + KCookieServer::~KCookieServer() + { + if (mCookieJar->changed()) + slotSave(); ++ + delete mCookieJar; + delete mTimer; + delete mPendingCookies; +@@ -125,7 +136,7 @@ + return 0; + } + +-bool KCookieServer::cookiesPending( const QString &url ) ++bool KCookieServer::cookiesPending( const QString &url, KHttpCookieList *cookieList ) + { + QString fqdn; + QStringList domains; +@@ -136,109 +147,161 @@ + if (!KCookieJar::parseURL(url, fqdn, path)) + return false; + +- KCookieJar::extractDomains( fqdn, domains ); ++ mCookieJar->extractDomains( fqdn, domains ); + for( KHttpCookie *cookie = mPendingCookies->first(); + cookie != 0L; + cookie = mPendingCookies->next()) + { + if (cookie->match( fqdn, domains, path)) +- return true; ++ { ++ if (!cookieList) ++ return true; ++ cookieList->append(cookie); ++ } + } +- return false; ++ if (!cookieList) ++ return false; ++ return cookieList->isEmpty(); + } + + void KCookieServer::addCookies( const QString &url, const QCString &cookieHeader, + long windowId, bool useDOMFormat ) + { +- KHttpCookiePtr cookie = 0; ++ KHttpCookieList cookieList; + if (useDOMFormat) +- cookie = mCookieJar->makeDOMCookies(url, cookieHeader, windowId); ++ cookieList = mCookieJar->makeDOMCookies(url, cookieHeader, windowId); + else +- cookie = mCookieJar->makeCookies(url, cookieHeader, windowId); ++ cookieList = mCookieJar->makeCookies(url, cookieHeader, windowId); + +- if (mAdvicePending) +- { +- checkCookies(cookie, true); +- } +- else ++ checkCookies(&cookieList); ++ ++ for(KHttpCookiePtr cookie = cookieList.first(); cookie; cookie = cookieList.first()) ++ mPendingCookies->append(cookieList.take()); ++ ++ if (!mAdvicePending) + { + mAdvicePending = true; +- do { +- checkCookies(cookie, false); +- cookie = mPendingCookies->count() ? mPendingCookies->take(0) : 0; ++ while (!mPendingCookies->isEmpty()) ++ { ++ checkCookies(0); + } +- while (cookie); + mAdvicePending = false; + } +- + } + +-void KCookieServer::checkCookies( KHttpCookie *cookie, bool queue ) ++void KCookieServer::checkCookies( KHttpCookieList *cookieList) + { +- QString host; +- KCookieAdvice userAdvice = KCookieDunno; +- if (cookie) host = cookie->host(); ++ KHttpCookieList *list; ++ ++ if (cookieList) ++ list = cookieList; ++ else ++ list = mPendingCookies; ++ ++ KHttpCookiePtr cookie = list->first(); + while (cookie) + { +- KHttpCookiePtr next_cookie = cookie->next(); + KCookieAdvice advice = mCookieJar->cookieAdvice(cookie); +- if ((advice == KCookieAsk) || (advice == KCookieDunno)) +- { +- // We only ask the user once, even if we get multiple +- // cookies from the same site. +- if (userAdvice == KCookieDunno) +- { +- if (queue) +- { +- mPendingCookies->append(cookie); +- return; +- } +- else +- { +- mPendingCookies->prepend(cookie); +- KCookieWin *kw = new KCookieWin( 0L, cookie, +- mCookieJar->defaultRadioButton, +- mCookieJar->showCookieDetails ); +- userAdvice = kw->advice(mCookieJar, cookie); +- delete kw; +- mPendingCookies->take(0); +- // Save the cookie config if it has changed +- mCookieJar->saveConfig( kapp->config() ); +- } +- } +- advice = userAdvice; +- } + switch(advice) + { + case KCookieAccept: ++ list->take(); + mCookieJar->addCookie(cookie); ++ cookie = list->current(); + break; + + case KCookieReject: +- default: ++ list->take(); + delete cookie; ++ cookie = list->current(); ++ break; ++ ++ default: ++ cookie = list->next(); + break; + } +- cookie = next_cookie; +- if (!cookie && !queue) ++ } ++ ++ if (cookieList || list->isEmpty()) ++ return; ++ ++ KHttpCookiePtr currentCookie = mPendingCookies->first(); ++ ++ KHttpCookieList currentList; ++ currentList.append(currentCookie); ++ QString currentHost = currentCookie->host(); ++ ++ cookie = mPendingCookies->next(); ++ while (cookie) ++ { ++ if (cookie->host() == currentHost) + { +- // Check if there are cookies on the pending list from the +- // same host. +- for( cookie = mPendingCookies->first(); +- cookie; +- cookie = mPendingCookies->next()) +- { +- if (cookie->host() == host) +- break; +- } +- if (cookie) ++ currentList.append(cookie); ++ } ++ cookie = mPendingCookies->next(); ++ } ++ ++ KCookieWin *kw; ++ KScrolledCookieWin *skw= 0L; ++ ++ if(!mBigScreen) { ++ qWarning( "Using Scrolled Cookie WIn" ); ++ skw = new KScrolledCookieWin(0L, currentList, ++ mCookieJar->preferredDefaultPolicy(), ++ mCookieJar->showCookieDetails() ); ++ kw = skw->cookieWindow(); ++ }else ++ kw = new KCookieWin( 0L, currentList, ++ mCookieJar->preferredDefaultPolicy(), ++ mCookieJar->showCookieDetails() ); ++ ++#ifdef _QT_QPE_ ++ int result = QPEApplication::execDialog( !mBigScreen ? ++ static_cast<QDialog*>( skw ) : ++ static_cast<QDialog*>( kw ) ); ++#else ++ int result = !mBigScreen ? skw->exec() : kw->exec(); ++#endif ++ ++ KCookieAdvice userAdvice = kw->advice( result, mCookieJar, currentCookie); ++ delete kw; ++ delete skw; ++ // Save the cookie config if it has changed ++ mCookieJar->saveConfig( kapp->config() ); ++ ++ // Apply the user's choice to all cookies that are currently ++ // queued for this host. ++ cookie = mPendingCookies->first(); ++ while (cookie) ++ { ++ if (cookie->host() == currentHost) ++ { ++ switch(userAdvice) + { +- // Found a matching cookie, remove it from the pending list. +- cookie = mPendingCookies->take(); ++ case KCookieAccept: ++ mPendingCookies->take(); ++ mCookieJar->addCookie(cookie); ++ cookie = mPendingCookies->current(); ++ break; ++ ++ case KCookieReject: ++ mPendingCookies->take(); ++ delete cookie; ++ cookie = mPendingCookies->current(); ++ break; ++ ++ default: ++ cookie = mPendingCookies->next(); ++ break; + } + } ++ else ++ { ++ cookie = mPendingCookies->next(); ++ } + } + ++ + // Check if we can handle any request + for ( CookieRequest *request = mRequestList->first(); request;) + { +@@ -246,13 +309,13 @@ + { + QCString replyType; + QByteArray replyData; +- QString res = mCookieJar->findCookies( request->url, request->DOM ); ++ QString res = mCookieJar->findCookies( request->url, request->DOM, request->windowId ); + + QDataStream stream2(replyData, IO_WriteOnly); + stream2 << res; + replyType = "QString"; + dcopClient()->endTransaction( request->transaction, +- replyType, replyData); ++ replyType, replyData); + CookieRequest *tmp = request; + request = mRequestList->next(); + mRequestList->removeRef( tmp ); +@@ -271,7 +334,7 @@ + { + delete mTimer; + mTimer = 0; +- QString filename = locateLocal("appdata", "cookies"); ++ QString filename = locateLocal("data", "kcookiejar/cookies"); + mCookieJar->saveCookies(filename); + } + +@@ -333,8 +396,9 @@ + return + ((hasDomain && c->domain() == domain) || + fqdn == c->host()) && +- (c->path() == path) && +- (c->name() == name); ++ (c->path() == path) && ++ (c->name() == name) && ++ (!c->isExpired(time(0))); + } + return false; + } +@@ -343,16 +407,30 @@ + QString + KCookieServer::findCookies(QString url) + { ++ return findCookies(url, 0); ++} ++ ++// DCOP function ++QString ++KCookieServer::findCookies(QString url, long windowId) ++{ + if (cookiesPending(url)) + { + CookieRequest *request = new CookieRequest; + request->transaction = dcopClient()->beginTransaction(); + request->url = url; + request->DOM = false; ++ request->windowId = windowId; + mRequestList->append( request ); + return QString::null; // Talk to you later :-) + } +- return mCookieJar->findCookies(url, false); ++ ++ QString cookies = mCookieJar->findCookies(url, false, windowId); ++ ++ if (mCookieJar->changed() && !mTimer) ++ saveCookieJar(); ++ ++ return cookies; + } + + // DCOP function +@@ -409,16 +487,20 @@ + QString + KCookieServer::findDOMCookies(QString url) + { +- if (cookiesPending(url)) +- { +- CookieRequest *request = new CookieRequest; +- request->transaction = dcopClient()->beginTransaction(); +- request->url = url; +- request->DOM = true; +- mRequestList->append( request ); +- return QString::null; // Talk to you later :-) +- } +- return mCookieJar->findCookies(url, true); ++ return findDOMCookies(url, 0); ++} ++ ++// DCOP function ++QString ++KCookieServer::findDOMCookies(QString url, long windowId) ++{ ++ // We don't wait for pending cookies because it locks up konqueror ++ // which can cause a deadlock if it happens to have a popup-menu up. ++ // Instead we just return pending cookies as if they had been accepted already. ++ KHttpCookieList pendingCookies; ++ cookiesPending(url, &pendingCookies); ++ ++ return mCookieJar->findCookies(url, true, windowId, &pendingCookies); + } + + // DCOP function +@@ -459,18 +541,27 @@ + saveCookieJar(); + } + ++ ++// Qt function + void +-KCookieServer::deleteSessionCookies( long winId ) ++KCookieServer::slotDeleteSessionCookies( long windowId ) + { +- mCookieJar->eatSessionCookies( winId ); ++ deleteSessionCookies(windowId); ++} ++ ++// DCOP function ++void ++KCookieServer::deleteSessionCookies( long windowId ) ++{ ++ mCookieJar->eatSessionCookies( windowId ); + if(!mTimer) + saveCookieJar(); + } + + void +-KCookieServer::deleteSessionCookiesFor(QString fqdn, long winId) ++KCookieServer::deleteSessionCookiesFor(QString fqdn, long windowId) + { +- mCookieJar->eatSessionCookies( fqdn, winId ); ++ mCookieJar->eatSessionCookies( fqdn, windowId ); + if(!mTimer) + saveCookieJar(); + } +@@ -500,7 +591,7 @@ + if (KCookieJar::parseURL(url, fqdn, dummy)) + { + QStringList domains; +- KCookieJar::extractDomains(fqdn, domains); ++ mCookieJar->extractDomains(fqdn, domains); + mCookieJar->setDomainAdvice(domains[0], + KCookieJar::strToAdvice(advice)); + } +@@ -516,7 +607,7 @@ + if (KCookieJar::parseURL(url, fqdn, dummy)) + { + QStringList domains; +- KCookieJar::extractDomains(fqdn, domains); ++ mCookieJar->extractDomains(fqdn, domains); + advice = mCookieJar->getDomainAdvice(domains[0]); + } + return KCookieJar::adviceToStr(advice); +@@ -533,7 +624,7 @@ + void + KCookieServer::shutdown() + { +- quit(); ++ quit(); + } + + #include "kcookieserver.moc" +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver.h~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver.h +@@ -20,7 +20,7 @@ + //---------------------------------------------------------------------------- + // + // KDE Cookie Server +-// $Id: kcookieserver.h,v 1.15.2.1 2001/09/08 22:03:49 adawit Exp $ ++// $Id: kcookieserver.h,v 1.24 2003/06/09 10:56:42 waba Exp $ + + #ifndef KCOOKIESERVER_H + #define KCOOKIESERVER_H +@@ -33,6 +33,7 @@ + class KHttpCookie; + class QTimer; + class RequestList; ++class KConfig; + + class KCookieServer : public KUniqueApplication + { +@@ -46,9 +47,11 @@ + + k_dcop: + QString findCookies(QString); ++ QString findCookies(QString, long); + QStringList findDomains(); + QStringList findCookies(QValueList<int>,QString,QString,QString,QString); + QString findDOMCookies(QString); ++ QString findDOMCookies(QString, long); + void addCookies(QString, QCString, long); + void deleteCookie(QString, QString, QString, QString); + void deleteCookiesFromDomain(QString); +@@ -62,13 +65,14 @@ + void shutdown(); + + public: +- bool cookiesPending(const QString &url); ++ bool cookiesPending(const QString &url, KHttpCookieList *cookieList=0); + void addCookies(const QString &url, const QCString &cookieHeader, + long windowId, bool useDOMFormat); +- void checkCookies(KHttpCookie *cookie, bool queue); ++ void checkCookies(KHttpCookieList *cookieList); + + public slots: + void slotSave(); ++ void slotDeleteSessionCookies(long); + + protected: + KCookieJar *mCookieJar; +@@ -82,6 +86,7 @@ + bool cookieMatches(KHttpCookie*, QString, QString, QString, QString); + void putCookie(QStringList&, KHttpCookie*, const QValueList<int>&); + void saveCookieJar(); ++ bool mBigScreen : 1; + }; + + #endif +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiewin.cpp~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiewin.cpp +@@ -1,8 +1,8 @@ + /* + This file is part of KDE + +- Copyright (C) 2000 Waldo Bastian <bastian@kde.org> +- Copyright (C) 2000-2001 Dawit Alemayehu <adawit@kde.org> ++ Copyright (C) 2000- Waldo Bastian <bastian@kde.org> ++ Copyright (C) 2000- Dawit Alemayehu <adawit@kde.org> + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal +@@ -24,7 +24,7 @@ + //---------------------------------------------------------------------------- + // + // KDE File Manager -- HTTP Cookie Dialogs +-// $Id: kcookiewin.cpp,v 1.26 2001/05/13 23:36:48 adawit Exp $ ++// $Id: kcookiewin.cpp,v 1.55 2004/07/07 15:18:43 waba Exp $ + + // The purpose of the QT_NO_TOOLTIP and QT_NO_WHATSTHIS ifdefs is because + // this file is also used in Konqueror/Embedded. One of the aims of +@@ -54,66 +54,77 @@ + #include <qpushbutton.h> + #include <qradiobutton.h> + #include <qvbuttongroup.h> ++#include <qscrollview.h> ++ ++#ifndef QT_NO_TOOLTIP ++#include <qtooltip.h> ++#endif ++ ++#ifndef QT_NO_WHATSTHIS ++#include <qwhatsthis.h> ++#endif + +-#include <kapp.h> + #include <kwin.h> + #include <klocale.h> + #include <kglobal.h> + #include <kurllabel.h> ++#include <qlineedit.h> + #include <kiconloader.h> + ++#ifndef Q_WS_QWS //FIXME(E): Implement for Qt Embedded ++#include <X11/Xlib.h> ++#endif ++ + #include "kcookiejar.h" + #include "kcookiewin.h" + +-KCookieWin::KCookieWin( QWidget *parent, KHttpCookie* cookie, +- int defaultButton, bool showDetails ) +- :KDialog( parent, "cookiealert", true ) ++KCookieWin::KCookieWin( QWidget *parent, KHttpCookieList cookieList, ++ int defaultButton, bool showDetails, bool modal ) ++ :KDialog( parent, "cookiealert", modal ) + { +- KWin::setState( winId(), NET::StaysOnTop ); +- KWin::setOnDesktop(winId(), KWin::currentDesktop()); ++#ifndef Q_WS_QWS //FIXME(E): Implement for Qt Embedded + setCaption( i18n("Cookie Alert") ); + setIcon( SmallIcon("cookie") ); +- ++ // all cookies in the list should have the same window at this time, so let's take the first ++ if( cookieList.first()->windowIds().count() > 0 ) ++ XSetTransientForHint( qt_xdisplay(), winId(), cookieList.first()->windowIds().first()); ++#endif + // Main widget's layout manager... + QVBoxLayout* vlayout = new QVBoxLayout( this, KDialog::marginHint(), KDialog::spacingHint() ); +- vlayout->setResizeMode( QLayout::Fixed ); + + // Cookie image and message to user + QHBox* hBox = new QHBox( this ); + hBox->setSpacing( KDialog::spacingHint() ); + QLabel* icon = new QLabel( hBox ); +- icon->setPixmap( QMessageBox::standardIcon(QMessageBox::Warning, kapp->style().guiStyle()) ); ++ icon->setPixmap( QMessageBox::standardIcon(QMessageBox::Warning, kapp->style().guiStyle() ) ); + icon->setAlignment( Qt::AlignCenter ); + icon->setFixedSize( 2*icon->sizeHint() ); + +- int count = 0; +- KHttpCookie* nextCookie = cookie; +- while ( nextCookie ) +- { +- count++; +- nextCookie = nextCookie->next(); +- } ++ int count = cookieList.count(); + + QVBox* vBox = new QVBox( hBox ); +- QString txt = (count == 1) ? i18n("You received a cookie from"): +- i18n("You received %1 cookies from").arg(count); ++ QString txt = i18n("You received a cookie from", ++ "You received %n cookies from", count); + QLabel* lbl = new QLabel( txt, vBox ); + lbl->setAlignment( Qt::AlignCenter ); ++ KHttpCookiePtr cookie = cookieList.first(); + txt = i18n("<b>%1</b>").arg( cookie->host() ); ++ if (cookie->isCrossDomain()) ++ txt += i18n(" <b>[Cross Domain!]</b>"); + lbl = new QLabel( txt, vBox ); + lbl->setAlignment( Qt::AlignCenter ); +- lbl = new QLabel( i18n("Do you want to accept or reject ?"), vBox ); ++ lbl = new QLabel( i18n("Do you want to accept or reject?"), vBox ); + lbl->setAlignment( Qt::AlignCenter ); + vlayout->addWidget( hBox, 0, Qt::AlignLeft ); + + // Cookie Details dialog... +- m_detailView = new KCookieDetail( cookie, count, this ); ++ m_detailView = new KCookieDetail( cookieList, count, this ); + vlayout->addWidget( m_detailView ); + m_showDetails = showDetails; + m_showDetails ? m_detailView->show():m_detailView->hide(); + + // Cookie policy choice... +- m_btnGrp = new QVButtonGroup( i18n("Apply choice to"), this ); ++ m_btnGrp = new QVButtonGroup( i18n("Apply Choice To"), this ); + m_btnGrp->setRadioButtonExclusive( true ); + + txt = (count == 1)? i18n("&Only this cookie") : i18n("&Only these cookies"); +@@ -128,7 +139,7 @@ + #ifndef QT_NO_WHATSTHIS + QWhatsThis::add( rb, i18n("Select this option to accept/reject all cookies from " + "this site. Choosing this option will add a new policy for " +- "the site this cookie originated from. This policy will be " ++ "the site this cookie originated from. This policy will be " + "permanent until you manually change it from the Control Center " + "<em>(see WebBrowsing/Cookies in the Control Center)</em>.") ); + #endif +@@ -146,35 +157,42 @@ + if ( defaultButton > -1 && defaultButton < 3 ) + m_btnGrp->setButton( defaultButton ); + else +- m_btnGrp->setButton( 0 ); ++ m_btnGrp->setButton( 1 ); + + // Accept/Reject buttons ++ QWidget* receiver = parent ? parent : this; + QWidget* bbox = new QWidget( this ); + QBoxLayout* bbLay = new QHBoxLayout( bbox ); + bbLay->setSpacing( KDialog::spacingHint() ); + QPushButton* btn = new QPushButton( i18n("&Accept"), bbox ); + btn->setDefault( true ); +- connect( btn, SIGNAL(clicked()), SLOT(accept()) ); ++ btn->setFocus(); ++ connect( btn, SIGNAL(clicked()), receiver, SLOT(accept()) ); + bbLay->addWidget( btn ); + btn = new QPushButton( i18n("&Reject"), bbox ); +- connect( btn, SIGNAL(clicked()), SLOT(reject()) ); ++ connect( btn, SIGNAL(clicked()), receiver, SLOT(reject()) ); + bbLay->addWidget( btn ); +- bbLay->addStretch( 1 ); +- m_button = new QPushButton( bbox ); +- m_button->setText( m_showDetails ? i18n("&Details <<"):i18n("&Details >>") ); +- connect( m_button, SIGNAL(clicked()), SLOT(slotCookieDetails()) ); +- bbLay->addWidget( m_button ); ++ bbLay->addStretch( 1 ); + #ifndef QT_NO_ACCEL + QAccel* a = new QAccel( this ); + a->connectItem( a->insertItem(Qt::Key_Escape), btn, SLOT(animateClick()) ); + #endif +- + ++ m_button = new QPushButton( bbox ); ++ m_button->setText( m_showDetails ? i18n("&Details <<"):i18n("&Details >>") ); ++ connect( m_button, SIGNAL(clicked()), SLOT(slotCookieDetails()) ); ++ bbLay->addWidget( m_button ); + #ifndef QT_NO_WHATSTHIS +- QWhatsThis::add( btn, i18n("See or modify the cookie information") ); ++ QWhatsThis::add( m_button, i18n("See or modify the cookie information") ); + #endif ++ ++ + vlayout->addWidget( bbox ); +- setFixedSize( sizeHint() ); ++ ++ if ( !parent ) { ++ vlayout->setResizeMode( QLayout::Fixed ); ++ setFixedSize( sizeHint() ); ++ } + } + + KCookieWin::~KCookieWin() +@@ -201,13 +219,16 @@ + } + } + +-KCookieAdvice KCookieWin::advice( KCookieJar *cookiejar, KHttpCookie* cookie ) ++KCookieAdvice KCookieWin::advice( int result, KCookieJar *cookiejar, KHttpCookie* cookie ) + { +- int result = exec(); ++ cookiejar->setShowCookieDetails ( m_showDetails ); ++ + KCookieAdvice advice = (result==QDialog::Accepted) ? KCookieAccept:KCookieReject; +- cookiejar->defaultRadioButton = m_btnGrp->id( m_btnGrp->selected() ); +- cookiejar->showCookieDetails = m_showDetails; +- switch ( cookiejar->defaultRadioButton ) ++ ++ int preferredPolicy = m_btnGrp->id( m_btnGrp->selected() ); ++ cookiejar->setPreferredDefaultPolicy( preferredPolicy ); ++ ++ switch ( preferredPolicy ) + { + case 2: + cookiejar->setGlobalAdvice( advice ); +@@ -222,11 +243,11 @@ + return advice; + } + +-KCookieDetail::KCookieDetail( KHttpCookie* cookie, int cookieCount, ++KCookieDetail::KCookieDetail( KHttpCookieList cookieList, int cookieCount, + QWidget* parent, const char* name ) + :QGroupBox( parent, name ) + { +- setTitle( i18n("Cookie details") ); ++ setTitle( i18n("Cookie Details") ); + QGridLayout* grid = new QGridLayout( this, 9, 2, + KDialog::spacingHint(), + KDialog::marginHint() ); +@@ -237,8 +258,7 @@ + grid->addWidget( label, 1, 0 ); + m_name = new QLineEdit( this ); + m_name->setReadOnly( true ); +- m_name->setText( cookie->name() ); +- m_name->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_name->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_name, 1 ,1 ); + + //Add the value +@@ -246,46 +266,35 @@ + grid->addWidget( label, 2, 0 ); + m_value = new QLineEdit( this ); + m_value->setReadOnly( true ); +- m_value->setText( cookie->value() ); +- m_value->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_value->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_value, 2, 1); + + label = new QLabel( i18n("Expires:"), this ); + grid->addWidget( label, 3, 0 ); + m_expires = new QLineEdit( this ); + m_expires->setReadOnly( true ); +- QDateTime cookiedate; +- cookiedate.setTime_t( cookie->expireDate() ); +- if ( cookie->expireDate() ) +- m_expires->setText( KGlobal::locale()->formatDateTime(cookiedate) ); +- else +- m_expires->setText( i18n("Not specified") ); +- m_expires->setMaximumWidth(fontMetrics().width('W') * 25 ); ++ m_expires->setMaximumWidth(fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_expires, 3, 1); + + label = new QLabel( i18n("Path:"), this ); + grid->addWidget( label, 4, 0 ); + m_path = new QLineEdit( this ); + m_path->setReadOnly( true ); +- m_path->setText( cookie->path() ); +- m_path->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_path->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_path, 4, 1); + + label = new QLabel( i18n("Domain:"), this ); + grid->addWidget( label, 5, 0 ); + m_domain = new QLineEdit( this ); + m_domain->setReadOnly( true ); +- QString val = cookie->domain(); +- m_domain->setText( val.isEmpty()?i18n("Not specified"):val ); +- m_domain->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_domain->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_domain, 5, 1); + +- label = new QLabel( i18n("Is Secure:"), this ); ++ label = new QLabel( i18n("Exposure:"), this ); + grid->addWidget( label, 6, 0 ); + m_secure = new QLineEdit( this ); + m_secure->setReadOnly( true ); +- m_secure->setText( cookie->isSecure() ? i18n("True"):i18n("False") ); +- m_secure->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_secure->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_secure, 6, 1 ); + + if ( cookieCount > 1 ) +@@ -298,8 +307,9 @@ + QToolTip::add( btnNext, i18n("Show details of the next cookie") ); + #endif + } +- m_cookie = cookie; +- m_cookie_orig = cookie; ++ m_cookieList = cookieList; ++ m_cookie = 0; ++ slotNextCookie(); + } + + KCookieDetail::~KCookieDetail() +@@ -308,9 +318,19 @@ + + void KCookieDetail::slotNextCookie() + { +- m_cookie = m_cookie->next(); +- if ( !m_cookie ) +- m_cookie = m_cookie_orig; ++ KHttpCookiePtr cookie = m_cookieList.first(); ++ if (m_cookie) while(cookie) ++ { ++ if (cookie == m_cookie) ++ { ++ cookie = m_cookieList.next(); ++ break; ++ } ++ cookie = m_cookieList.next(); ++ } ++ m_cookie = cookie; ++ if (!m_cookie) ++ m_cookie = m_cookieList.first(); + + if ( m_cookie ) + { +@@ -326,9 +346,52 @@ + if ( m_cookie->expireDate() ) + m_expires->setText( KGlobal::locale()->formatDateTime(cookiedate) ); + else +- m_expires->setText( i18n("Not specified") ); +- m_secure->setText( m_cookie->isSecure() ? i18n("True"):i18n("False") ); ++ m_expires->setText( i18n("End of Session") ); ++ QString sec; ++ if (m_cookie->isSecure()) ++ { ++ if (m_cookie->isHttpOnly()) ++ sec = i18n("Secure servers only"); ++ else ++ sec = i18n("Secure servers, page scripts"); ++ } ++ else ++ { ++ if (m_cookie->isHttpOnly()) ++ sec = i18n("Servers"); ++ else ++ sec = i18n("Servers, page scripts"); ++ } ++ m_secure->setText( sec ); + } + } + ++ ++//////////// ++/// The Adapter ++/// ++/////////// ++KScrolledCookieWin::KScrolledCookieWin( QWidget *parent, KHttpCookieList cookieList, ++ int defaultButton, bool showDetails ) ++ : KDialog( parent, "scrolled_cookiealert", true ) ++{ ++ setCaption( i18n("Cookie Alert") ); ++ QVBoxLayout *layout = new QVBoxLayout( this ); ++ QScrollView *view = new QScrollView( this, "cookie_view" ); ++ m_cookieWin = new KCookieWin( this, cookieList, defaultButton, ++ showDetails, false ); ++ ++ view->setResizePolicy( QScrollView::AutoOneFit ); ++ view->setFrameShape( QFrame::NoFrame ); ++ view->addChild( m_cookieWin ); ++ ++ layout->addWidget( view ); ++} ++ ++KCookieWin* KScrolledCookieWin::cookieWindow()const ++{ ++ return m_cookieWin; ++} ++ ++ + #include "kcookiewin.moc" +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiewin.h~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiewin.h +@@ -1,8 +1,8 @@ + /* + This file is part of the KDE File Manager + +- Copyright (C) 1998-2000 Waldo Bastian (bastian@kde.org) +- Copyright (C) 2000 Dawit Alemayehu (adawit@kde.org) ++ Copyright (C) 1998- Waldo Bastian (bastian@kde.org) ++ Copyright (C) 2000- Dawit Alemayehu (adawit@kde.org) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License +@@ -22,7 +22,7 @@ + //---------------------------------------------------------------------------- + // + // KDE File Manager -- HTTP Cookie Dialogs +-// $Id: kcookiewin.h,v 1.9 2001/04/26 23:45:12 waba Exp $ ++// $Id: kcookiewin.h,v 1.12 2002/05/20 05:35:37 adawit Exp $ + + #ifndef _KCOOKIEWIN_H_ + #define _KCOOKIEWIN_H_ +@@ -42,7 +42,7 @@ + Q_OBJECT + + public : +- KCookieDetail( KHttpCookie* cookie, int cookieCount, QWidget *parent=0, ++ KCookieDetail( KHttpCookieList cookieList, int cookieCount, QWidget *parent=0, + const char *name=0 ); + ~KCookieDetail(); + +@@ -54,8 +54,8 @@ + QLineEdit* m_path; + QLineEdit* m_secure; + +- KHttpCookie* m_cookie; +- KHttpCookie* m_cookie_orig; ++ KHttpCookieList m_cookieList; ++ KHttpCookiePtr m_cookie; + + private slots: + void slotNextCookie(); +@@ -66,11 +66,11 @@ + Q_OBJECT + + public : +- KCookieWin( QWidget *parent, KHttpCookie* cookie, int defaultButton=0, +- bool showDetails=false ); ++ KCookieWin( QWidget *parent, KHttpCookieList cookieList, int defaultButton=0, ++ bool showDetails=false, bool modal = true ); + ~KCookieWin(); + +- KCookieAdvice advice( KCookieJar *cookiejar, KHttpCookie* cookie ); ++ KCookieAdvice advice( int result, KCookieJar *cookiejar, KHttpCookie* cookie ); + + private : + QPushButton* m_button; +@@ -81,4 +81,21 @@ + private slots: + void slotCookieDetails(); + }; ++ ++/** ++ * A small Scrolled Adapter for KCookieWin ++ * to be used on big screen ++ */ ++class KScrolledCookieWin : public KDialog ++{ ++ Q_OBJECT ++ ++public: ++ KScrolledCookieWin( QWidget *parent, KHttpCookieList cookieList, int defaultButton=0, ++ bool showDetails=false ); ++ KCookieWin* cookieWindow()const; ++ ++private: ++ KCookieWin *m_cookieWin; ++}; + #endif +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver_skel.cpp~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver_skel.cpp +@@ -6,18 +6,20 @@ + ** + *****************************************************************************/ + +-#include "./kcookieserver.h" ++#include "kcookieserver.h" + + #include <kdatastream.h> + #include <qasciidict.h> + + +-static const int KCookieServer_fhash = 17; +-static const char* const KCookieServer_ftable[16][3] = { ++static const int KCookieServer_fhash = 19; ++static const char* const KCookieServer_ftable[18][3] = { + { "QString", "findCookies(QString)", "findCookies(QString)" }, ++ { "QString", "findCookies(QString,long int)", "findCookies(QString,long int)" }, + { "QStringList", "findDomains()", "findDomains()" }, + { "QStringList", "findCookies(QValueList<int>,QString,QString,QString,QString)", "findCookies(QValueList<int>,QString,QString,QString,QString)" }, + { "QString", "findDOMCookies(QString)", "findDOMCookies(QString)" }, ++ { "QString", "findDOMCookies(QString,long int)", "findDOMCookies(QString,long int)" }, + { "void", "addCookies(QString,QCString,long int)", "addCookies(QString,QCString,long int)" }, + { "void", "deleteCookie(QString,QString,QString,QString)", "deleteCookie(QString,QString,QString,QString)" }, + { "void", "deleteCookiesFromDomain(QString)", "deleteCookiesFromDomain(QString)" }, +@@ -50,12 +52,22 @@ + QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << findCookies(arg0 ); + } break; +- case 1: { // QStringList findDomains() ++ case 1: { // QString findCookies(QString,long int) ++ QString arg0; ++ long int arg1; ++ QDataStream arg( data, IO_ReadOnly ); ++ arg >> arg0; ++ arg >> arg1; + replyType = KCookieServer_ftable[1][0]; + QDataStream _replyStream( replyData, IO_WriteOnly ); ++ _replyStream << findCookies(arg0, arg1 ); ++ } break; ++ case 2: { // QStringList findDomains() ++ replyType = KCookieServer_ftable[2][0]; ++ QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << findDomains( ); + } break; +- case 2: { // QStringList findCookies(QValueList<int>,QString,QString,QString,QString) ++ case 3: { // QStringList findCookies(QValueList<int>,QString,QString,QString,QString) + QValueList<int> arg0; + QString arg1; + QString arg2; +@@ -67,19 +79,29 @@ + arg >> arg2; + arg >> arg3; + arg >> arg4; +- replyType = KCookieServer_ftable[2][0]; ++ replyType = KCookieServer_ftable[3][0]; + QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << findCookies(arg0, arg1, arg2, arg3, arg4 ); + } break; +- case 3: { // QString findDOMCookies(QString) ++ case 4: { // QString findDOMCookies(QString) + QString arg0; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; +- replyType = KCookieServer_ftable[3][0]; ++ replyType = KCookieServer_ftable[4][0]; + QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << findDOMCookies(arg0 ); + } break; +- case 4: { // void addCookies(QString,QCString,long int) ++ case 5: { // QString findDOMCookies(QString,long int) ++ QString arg0; ++ long int arg1; ++ QDataStream arg( data, IO_ReadOnly ); ++ arg >> arg0; ++ arg >> arg1; ++ replyType = KCookieServer_ftable[5][0]; ++ QDataStream _replyStream( replyData, IO_WriteOnly ); ++ _replyStream << findDOMCookies(arg0, arg1 ); ++ } break; ++ case 6: { // void addCookies(QString,QCString,long int) + QString arg0; + QCString arg1; + long int arg2; +@@ -87,10 +109,10 @@ + arg >> arg0; + arg >> arg1; + arg >> arg2; +- replyType = KCookieServer_ftable[4][0]; ++ replyType = KCookieServer_ftable[6][0]; + addCookies(arg0, arg1, arg2 ); + } break; +- case 5: { // void deleteCookie(QString,QString,QString,QString) ++ case 7: { // void deleteCookie(QString,QString,QString,QString) + QString arg0; + QString arg1; + QString arg2; +@@ -100,37 +122,37 @@ + arg >> arg1; + arg >> arg2; + arg >> arg3; +- replyType = KCookieServer_ftable[5][0]; ++ replyType = KCookieServer_ftable[7][0]; + deleteCookie(arg0, arg1, arg2, arg3 ); + } break; +- case 6: { // void deleteCookiesFromDomain(QString) ++ case 8: { // void deleteCookiesFromDomain(QString) + QString arg0; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; +- replyType = KCookieServer_ftable[6][0]; ++ replyType = KCookieServer_ftable[8][0]; + deleteCookiesFromDomain(arg0 ); + } break; +- case 7: { // void deleteSessionCookies(long int) ++ case 9: { // void deleteSessionCookies(long int) + long int arg0; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; +- replyType = KCookieServer_ftable[7][0]; ++ replyType = KCookieServer_ftable[9][0]; + deleteSessionCookies(arg0 ); + } break; +- case 8: { // void deleteSessionCookiesFor(QString,long int) ++ case 10: { // void deleteSessionCookiesFor(QString,long int) + QString arg0; + long int arg1; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; + arg >> arg1; +- replyType = KCookieServer_ftable[8][0]; ++ replyType = KCookieServer_ftable[10][0]; + deleteSessionCookiesFor(arg0, arg1 ); + } break; +- case 9: { // void deleteAllCookies() +- replyType = KCookieServer_ftable[9][0]; ++ case 11: { // void deleteAllCookies() ++ replyType = KCookieServer_ftable[11][0]; + deleteAllCookies( ); + } break; +- case 10: { // void addDOMCookies(QString,QCString,long int) ++ case 12: { // void addDOMCookies(QString,QCString,long int) + QString arg0; + QCString arg1; + long int arg2; +@@ -138,38 +160,38 @@ + arg >> arg0; + arg >> arg1; + arg >> arg2; +- replyType = KCookieServer_ftable[10][0]; ++ replyType = KCookieServer_ftable[12][0]; + addDOMCookies(arg0, arg1, arg2 ); + } break; +- case 11: { // void setDomainAdvice(QString,QString) ++ case 13: { // void setDomainAdvice(QString,QString) + QString arg0; + QString arg1; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; + arg >> arg1; +- replyType = KCookieServer_ftable[11][0]; ++ replyType = KCookieServer_ftable[13][0]; + setDomainAdvice(arg0, arg1 ); + } break; +- case 12: { // QString getDomainAdvice(QString) ++ case 14: { // QString getDomainAdvice(QString) + QString arg0; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; +- replyType = KCookieServer_ftable[12][0]; ++ replyType = KCookieServer_ftable[14][0]; + QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << getDomainAdvice(arg0 ); + } break; +- case 13: { // void reloadPolicy() +- replyType = KCookieServer_ftable[13][0]; ++ case 15: { // void reloadPolicy() ++ replyType = KCookieServer_ftable[15][0]; + reloadPolicy( ); + } break; +- case 14: { // void shutdown() +- replyType = KCookieServer_ftable[14][0]; ++ case 16: { // void shutdown() ++ replyType = KCookieServer_ftable[16][0]; + shutdown( ); + } break; + default: + return KUniqueApplication::process( fun, data, replyType, replyData ); + } +- return TRUE; ++ return true; + } + + QCStringList KCookieServer::interfaces() +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/http.cc~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/http.cc +@@ -200,9 +200,9 @@ + kdDebug(7103) << "(" << getpid() << ") Proxy URL is now: " << m_proxyURL.url() << endl; + } + +- m_bUseCookiejar = config()->readBoolEntry("Cookies"); +- m_bUseCache = config()->readBoolEntry("UseCache"); +- m_strCacheDir = config()->readEntry("CacheDir"); ++ m_bUseCookiejar = config()->readBoolEntry("Cookies", true); ++ m_bUseCache = config()->readBoolEntry("UseCache", true); ++ m_strCacheDir = config()->readEntry("CacheDir", "/tmp/"); + m_maxCacheAge = config()->readNumEntry("MaxCacheAge"); + m_request.window = config()->readEntry("window-id"); + diff --git a/packages/konqueror/konqueror-embedded-20030705/kcookiejar-merge.patch.patch b/packages/konqueror/konqueror-embedded-20030705/kcookiejar-merge.patch.patch index e69de29bb2..5ffdd1bba2 100644 --- a/packages/konqueror/konqueror-embedded-20030705/kcookiejar-merge.patch.patch +++ b/packages/konqueror/konqueror-embedded-20030705/kcookiejar-merge.patch.patch @@ -0,0 +1,2891 @@ + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiejar.cpp~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiejar.cpp +@@ -1,8 +1,8 @@ + /* This file is part of the KDE File Manager + +- Copyright (C) 1998,1999,2000,2001 Waldo Bastian (bastian@kde.org) +- Copyright (C) 2000,2001 Dawit Alemayehu (adawit@kde.org) +- ++ Copyright (C) 1998-2000 Waldo Bastian (bastian@kde.org) ++ Copyright (C) 2000,2001 Dawit Alemayehu (adawit@kde.org) ++ + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights +@@ -22,17 +22,18 @@ + */ + //---------------------------------------------------------------------------- + // +-// KDE HTTP Cookie Manager +-// $Id: kcookiejar.cpp,v 1.58.2.5 2001/11/04 04:21:39 adawit Exp $ ++// KDE File Manager -- HTTP Cookies ++// $Id: kcookiejar.cpp,v 1.117 2004/07/20 15:29:24 waba Exp $ + + // + // The cookie protocol is a mess. RFC2109 is a joke since nobody seems to +-// use it. Apart from that it is badly written. We try to implement Netscape +-// Cookies and try to behave according to RFC2109 as much as we can. ++// use it. Apart from that it is badly written. ++// We try to implement Netscape Cookies and try to behave us according to ++// RFC2109 as much as we can. ++// ++// We assume cookies do not contain any spaces (Netscape spec.) ++// According to RFC2109 this is allowed though. + // +-// We assume cookies do not contain any spaces (Netscape spec.) According to +-// RFC2109 this is allowed though. +- + + #include <config.h> + #include <sys/types.h> +@@ -44,12 +45,23 @@ + #include <unistd.h> + #include <stdio.h> + #include <string.h> ++ ++#ifdef USE_SOLARIS ++#include <strings.h> ++#endif ++ + #include <stdlib.h> + ++//#include <netinet/in.h> ++//#include <arpa/inet.h> ++ + #include <qstring.h> + #include <qstrlist.h> + #include <qlist.h> + #include <qdict.h> ++#include <qfile.h> ++#include <qdir.h> ++#include <qregexp.h> + + #include <kurl.h> + #include <krfcdate.h> +@@ -61,6 +73,13 @@ + + #define READ_BUFFER_SIZE 8192 + ++// Note with respect to QString::fromLatin1( ) ++// Cookies are stored as 8 bit data and passed to kio_http as ++// latin1 regardless of their actual encoding. ++ ++// L1 is used to indicate latin1 constants ++#define L1(x) QString::fromLatin1(x) ++ + template class QList<KHttpCookie>; + template class QDict<KHttpCookieList>; + +@@ -68,10 +87,10 @@ + { + switch( _advice ) + { +- case KCookieAccept: return "Accept"; +- case KCookieReject: return "Reject"; +- case KCookieAsk: return "Ask"; +- default: return "Dunno"; ++ case KCookieAccept: return L1("Accept"); ++ case KCookieReject: return L1("Reject"); ++ case KCookieAsk: return L1("Ask"); ++ default: return L1("Dunno"); + } + } + +@@ -80,7 +99,7 @@ + if (_str.isEmpty()) + return KCookieDunno; + +- QString advice = _str.lower(); ++ QCString advice = _str.lower().latin1(); + + if (advice == "accept") + return KCookieAccept; +@@ -105,17 +124,20 @@ + const QString &_value, + time_t _expireDate, + int _protocolVersion, +- bool _secure) : ++ bool _secure, ++ bool _httpOnly, ++ bool _explicitPath) : + mHost(_host), + mDomain(_domain), +- mPath(_path), ++ mPath(_path.isEmpty() ? QString::null : _path), + mName(_name), + mValue(_value), + mExpireDate(_expireDate), + mProtocolVersion(_protocolVersion), +- mSecure(_secure) ++ mSecure(_secure), ++ mHttpOnly(_httpOnly), ++ mExplicitPath(_explicitPath) + { +- nextCookie = 0; + } + + // +@@ -135,16 +157,17 @@ + + if (useDOMFormat || (mProtocolVersion == 0)) + { +- result = mName + "=" + mValue; ++ if ( !mName.isEmpty() ) ++ result = mName + '='; ++ result += mValue; + } + else + { +- result.sprintf("$Version=\"%d\"; ", mProtocolVersion); +- result += mName + "=\"" + mValue + "\""; +- if (!mPath.isEmpty()) +- result += "; $Path=\""+ mPath + "\""; ++ result = mName + '=' + mValue; ++ if (mExplicitPath) ++ result += L1("; $Path=\"") + mPath + L1("\""); + if (!mDomain.isEmpty()) +- result += "; $Domain=\""+ mDomain + "\""; ++ result += L1("; $Domain=\"") + mDomain + L1("\""); + } + return result; + } +@@ -157,8 +180,7 @@ + // Cookie domain match check + if (mDomain.isEmpty()) + { +- // No domain set, check hostname. +- if (fqdn != mHost) ++ if (fqdn != mHost) + return false; + } + else if (!domains.contains(mDomain)) +@@ -167,17 +189,30 @@ + return false; + + // Maybe the domain needs an extra dot. +- QString domain = "." + mDomain; ++ QString domain = '.' + mDomain; + if ( !domains.contains( domain ) ) + if ( fqdn != mDomain ) + return false; + } + + // Cookie path match check +- if( !path.isEmpty() && !path.startsWith(mPath) ) +- return false; // Path of URL does not start with cookie-path ++ if (mPath.isEmpty()) ++ return true; + +- return true; ++ // According to the netscape spec both http://www.acme.com/foobar, ++ // http://www.acme.com/foo.bar and http://www.acme.com/foo/bar ++ // match http://www.acme.com/foo. ++ // We only match http://www.acme.com/foo/bar ++ ++ if( path.startsWith(mPath) && ++ ( ++ (path.length() == mPath.length() ) || // Paths are exact match ++ (path[mPath.length()-1] == '/') || // mPath ended with a slash ++ (path[mPath.length()] == '/') // A slash follows. ++ )) ++ return true; // Path of URL starts with cookie-path ++ ++ return false; + } + + // KHttpCookieList +@@ -188,9 +223,9 @@ + int pathLen1 = ((KHttpCookie *)item1)->path().length(); + int pathLen2 = ((KHttpCookie *)item2)->path().length(); + if (pathLen1 > pathLen2) +- return 1; +- if (pathLen1 < pathLen2) + return -1; ++ if (pathLen1 < pathLen2) ++ return 1; + return 0; + } + +@@ -205,10 +240,18 @@ + // + KCookieJar::KCookieJar() + { +- cookieDomains.setAutoDelete( true ); +- globalAdvice = KCookieDunno; +- configChanged = false; +- cookiesChanged = false; ++ m_cookieDomains.setAutoDelete( true ); ++ m_globalAdvice = KCookieDunno; ++ m_configChanged = false; ++ m_cookiesChanged = false; ++ ++ QString twoLevelTLD="name,ai,au,bd,bh,ck,eg,et,fk,il,in,kh,kr,mk,mt,na,np,nz,pg,pk,qa,sa,sb,sg,sv,ua,ug,uk,uy,vn,za,zw"; ++ QStringList countries = QStringList::split(',', twoLevelTLD); ++ for(QStringList::ConstIterator it = countries.begin(); ++ it != countries.end(); ++it) ++ { ++ m_twoLevelTLD.replace(*it, (int *) 1); ++ } + } + + // +@@ -221,89 +264,184 @@ + // Not much to do here + } + ++static void removeDuplicateFromList(KHttpCookieList *list, KHttpCookie *cookiePtr, bool nameMatchOnly=false, bool updateWindowId=false) ++{ ++ QString domain1 = cookiePtr->domain(); ++ if (domain1.isEmpty()) ++ domain1 = cookiePtr->host(); ++ ++ for ( KHttpCookiePtr cookie=list->first(); cookie != 0; ) ++ { ++ QString domain2 = cookie->domain(); ++ if (domain2.isEmpty()) ++ domain2 = cookie->host(); ++ ++ if ( ++ (cookiePtr->name() == cookie->name()) && ++ ( ++ nameMatchOnly || ++ ( (domain1 == domain2) && (cookiePtr->path() == cookie->path()) ) ++ ) ++ ) ++ { ++ if (updateWindowId) ++ { ++ for(QValueList<long>::ConstIterator it = cookie->windowIds().begin(); ++ it != cookie->windowIds().end(); ++it) ++ { ++ long windowId = *it; ++ if (windowId && (cookiePtr->windowIds().find(windowId) == cookiePtr->windowIds().end())) ++ { ++ cookiePtr->windowIds().append(windowId); ++ } ++ } ++ } ++ KHttpCookiePtr old_cookie = cookie; ++ cookie = list->next(); ++ list->removeRef( old_cookie ); ++ break; ++ } ++ else ++ { ++ cookie = list->next(); ++ } ++ } ++} ++ ++ + // + // Looks for cookies in the cookie jar which are appropriate for _url. + // Returned is a string containing all appropriate cookies in a format + // which can be added to a HTTP-header without any additional processing. + // +-QString KCookieJar::findCookies(const QString &_url, bool useDOMFormat) ++QString KCookieJar::findCookies(const QString &_url, bool useDOMFormat, long windowId, KHttpCookieList *pendingCookies) + { + QString cookieStr; + QStringList domains; + QString fqdn; + QString path; + KHttpCookiePtr cookie; +- int protVersion = 1; +- int cookieCount = 0; ++ KCookieAdvice advice = m_globalAdvice; + + if (!parseURL(_url, fqdn, path)) +- { + return cookieStr; +- } ++ ++ bool secureRequest = (_url.find( L1("https://"), 0, false) == 0 || ++ _url.find( L1("webdavs://"), 0, false) == 0); + + extractDomains(fqdn, domains); +- bool secureRequest = (_url.find( "https://", 0, false) == 0); ++ ++ KHttpCookieList allCookies; ++ + for(QStringList::ConstIterator it = domains.begin(); +- it != domains.end(); ++ true; + ++it) + { +- KHttpCookieList *cookieList = cookieDomains[(*it)]; ++ KHttpCookieList *cookieList; ++ if (it == domains.end()) ++ { ++ cookieList = pendingCookies; // Add pending cookies ++ pendingCookies = 0; ++ if (!cookieList) ++ break; ++ } ++ else ++ { ++ QString key = (*it).isNull() ? L1("") : (*it); ++ cookieList = m_cookieDomains[key]; ++ if (!cookieList) ++ continue; // No cookies for this domain ++ } + +- if (!cookieList) +- continue; // No cookies for this domain ++ if (cookieList->getAdvice() != KCookieDunno) ++ advice = cookieList->getAdvice(); ++ ++ // Do not send cookies for this domain if policy is set to reject ++ // and we are not setup to automatically accept all cookies as ++ // session cookies... ++ if (advice == KCookieReject && ++ !(m_ignoreCookieExpirationDate && m_autoAcceptSessionCookies)) ++ { ++ if (it == domains.end()) ++ break; // Finished. ++ continue; ++ } + + for ( cookie=cookieList->first(); cookie != 0; cookie=cookieList->next() ) + { +- if (!cookie->match(fqdn, domains, path) && cookie->domain().isEmpty()) +- { +- // The following code is added because RFC 2109 is completely +- // ambigious when it comes what needs to be done when cookies +- // with empty "domain=" fields are present! The following code +- // makes such cookies available to all the domains/hosts under +- // the TLD of the cookie in question! +- QStringList cookieDomainList; +- extractDomains( cookie->host(), cookieDomainList ); +- +- int fqdnCount = domains.count(); +- int cookieDomainCount = cookieDomainList.count(); +- +- if ( domains[fqdnCount-2] != cookieDomainList[cookieDomainCount-2] && +- domains[fqdnCount-1] != cookieDomainList[cookieDomainCount-1] ) +- continue; +- } ++ if (!cookie->match(fqdn, domains, path)) ++ continue; + + if( cookie->isSecure() && !secureRequest ) + continue; + +- // Use first cookie to determine protocol version +- if (cookieCount == 0) ++ if( cookie->isHttpOnly() && useDOMFormat ) ++ continue; ++ ++ // Do not send expired cookies. ++ if ( cookie->isExpired (time(0)) ) + { +- protVersion = cookie->protocolVersion(); ++ // Note there is no need to actually delete the cookie here ++ // since the cookieserver will invoke ::saveCookieJar because ++ // of the state change below. This will then do the job of ++ // deleting the cookie for us. ++ m_cookiesChanged = true; ++ continue; + } +- if (useDOMFormat) ++ ++ if (windowId && (cookie->windowIds().find(windowId) == cookie->windowIds().end())) + { +- if (cookieCount > 0) +- cookieStr += "; "; +- cookieStr += cookie->cookieStr(true); ++ cookie->windowIds().append(windowId); + } +- else if (protVersion == 0) ++ ++ if (it == domains.end()) // Only needed when processing pending cookies ++ removeDuplicateFromList(&allCookies, cookie); ++ ++ allCookies.append(cookie); ++ } ++ if (it == domains.end()) ++ break; // Finished. ++ } ++ ++ ++ int cookieCount = 0; ++ ++ int protVersion=0; ++ for ( cookie=allCookies.first(); cookie != 0; cookie=allCookies.next() ) ++ { ++ if (cookie->protocolVersion() > protVersion) ++ protVersion = cookie->protocolVersion(); ++ } ++ ++ for ( cookie=allCookies.first(); cookie != 0; cookie=allCookies.next() ) ++ { ++ if (useDOMFormat) ++ { ++ if (cookieCount > 0) ++ cookieStr += L1("; "); ++ cookieStr += cookie->cookieStr(true); ++ } ++ else ++ { ++ if (cookieCount == 0) + { +- if (cookieCount == 0) +- cookieStr += "Cookie: "; +- else +- cookieStr += "; "; +- cookieStr += cookie->cookieStr(false); ++ cookieStr += L1("Cookie: "); ++ if (protVersion > 0) ++ { ++ QString version; ++ version.sprintf("$Version=%d; ", protVersion); // Without quotes ++ cookieStr += version; ++ } + } + else + { +- if (cookieCount > 0) +- cookieStr += "\r\n"; +- cookieStr += "Cookie: "; +- cookieStr += cookie->cookieStr(false); ++ cookieStr += L1("; "); + } +- cookieCount++; ++ cookieStr += cookie->cookieStr(false); + } ++ cookieCount++; + } ++ + return cookieStr; + } + +@@ -323,17 +461,17 @@ + bool keepQuotes=false) + { + const char *s = header; +- + // Parse 'my_name' part + for(; (*s != '='); s++) + { + if ((*s=='\0') || (*s==';') || (*s=='\n')) + { +- // End of Name +- Value = ""; +- Name = header; +- Name.truncate( s - header ); +- Name = Name.stripWhiteSpace(); ++ // No '=' sign -> use string as the value, name is empty ++ // (behavior found in Mozilla and IE) ++ Name = ""; ++ Value = QString::fromLatin1(header); ++ Value.truncate( s - header ); ++ Value = Value.stripWhiteSpace(); + return (s); + } + } +@@ -366,12 +504,12 @@ + if ((*s=='\0') || (*s=='\n')) + { + // End of Name +- Value = header; ++ Value = QString::fromLatin1(header); + Value.truncate(s - header); + return (s); + } + } +- Value = header; ++ Value = QString::fromLatin1(header); + Value.truncate( s - header ); + + // *s == '\"'; +@@ -390,7 +528,7 @@ + while ((*s != '\0') && (*s != ';') && (*s != '\n')) + s++; + // End of Name +- Value = header; ++ Value = QString::fromLatin1(header); + Value.truncate( s - header ); + Value = Value.stripWhiteSpace(); + } +@@ -398,14 +536,14 @@ + + } + +-static void stripDomain(const QString &_fqdn, QString &_domain) ++void KCookieJar::stripDomain(const QString &_fqdn, QString &_domain) + { + QStringList domains; +- KCookieJar::extractDomains(_fqdn, domains); ++ extractDomains(_fqdn, domains); + _domain = domains[0]; + } + +-static QString stripDomain( KHttpCookiePtr cookiePtr) ++QString KCookieJar::stripDomain( KHttpCookiePtr cookiePtr) + { + QString domain; // We file the cookie under this domain. + if (cookiePtr->domain().isEmpty()) +@@ -420,10 +558,18 @@ + QString &_path) + { + KURL kurl(_url); +- if (kurl.isMalformed()) ++ if (!kurl.isValid()) + return false; + + _fqdn = kurl.host().lower(); ++ if (kurl.port()) ++ { ++ if (((kurl.protocol() == L1("http")) && (kurl.port() != 80)) || ++ ((kurl.protocol() == L1("https")) && (kurl.port() != 443))) ++ { ++ _fqdn = L1("%1:%2").arg(kurl.port()).arg(_fqdn); ++ } ++ } + + // Cookie spoofing protection. Since there is no way a path separator + // or escape encoded character is allowed in the hostname according +@@ -435,19 +581,44 @@ + + _path = kurl.path(); + if (_path.isEmpty()) +- _path = "/"; ++ _path = L1("/"); ++ ++ QRegExp exp(L1("[\\\\/]\\.\\.[\\\\/]")); ++ // Weird path, cookie stealing attempt? ++ if (_path.find(exp) != -1) { ++ return false; // Deny everything!! ++ } ++ + return true; + } + + void KCookieJar::extractDomains(const QString &_fqdn, + QStringList &_domains) + { +- // Use fqdn only if the fqdn consists of numbers. +- if ((_fqdn[0] >= '0') && (_fqdn[0] <= '9')) ++ // Return numeric IPv6 addresses as is... ++ if (_fqdn[0] == '[') + { + _domains.append( _fqdn ); + return; + } ++ // Return numeric IPv4 addresses as is... ++ if ((_fqdn[0] >= '0') && (_fqdn[0] <= '9')) ++ { ++ bool allNumeric = true; ++ for(int i = _fqdn.length(); i--;) ++ { ++ if (!strchr("0123456789:.", _fqdn[i].latin1())) ++ { ++ allNumeric = false; ++ break; ++ } ++ } ++ if (allNumeric) ++ { ++ _domains.append( _fqdn ); ++ return; ++ } ++ } + + QStringList partList = QStringList::split('.', _fqdn, false); + +@@ -458,29 +629,36 @@ + { + if (partList.count() == 1) + break; // We only have a TLD left. +- if (partList.count() == 2) ++ ++ if ((partList.count() == 2) && (m_twoLevelTLD[partList[1].lower()])) ++ { ++ // This domain uses two-level TLDs in the form xxxx.yy ++ break; ++ } ++ ++ if ((partList.count() == 2) && (partList[1].length() == 2)) + { + // If this is a TLD, we should stop. (e.g. co.uk) + // We assume this is a TLD if it ends with .xx.yy or .x.yy +- if ((partList[0].length() <= 2) && +- (partList[1].length() == 2)) ++ if (partList[0].length() <= 2) + break; // This is a TLD. ++ ++ // Catch some TLDs that we miss with the previous check ++ // e.g. com.au, org.uk, mil.co ++ QCString t = partList[0].lower().utf8(); ++ if ((t == "com") || (t == "net") || (t == "org") || (t == "gov") || (t == "edu") || (t == "mil") || (t == "int")) ++ break; + } +- QString domain = partList.join("."); +- _domains.append("." + domain); ++ ++ QString domain = partList.join(L1(".")); ++ _domains.append('.' + domain); + _domains.append(domain); + partList.remove(partList.begin()); // Remove part + } + +- // Only URLs that would get in here are of type +- // "host.foo" or "host.co.fo" so simply append +- // a '.' on top to make sure they are stored under +- // the proper cookie domain. +- if (_domains.isEmpty()) +- _domains.append( "." + _fqdn ); +- + // Always add the FQDN at the end of the list for + // hostname == cookie-domainname checks! ++ _domains.append( '.' + _fqdn ); + _domains.append( _fqdn ); + } + +@@ -492,55 +670,73 @@ + // cookie_headers should be a concatenation of all lines of a HTTP-header + // which start with "Set-Cookie". The lines should be separated by '\n's. + // +-KHttpCookiePtr KCookieJar::makeCookies(const QString &_url, ++KHttpCookieList KCookieJar::makeCookies(const QString &_url, + const QCString &cookie_headers, + long windowId) + { +- KHttpCookiePtr cookieChain = 0; ++ KHttpCookieList cookieList; ++ KHttpCookieList cookieList2; + KHttpCookiePtr lastCookie = 0; + const char *cookieStr = cookie_headers.data(); + QString Name; + QString Value; + QString fqdn; + QString path; ++ bool crossDomain = false; + + if (!parseURL(_url, fqdn, path)) + { + // Error parsing _url +- return 0; ++ return KHttpCookieList(); + } ++ QString defaultPath; ++ int i = path.findRev('/'); ++ if (i > 0) ++ defaultPath = path.left(i); + + // The hard stuff :) + for(;;) + { + // check for "Set-Cookie" +- if (strncasecmp(cookieStr, "Set-Cookie:", 11) == 0) ++ if (strncmp(cookieStr, "Cross-Domain\n", 13) == 0) ++ { ++ cookieStr += 13; ++ crossDomain = true; ++ } ++ else if (strncasecmp(cookieStr, "Set-Cookie:", 11) == 0) + { + cookieStr = parseNameValue(cookieStr+11, Name, Value, true); + +- if (Name.isEmpty()) +- continue; +- + // Host = FQDN + // Default domain = "" +- // Default path = "" +- KHttpCookie *cookie = new KHttpCookie(fqdn, "", "", Name, Value); +- cookie->mWindowId = windowId; ++ // Default path according to rfc2109 ++ ++ KHttpCookie *cookie = new KHttpCookie(fqdn, L1(""), defaultPath, Name, Value); ++ if (windowId) ++ cookie->mWindowIds.append(windowId); ++ cookie->mCrossDomain = crossDomain; + + // Insert cookie in chain +- if (lastCookie) +- lastCookie->nextCookie = cookie; +- else +- cookieChain = cookie; ++ cookieList.append(cookie); + lastCookie = cookie; + } +- else if (lastCookie && (strncasecmp(cookieStr, "Set-Cookie2:", 12) == 0)) ++ else if (strncasecmp(cookieStr, "Set-Cookie2:", 12) == 0) + { +- // What the fuck is this? +- // Does anyone invent his own headers these days? +- // Read the fucking RFC guys! This header is not there! +- cookieStr +=12; +- // Continue with lastCookie ++ // Attempt to follow rfc2965 ++ cookieStr = parseNameValue(cookieStr+12, Name, Value, true); ++ ++ // Host = FQDN ++ // Default domain = "" ++ // Default path according to rfc2965 ++ ++ KHttpCookie *cookie = new KHttpCookie(fqdn, L1(""), defaultPath, Name, Value); ++ if (windowId) ++ cookie->mWindowIds.append(windowId); ++ cookie->mCrossDomain = crossDomain; ++ ++ // Insert cookie in chain ++ cookieList2.append(cookie); ++ lastCookie = cookie; + } + else + { +@@ -564,13 +760,12 @@ + // Name-Value pair follows + cookieStr = parseNameValue(cookieStr, Name, Value); + +- Name = Name.lower(); +- +- if (Name == "domain") ++ QCString cName = Name.lower().latin1(); ++ if (cName == "domain") + { + lastCookie->mDomain = Value.lower(); + } +- else if (Name == "max-age") ++ else if (cName == "max-age") + { + int max_age = Value.toInt(); + if (max_age == 0) +@@ -578,23 +773,33 @@ + else + lastCookie->mExpireDate = time(0)+max_age; + } +- else if (Name == "expires") ++ else if (cName == "expires") + { + // Parse brain-dead netscape cookie-format + lastCookie->mExpireDate = KRFCDate::parseDate(Value); + } +- else if (Name == "path") ++ else if (cName == "path") + { +- lastCookie->mPath = Value; ++ if (Value.isEmpty()) ++ lastCookie->mPath = QString::null; // Catch "" <> QString::null ++ else ++ lastCookie->mPath = KURL::decode_string(Value); ++ lastCookie->mExplicitPath = true; + } +- else if (Name == "version") ++ else if (cName == "version") + { + lastCookie->mProtocolVersion = Value.toInt(); + } +- else if (Name == "secure") ++ else if ((cName == "secure") || ++ (cName.isEmpty() && Value.lower() == L1("secure"))) + { + lastCookie->mSecure = true; + } ++ else if ((cName == "httponly") || ++ (cName.isEmpty() && Value.lower() == L1("httponly"))) ++ { ++ lastCookie->mHttpOnly = true; ++ } + } + + if (*cookieStr == '\0') +@@ -604,7 +809,14 @@ + cookieStr++; + } + +- return cookieChain; ++ // RFC2965 cookies come last so that they override netscape cookies. ++ while( !cookieList2.isEmpty() && (lastCookie = cookieList2.take(0)) ) ++ { ++ removeDuplicateFromList(&cookieList, lastCookie, true); ++ cookieList.append(lastCookie); ++ } ++ ++ return cookieList; + } + + /** +@@ -613,12 +825,12 @@ + * pairs. Any whitespace before "name" or around '=' is discarded. + * If no cookies are found, 0 is returned. + */ +-KHttpCookiePtr KCookieJar::makeDOMCookies(const QString &_url, ++KHttpCookieList KCookieJar::makeDOMCookies(const QString &_url, + const QCString &cookie_domstring, + long windowId) + { + // A lot copied from above +- KHttpCookiePtr cookieChain = 0; ++ KHttpCookieList cookieList; + KHttpCookiePtr lastCookie = 0; + + const char *cookieStr = cookie_domstring.data(); +@@ -630,7 +842,7 @@ + if (!parseURL(_url, fqdn, path)) + { + // Error parsing _url +- return 0; ++ return KHttpCookieList(); + } + + // This time it's easy +@@ -638,35 +850,25 @@ + { + cookieStr = parseNameValue(cookieStr, Name, Value); + +- if (Name.isEmpty()) { +- if (*cookieStr != '\0') +- cookieStr++; // Skip ';' or '\n' +- +- continue; +- } +- + // Host = FQDN + // Default domain = "" + // Default path = "" + KHttpCookie *cookie = new KHttpCookie(fqdn, QString::null, QString::null, + Name, Value ); +- cookie->mWindowId = windowId; +- +- // Insert cookie in chain +- if (lastCookie) +- lastCookie->nextCookie = cookie; +- else +- cookieChain = cookie; ++ if (windowId) ++ cookie->mWindowIds.append(windowId); + ++ cookieList.append(cookie); + lastCookie = cookie; + + if (*cookieStr != '\0') + cookieStr++; // Skip ';' or '\n' + } + +- return cookieChain; ++ return cookieList; + } + ++ + // + // This function hands a KHttpCookie object over to the cookie jar. + // +@@ -674,7 +876,6 @@ + // + void KCookieJar::addCookie(KHttpCookiePtr &cookiePtr) + { +- QString domain; + QStringList domains; + KHttpCookieList *cookieList = 0L; + +@@ -686,42 +887,31 @@ + (it != domains.end() && !cookieList); + ++it ) + { +- KHttpCookieList *list= cookieDomains[(*it)]; ++ QString key = (*it).isNull() ? L1("") : (*it); ++ KHttpCookieList *list= m_cookieDomains[key]; + if ( !list ) continue; + +- for ( KHttpCookiePtr cookie=list->first(); cookie != 0; ) +- { +- if ( cookiePtr->name() == cookie->name() && +- cookie->match(cookiePtr->host(),domains,cookiePtr->path()) ) +- { +- KHttpCookiePtr old_cookie = cookie; +- cookie = list->next(); +- list->removeRef( old_cookie ); +- break; +- } +- else +- { +- cookie = list->next(); +- } +- } ++ removeDuplicateFromList(list, cookiePtr, false, true); + } + +- domain = stripDomain( cookiePtr ); +- cookieList = cookieDomains[ domain ]; ++ QString domain = stripDomain( cookiePtr ); ++ QString key = domain.isNull() ? L1("") : domain; ++ cookieList = m_cookieDomains[ key ]; + if (!cookieList) + { + // Make a new cookie list + cookieList = new KHttpCookieList(); ++ cookieList->setAutoDelete(true); + + // All cookies whose domain is not already + // known to us should be added with KCookieDunno. + // KCookieDunno means that we use the global policy. + cookieList->setAdvice( KCookieDunno ); + +- cookieDomains.insert( domain, cookieList); ++ m_cookieDomains.insert( domain, cookieList); + + // Update the list of domains +- domainList.append(domain); ++ m_domainList.append(domain); + } + + // Add the cookie to the cookie list +@@ -729,7 +919,7 @@ + if (!cookiePtr->isExpired(time(0))) + { + cookieList->inSort( cookiePtr ); +- cookiesChanged = true; ++ m_cookiesChanged = true; + } + else + { +@@ -745,12 +935,20 @@ + KCookieAdvice KCookieJar::cookieAdvice(KHttpCookiePtr cookiePtr) + { + QStringList domains; ++ ++ if (m_rejectCrossDomainCookies && cookiePtr->isCrossDomain()) ++ return KCookieReject; ++ ++ if (m_autoAcceptSessionCookies && (cookiePtr->expireDate() == 0 || ++ m_ignoreCookieExpirationDate)) ++ return KCookieAccept; ++ + extractDomains(cookiePtr->host(), domains); +- bool isEmptyDomain = cookiePtr->domain().isEmpty(); + +- if (!isEmptyDomain ) ++ // If the cookie specifies a domain, check whether it is valid and ++ // correct otherwise. ++ if (!cookiePtr->domain().isEmpty()) + { +- // Cookie specifies a domain. Check whether it is valid. + bool valid = false; + + // This checks whether the cookie is valid based on +@@ -764,42 +962,34 @@ + if (!valid) + { + // Maybe the domain doesn't start with a "." +- QString domain = "."+cookiePtr->domain(); ++ QString domain = '.' + cookiePtr->domain(); + if (domains.contains(domain)) + valid = true; + } + + if (!valid) + { +- qWarning("WARNING: Host %s tries to set cookie for domain %s", +- cookiePtr->host().latin1(), cookiePtr->domain().latin1()); + cookiePtr->fixDomain(QString::null); +- isEmptyDomain = true; + } + } + +- // For empty domain use the FQDN to find a +- // matching advice for the pending cookie. +- QString domain; +- if ( isEmptyDomain ) +- domain = domains[0]; +- else +- domain = cookiePtr->domain(); ++ KCookieAdvice advice = KCookieDunno; + +- KHttpCookieList *cookieList = cookieDomains[domain]; +- KCookieAdvice advice; +- if (cookieList) +- { +- advice = cookieList->getAdvice(); +- if (advice == KCookieDunno) +- { +- advice = globalAdvice; +- } +- } +- else ++ QStringList::Iterator it = domains.fromLast(); // Start with FQDN which is last in the list. ++ while( (advice == KCookieDunno) && (it != domains.end())) + { +- advice = globalAdvice; ++ QString domain = *it; ++ // Check if a policy for the FQDN/domain is set. ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; ++ if (cookieList) ++ advice = cookieList->getAdvice(); ++ domains.remove(it); ++ it = domains.begin(); // Continue from begin of remaining list + } ++ ++ if (advice == KCookieDunno) ++ advice = m_globalAdvice; ++ + return advice; + } + +@@ -809,7 +999,7 @@ + // + KCookieAdvice KCookieJar::getDomainAdvice(const QString &_domain) + { +- KHttpCookieList *cookieList = cookieDomains[_domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[_domain]; + KCookieAdvice advice; + + if (cookieList) +@@ -831,13 +1021,13 @@ + void KCookieJar::setDomainAdvice(const QString &_domain, KCookieAdvice _advice) + { + QString domain(_domain); +- KHttpCookieList *cookieList = cookieDomains[domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; + + if (cookieList) + { +- if (cookieList->getAdvice() != _advice); ++ if (cookieList->getAdvice() != _advice) + { +- configChanged = true; ++ m_configChanged = true; + // domain is already known + cookieList->setAdvice( _advice); + } +@@ -846,8 +1036,8 @@ + (_advice == KCookieDunno)) + { + // This deletes cookieList! +- cookieDomains.remove(domain); +- domainList.remove(domain); ++ m_cookieDomains.remove(domain); ++ m_domainList.remove(domain); + } + } + else +@@ -856,13 +1046,14 @@ + if (_advice != KCookieDunno) + { + // We should create a domain entry +- configChanged = true; ++ m_configChanged = true; + // Make a new cookie list + cookieList = new KHttpCookieList(); ++ cookieList->setAutoDelete(true); + cookieList->setAdvice( _advice); +- cookieDomains.insert( domain, cookieList); ++ m_cookieDomains.insert( domain, cookieList); + // Update the list of domains +- domainList.append( domain); ++ m_domainList.append( domain); + } + } + } +@@ -883,9 +1074,9 @@ + // + void KCookieJar::setGlobalAdvice(KCookieAdvice _advice) + { +- if (globalAdvice != _advice) +- configChanged = true; +- globalAdvice = _advice; ++ if (m_globalAdvice != _advice) ++ m_configChanged = true; ++ m_globalAdvice = _advice; + } + + // +@@ -893,7 +1084,7 @@ + // + const QStringList& KCookieJar::getDomainList() + { +- return domainList; ++ return m_domainList; + } + + // +@@ -909,7 +1100,7 @@ + else + domain = _domain; + +- return cookieDomains[domain]; ++ return m_cookieDomains[domain]; + } + + // +@@ -919,86 +1110,97 @@ + void KCookieJar::eatCookie(KHttpCookiePtr cookiePtr) + { + QString domain = stripDomain(cookiePtr); // We file the cookie under this domain. +- KHttpCookieList *cookieList = cookieDomains[domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; + + if (cookieList) + { + // This deletes cookiePtr! + if (cookieList->removeRef( cookiePtr )) +- cookiesChanged = true; ++ m_cookiesChanged = true; + + if ((cookieList->isEmpty()) && + (cookieList->getAdvice() == KCookieDunno)) + { + // This deletes cookieList! +- cookieDomains.remove(domain); ++ m_cookieDomains.remove(domain); + +- domainList.remove(domain); ++ m_domainList.remove(domain); + } + } + } + + void KCookieJar::eatCookiesForDomain(const QString &domain) + { +- KHttpCookieList *cookieList = cookieDomains[domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; + if (!cookieList || cookieList->isEmpty()) return; + + cookieList->clear(); + if (cookieList->getAdvice() == KCookieDunno) + { + // This deletes cookieList! +- cookieDomains.remove(domain); +- domainList.remove(domain); ++ m_cookieDomains.remove(domain); ++ m_domainList.remove(domain); + } +- cookiesChanged = true; ++ m_cookiesChanged = true; + } + +-void KCookieJar::eatSessionCookies( int winId ) ++void KCookieJar::eatSessionCookies( long windowId ) + { +- QStringList::Iterator it=domainList.begin(); +- for ( ; it != domainList.end(); ++it ) +- eatSessionCookies( *it, winId, false ); ++ if (!windowId) ++ return; ++ ++ QStringList::Iterator it=m_domainList.begin(); ++ for ( ; it != m_domainList.end(); ++it ) ++ eatSessionCookies( *it, windowId, false ); + } + +-void KCookieJar::eatSessionCookies( const QString& fqdn, int winId, ++void KCookieJar::eatAllCookies() ++{ ++ for ( QStringList::Iterator it=m_domainList.begin(); ++ it != m_domainList.end();) ++ { ++ QString domain = *it++; ++ // This might remove domain from domainList! ++ eatCookiesForDomain(domain); ++ } ++} ++ ++void KCookieJar::eatSessionCookies( const QString& fqdn, long windowId, + bool isFQDN ) + { + KHttpCookieList* cookieList; +- if ( isFQDN ) ++ if ( !isFQDN ) ++ cookieList = m_cookieDomains[fqdn]; ++ else + { + QString domain; + stripDomain( fqdn, domain ); +- cookieList = cookieDomains[domain]; ++ cookieList = m_cookieDomains[domain]; + } +- else +- cookieList = cookieDomains[fqdn]; + + if ( cookieList ) + { + KHttpCookiePtr cookie=cookieList->first(); + for (; cookie != 0;) + { +- if (cookie->windowId() == winId && +- (cookie->expireDate() == 0)) ++ if ((cookie->expireDate() != 0) && !m_ignoreCookieExpirationDate) + { +- KHttpCookiePtr old_cookie = cookie; +- cookie = cookieList->next(); +- cookieList->removeRef( old_cookie ); ++ cookie = cookieList->next(); ++ continue; + } +- else +- cookie = cookieList->next(); +- } +- } +-} +- + +-void KCookieJar::eatAllCookies() +-{ +- for ( QStringList::Iterator it=domainList.begin(); +- it != domainList.end();) +- { +- QString domain = *it++; +- eatCookiesForDomain(domain); // This might remove domain from domainList! ++ QValueList<long> &ids = cookie->windowIds(); ++ bool empty = (ids.find(windowId) == ids.end() ); ++ ids.remove(windowId); ++ if (!empty || !ids.isEmpty()) ++ { ++ cookie = cookieList->next(); ++ continue; ++ } ++ KHttpCookiePtr old_cookie = cookie; ++ cookie = cookieList->next(); ++ cookieList->removeRef( old_cookie ); ++ } + } + } + +@@ -1008,7 +1210,7 @@ + // On failure 'false' is returned. + bool KCookieJar::saveCookies(const QString &_filename) + { +- KSaveFile saveFile(_filename); ++ KSaveFile saveFile(_filename, 0600); + + if (saveFile.status() != 0) + return false; +@@ -1017,31 +1219,31 @@ + + time_t curTime = time(0); + +- fprintf(fStream, "# KDE Cookie File\n#\n"); ++ fprintf(fStream, "# KDE Cookie File v2\n#\n"); + +- fprintf(fStream, "%-20s %-20s %-12s %-9s %-4s %-10s %s %-4s\n", +- "# Host", "Domain", "Path", "Exp.date", "Prot", "Name", "Value", "Secure"); ++ fprintf(fStream, "%-20s %-20s %-12s %-10s %-4s %-20s %-4s %s\n", ++ "# Host", "Domain", "Path", "Exp.date", "Prot", ++ "Name", "Sec", "Value"); + +- for ( QStringList::Iterator it=domainList.begin(); +- it != domainList.end(); +- it++) ++ for ( QStringList::Iterator it=m_domainList.begin(); it != m_domainList.end(); ++ it++ ) + { + const QString &domain = *it; + bool domainPrinted = false; + +- KHttpCookieList *cookieList = cookieDomains[domain]; ++ KHttpCookieList *cookieList = m_cookieDomains[domain]; + KHttpCookiePtr cookie=cookieList->first(); + +- for (; cookie != 0;) ++ for (; cookie != 0;) + { + if (cookie->isExpired(curTime)) +- { +- // Delete expired cookies ++ { ++ // Delete expired cookies + KHttpCookiePtr old_cookie = cookie; + cookie = cookieList->next(); + cookieList->removeRef( old_cookie ); +- } +- else if (cookie->expireDate() != 0) ++ } ++ else if (cookie->expireDate() != 0 && !m_ignoreCookieExpirationDate) + { + if (!domainPrinted) + { +@@ -1049,25 +1251,26 @@ + fprintf(fStream, "[%s]\n", domain.local8Bit().data()); + } + // Store persistent cookies +- QString path("\""); ++ QString path = L1("\""); + path += cookie->path(); +- path += "\""; +- QString domain("\""); ++ path += '"'; ++ QString domain = L1("\""); + domain += cookie->domain(); +- domain += "\""; +- fprintf(fStream, "%-20s %-20s %-12s %9lu %2d %-10s %s %-4i\n", +- cookie->host().local8Bit().data(), domain.local8Bit().data(), path.local8Bit().data(), +- (unsigned long) cookie->expireDate(), cookie->protocolVersion()+100, +- cookie->name().local8Bit().data(), cookie->value().local8Bit().data(), +- cookie->isSecure()); +- cookie = cookieList->next(); +- } +- else +- { +- // Skip session-only cookies +- cookie = cookieList->next(); +- } +- } ++ domain += '"'; ++ fprintf(fStream, "%-20s %-20s %-12s %10lu %3d %-20s %-4i %s\n", ++ cookie->host().latin1(), domain.latin1(), ++ path.latin1(), (unsigned long) cookie->expireDate(), ++ cookie->protocolVersion(), cookie->name().latin1(), ++ (cookie->isSecure() ? 1 : 0) + (cookie->isHttpOnly() ? 2 : 0) + (cookie->hasExplicitPath() ? 4 : 0), ++ cookie->value().latin1()); ++ cookie = cookieList->next(); ++ } ++ else ++ { ++ // Skip session-only cookies ++ cookie = cookieList->next(); ++ } ++ } + } + + return saveFile.close(); +@@ -1080,26 +1283,27 @@ + char *result; + if (!keepQuotes && (*buffer == '\"')) + { +- // Find terminating " ++ // Find terminating " + buffer++; + result = buffer; + while((*buffer != '\"') && (*buffer)) +- buffer++; ++ buffer++; + } + else + { + // Find first white space + result = buffer; + while((*buffer != ' ') && (*buffer != '\t') && (*buffer != '\n') && (*buffer)) +- buffer++; ++ buffer++; + } ++ + if (!*buffer) +- return result; // ++ return result; // + *buffer++ = '\0'; + + // Skip white-space + while((*buffer == ' ') || (*buffer == '\t') || (*buffer == '\n')) +- buffer++; ++ buffer++; + + return result; + } +@@ -1124,7 +1328,18 @@ + bool err = false; + err = (fgets(buffer, READ_BUFFER_SIZE, fStream) == 0); + +- err = err || (strcmp(buffer, "# KDE Cookie File\n") != 0); ++ int version = 1; ++ if (!err) ++ { ++ if (strcmp(buffer, "# KDE Cookie File\n") == 0) ++ { ++ // version 1 ++ } ++ else if (sscanf(buffer, "# KDE Cookie File v%d\n", &version) != 1) ++ { ++ err = true; ++ } ++ } + + if (!err) + { +@@ -1146,13 +1361,31 @@ + int protVer = (time_t) strtoul(verStr, 0, 10); + const char *name( parseField(line) ); + bool keepQuotes = false; +- if (protVer >= 100) ++ bool secure = false; ++ bool httpOnly = false; ++ bool explicitPath = false; ++ const char *value = 0; ++ if ((version == 2) || (protVer >= 200)) + { +- protVer -= 100; +- keepQuotes = true; ++ if (protVer >= 200) ++ protVer -= 200; ++ int i = atoi( parseField(line) ); ++ secure = i & 1; ++ httpOnly = i & 2; ++ explicitPath = i & 4; ++ line[strlen(line)-1] = '\0'; // Strip LF. ++ value = line; ++ } ++ else ++ { ++ if (protVer >= 100) ++ { ++ protVer -= 100; ++ keepQuotes = true; ++ } ++ value = parseField(line, keepQuotes); ++ secure = atoi( parseField(line) ); + } +- const char *value( parseField(line, keepQuotes) ); +- bool secure = atoi( parseField(line) ); + + // Parse error + if (!value) continue; +@@ -1161,15 +1394,18 @@ + if ((expDate == 0) || (expDate < curTime)) + continue; + +- KHttpCookie *cookie = new KHttpCookie(host, domain, path, name, +- value, expDate, protVer, +- secure); +- if ( cookieAdvice( cookie ) ) +- addCookie(cookie); ++ KHttpCookie *cookie = new KHttpCookie(QString::fromLatin1(host), ++ QString::fromLatin1(domain), ++ QString::fromLatin1(path), ++ QString::fromLatin1(name), ++ QString::fromLatin1(value), ++ expDate, protVer, ++ secure, httpOnly, explicitPath); ++ addCookie(cookie); + } + } + delete [] buffer; +- cookiesChanged = false; ++ m_cookiesChanged = false; + + fclose( fStream); + return err; +@@ -1181,19 +1417,18 @@ + + void KCookieJar::saveConfig(KConfig *_config) + { +- if (!configChanged) ++ if (!m_configChanged) + return; + +- _config->setGroup(QString::null); +- _config->writeEntry("DefaultRadioButton", defaultRadioButton); +- _config->writeEntry("ShowCookieDetails", showCookieDetails ); +- +- QStringList domainSettings; ++ _config->setGroup("Cookie Dialog"); ++ _config->writeEntry("PreferredPolicy", m_preferredPolicy); ++ _config->writeEntry("ShowCookieDetails", m_showCookieDetails ); + _config->setGroup("Cookie Policy"); +- _config->writeEntry("CookieGlobalAdvice", adviceToStr( globalAdvice)); ++ _config->writeEntry("CookieGlobalAdvice", adviceToStr( m_globalAdvice)); + +- for ( QStringList::Iterator it=domainList.begin(); +- it != domainList.end(); ++ QStringList domainSettings; ++ for ( QStringList::Iterator it=m_domainList.begin(); ++ it != m_domainList.end(); + it++ ) + { + const QString &domain = *it; +@@ -1208,6 +1443,7 @@ + } + _config->writeEntry("CookieDomainAdvice", domainSettings); + _config->sync(); ++ m_configChanged = false; + } + + +@@ -1217,23 +1453,23 @@ + + void KCookieJar::loadConfig(KConfig *_config, bool reparse ) + { +- QString value; +- QStringList domainSettings; +- + if ( reparse ) + _config->reparseConfiguration(); + +- _config->setGroup(QString::null); +- defaultRadioButton = _config->readNumEntry( "DefaultRadioButton", 0 ); +- showCookieDetails = _config->readBoolEntry( "ShowCookieDetails" ); ++ _config->setGroup("Cookie Dialog"); ++ m_showCookieDetails = _config->readBoolEntry( "ShowCookieDetails" ); ++ m_preferredPolicy = _config->readNumEntry( "PreferredPolicy", 0 ); + + _config->setGroup("Cookie Policy"); +- value = _config->readEntry("CookieGlobalAdvice", "Ask"); +- globalAdvice = strToAdvice(value); +- domainSettings = _config->readListEntry("CookieDomainAdvice"); ++ QStringList domainSettings = _config->readListEntry("CookieDomainAdvice"); ++ m_rejectCrossDomainCookies = _config->readBoolEntry( "RejectCrossDomainCookies", true ); ++ m_autoAcceptSessionCookies = _config->readBoolEntry( "AcceptSessionCookies", true ); ++ m_ignoreCookieExpirationDate = _config->readBoolEntry( "IgnoreExpirationDate", false ); ++ QString value = _config->readEntry("CookieGlobalAdvice", L1("Ask")); ++ m_globalAdvice = strToAdvice(value); + + // Reset current domain settings first. +- for ( QStringList::Iterator it=domainList.begin(); it != domainList.end(); ) ++ for ( QStringList::Iterator it=m_domainList.begin(); it != m_domainList.end(); ) + { + // Make sure to update iterator before calling setDomainAdvice() + // setDomainAdvice() might delete the domain from domainList. +@@ -1241,16 +1477,19 @@ + setDomainAdvice(domain, KCookieDunno); + } + +- // Now apply the ++ // Now apply the domain settings read from config file... + for ( QStringList::Iterator it=domainSettings.begin(); + it != domainSettings.end(); ) + { + const QString &value = *it++; ++ + int sepPos = value.find(':'); +- if (sepPos <= 0) { continue; } ++ ++ if (sepPos <= 0) ++ continue; ++ + QString domain(value.left(sepPos)); + KCookieAdvice advice = strToAdvice( value.mid(sepPos + 1) ); + setDomainAdvice(domain, advice); + } + } +- +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiejar.h~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiejar.h +@@ -20,7 +20,7 @@ + //---------------------------------------------------------------------------- + // + // KDE File Manager -- HTTP Cookies +-// $Id: kcookiejar.h,v 1.21.2.1 2001/09/08 22:03:49 adawit Exp $ ++// $Id: kcookiejar.h,v 1.34 2004/07/20 15:29:24 waba Exp $ + + #ifndef KCOOKIEJAR_H + #define KCOOKIEJAR_H +@@ -59,10 +59,12 @@ + QString mValue; + time_t mExpireDate; + int mProtocolVersion; +- long mWindowId; + bool mSecure; ++ bool mCrossDomain; ++ bool mHttpOnly; ++ bool mExplicitPath; ++ QValueList<long> mWindowIds; + +- KHttpCookiePtr nextCookie; + QString cookieStr(bool useDOMFormat); + + public: +@@ -73,28 +75,32 @@ + const QString &_value=QString::null, + time_t _expireDate=0, + int _protocolVersion=0, +- bool _secure = false); ++ bool _secure = false, ++ bool _httpOnly = false, ++ bool _explicitPath = false); + + QString domain(void) { return mDomain; } + QString host(void) { return mHost; } + QString path(void) { return mPath; } + QString name(void) { return mName; } + QString value(void) { return mValue; } +- long windowId(void) { return mWindowId; } ++ QValueList<long> &windowIds(void) { return mWindowIds; } + void fixDomain(const QString &domain) { mDomain = domain; } + time_t expireDate(void) { return mExpireDate; } + int protocolVersion(void) { return mProtocolVersion; } + bool isSecure(void) { return mSecure; } + bool isExpired(time_t currentDate); ++ bool isCrossDomain(void) { return mCrossDomain; } ++ bool isHttpOnly(void) { return mHttpOnly; } ++ bool hasExplicitPath(void) { return mExplicitPath; } + bool match(const QString &fqdn, const QStringList &domainList, const QString &path); +- KHttpCookiePtr next() { return nextCookie; } + }; + + class KHttpCookieList : public QList<KHttpCookie> + { + public: + KHttpCookieList() : QList<KHttpCookie>(), advice( KCookieDunno ) +- { setAutoDelete(true); } ++ { } + virtual ~KHttpCookieList() { } + + virtual int compareItems( void * item1, void * item2); +@@ -125,7 +131,7 @@ + /** + * Returns whether the cookiejar has been changed + */ +- bool changed() { return cookiesChanged || configChanged; } ++ bool changed() const { return m_cookiesChanged || m_configChanged; } + + /** + * Store all the cookies in a safe(?) place +@@ -154,8 +160,11 @@ + * + * If @p useDOMFormat is true, the string is formatted in a format + * in compliance with the DOM standard. ++ * @p pendingCookies contains a list of cookies that have not been ++ * approved yet by the user but that will be included in the result ++ * none the less. + */ +- QString findCookies(const QString &_url, bool useDOMFormat); ++ QString findCookies(const QString &_url, bool useDOMFormat, long windowId, KHttpCookieList *pendingCookies=0); + + /** + * This function parses cookie_headers and returns a linked list of +@@ -165,17 +174,17 @@ + * cookie_headers should be a concatenation of all lines of a HTTP-header + * which start with "Set-Cookie". The lines should be separated by '\n's. + */ +- KHttpCookiePtr makeCookies(const QString &_url, const QCString &cookie_headers, long windowId); ++ KHttpCookieList makeCookies(const QString &_url, const QCString &cookie_headers, long windowId); + + /** + * This function parses cookie_headers and returns a linked list of + * valid KHttpCookie objects for all cookies found in cookie_headers. + * If no cookies could be found 0 is returned. + * +- * cookie_domstr should be a concatenation of "name=value" pairs, seperated ++ * cookie_domstr should be a concatenation of "name=value" pairs, separated + * by a semicolon ';'. + */ +- KHttpCookiePtr makeDOMCookies(const QString &_url, const QCString &cookie_domstr, long windowId); ++ KHttpCookieList makeDOMCookies(const QString &_url, const QCString &cookie_domstr, long windowId); + + /** + * This function hands a KHttpCookie object over to the cookie jar. +@@ -279,13 +288,13 @@ + * Removes all end of session cookies set by the + * session @p windId. + */ +- void eatSessionCookies( int windId ); ++ void eatSessionCookies( long windowId ); + + /** + * Removes all end of session cookies set by the + * session @p windId. + */ +- void eatSessionCookies( const QString& fqdn, int windId, bool isFQDN = true ); ++ void eatSessionCookies( const QString& fqdn, long windowId, bool isFQDN = true ); + + /** + * Parses _url and returns the FQDN (_fqdn) and path (_path). +@@ -297,21 +306,46 @@ + /** + * Returns a list of domains (_domainList) relevant for this host. + */ +- static void extractDomains(const QString &_fqdn, +- QStringList &_domainList); ++ void extractDomains(const QString &_fqdn, ++ QStringList &_domainList); + + static QString adviceToStr(KCookieAdvice _advice); + static KCookieAdvice strToAdvice(const QString &_str); + +- // Save this in the config file... +- int defaultRadioButton; // 0 = This cookie, 1 = domain, 2 = all cookies +- bool showCookieDetails; // true, false ++ /** Returns the */ ++ int preferredDefaultPolicy() const { return m_preferredPolicy; } ++ ++ /** Returns the */ ++ bool showCookieDetails () const { return m_showCookieDetails; } ++ ++ /** ++ * Sets the user's default preference cookie policy. ++ */ ++ void setPreferredDefaultPolicy (int value) { m_preferredPolicy = value; } ++ ++ /** ++ * Sets the user's preference of level of detail displayed ++ * by the cookie dialog. ++ */ ++ void setShowCookieDetails (bool value) { m_showCookieDetails = value; } + + protected: +- QDict<KHttpCookieList> cookieDomains; +- QStringList domainList; +- KCookieAdvice globalAdvice; +- bool configChanged; +- bool cookiesChanged; ++ void stripDomain(const QString &_fqdn, QString &_domain); ++ QString stripDomain( KHttpCookiePtr cookiePtr); ++ ++protected: ++ QStringList m_domainList; ++ KCookieAdvice m_globalAdvice; ++ QDict<KHttpCookieList> m_cookieDomains; ++ QDict<int> m_twoLevelTLD; ++ ++ bool m_configChanged; ++ bool m_cookiesChanged; ++ bool m_showCookieDetails; ++ bool m_rejectCrossDomainCookies; ++ bool m_autoAcceptSessionCookies; ++ bool m_ignoreCookieExpirationDate; ++ ++ int m_preferredPolicy; + }; + #endif +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver.cpp~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver.cpp +@@ -23,25 +23,26 @@ + //---------------------------------------------------------------------------- + // + // KDE Cookie Server +-// $Id: kcookieserver.cpp,v 1.33.2.1 2001/09/08 22:03:49 adawit Exp $ ++// $Id: kcookieserver.cpp,v 1.52 2004/08/16 14:04:40 lunakl Exp $ + + #define SAVE_DELAY 3 // Save after 3 minutes + +-#include "kcookieserver.h" +-#include "kcookiejar.h" +-#include "kcookiewin.h" ++#include <unistd.h> + +-#include <kdebug.h> +-#include <kapp.h> +-#include <kcmdlineargs.h> +-#include <kstddirs.h> + #include <qtimer.h> +-#include <unistd.h> + #include <qlist.h> + #include <qfile.h> + + #include <dcopclient.h> ++ + #include <kconfig.h> ++#include <kdebug.h> ++#include <kcmdlineargs.h> ++#include <kstddirs.h> ++ ++#include "kcookiejar.h" ++#include "kcookiewin.h" ++#include "kcookieserver.h" + + // Cookie field indexes + enum CookieDetails { CF_DOMAIN=0, CF_PATH, CF_NAME, CF_HOST, +@@ -53,6 +54,7 @@ + DCOPClientTransaction *transaction; + QString url; + bool DOM; ++ long windowId; + }; + + template class QList<CookieRequest>; +@@ -68,10 +70,11 @@ + { + mCookieJar = new KCookieJar; + mPendingCookies = new KHttpCookieList; ++ mPendingCookies->setAutoDelete(true); + mRequestList = new RequestList; + mAdvicePending = false; + mTimer = 0; +- mCookieJar->loadConfig( kapp->config()); ++ mCookieJar->loadConfig( kapp->config() ); + + QString filename = locateLocal("appdata", "cookies"); + +@@ -89,12 +92,16 @@ + { + mCookieJar->loadCookies( filename); + } ++ ++ QWidget *wid = qApp->desktop(); ++ mBigScreen = (wid->width() > 320 || wid->height() > 320); + } + + KCookieServer::~KCookieServer() + { + if (mCookieJar->changed()) + slotSave(); ++ + delete mCookieJar; + delete mTimer; + delete mPendingCookies; +@@ -125,7 +132,7 @@ + return 0; + } + +-bool KCookieServer::cookiesPending( const QString &url ) ++bool KCookieServer::cookiesPending( const QString &url, KHttpCookieList *cookieList ) + { + QString fqdn; + QStringList domains; +@@ -136,109 +143,152 @@ + if (!KCookieJar::parseURL(url, fqdn, path)) + return false; + +- KCookieJar::extractDomains( fqdn, domains ); ++ mCookieJar->extractDomains( fqdn, domains ); + for( KHttpCookie *cookie = mPendingCookies->first(); + cookie != 0L; + cookie = mPendingCookies->next()) + { + if (cookie->match( fqdn, domains, path)) +- return true; ++ { ++ if (!cookieList) ++ return true; ++ cookieList->append(cookie); ++ } + } +- return false; ++ if (!cookieList) ++ return false; ++ return cookieList->isEmpty(); + } + + void KCookieServer::addCookies( const QString &url, const QCString &cookieHeader, + long windowId, bool useDOMFormat ) + { +- KHttpCookiePtr cookie = 0; ++ KHttpCookieList cookieList; + if (useDOMFormat) +- cookie = mCookieJar->makeDOMCookies(url, cookieHeader, windowId); ++ cookieList = mCookieJar->makeDOMCookies(url, cookieHeader, windowId); + else +- cookie = mCookieJar->makeCookies(url, cookieHeader, windowId); ++ cookieList = mCookieJar->makeCookies(url, cookieHeader, windowId); + +- if (mAdvicePending) +- { +- checkCookies(cookie, true); +- } +- else ++ checkCookies(&cookieList); ++ ++ for(KHttpCookiePtr cookie = cookieList.first(); cookie; cookie = cookieList.first()) ++ mPendingCookies->append(cookieList.take()); ++ ++ if (!mAdvicePending) + { + mAdvicePending = true; +- do { +- checkCookies(cookie, false); +- cookie = mPendingCookies->count() ? mPendingCookies->take(0) : 0; ++ while (!mPendingCookies->isEmpty()) ++ { ++ checkCookies(0); + } +- while (cookie); + mAdvicePending = false; + } +- + } + +-void KCookieServer::checkCookies( KHttpCookie *cookie, bool queue ) ++void KCookieServer::checkCookies( KHttpCookieList *cookieList) + { +- QString host; +- KCookieAdvice userAdvice = KCookieDunno; +- if (cookie) host = cookie->host(); ++ KHttpCookieList *list; ++ ++ if (cookieList) ++ list = cookieList; ++ else ++ list = mPendingCookies; ++ ++ KHttpCookiePtr cookie = list->first(); + while (cookie) + { +- KHttpCookiePtr next_cookie = cookie->next(); + KCookieAdvice advice = mCookieJar->cookieAdvice(cookie); +- if ((advice == KCookieAsk) || (advice == KCookieDunno)) +- { +- // We only ask the user once, even if we get multiple +- // cookies from the same site. +- if (userAdvice == KCookieDunno) +- { +- if (queue) +- { +- mPendingCookies->append(cookie); +- return; +- } +- else +- { +- mPendingCookies->prepend(cookie); +- KCookieWin *kw = new KCookieWin( 0L, cookie, +- mCookieJar->defaultRadioButton, +- mCookieJar->showCookieDetails ); +- userAdvice = kw->advice(mCookieJar, cookie); +- delete kw; +- mPendingCookies->take(0); +- // Save the cookie config if it has changed +- mCookieJar->saveConfig( kapp->config() ); +- } +- } +- advice = userAdvice; +- } + switch(advice) + { + case KCookieAccept: ++ list->take(); + mCookieJar->addCookie(cookie); ++ cookie = list->current(); + break; + + case KCookieReject: +- default: ++ list->take(); + delete cookie; ++ cookie = list->current(); ++ break; ++ ++ default: ++ cookie = list->next(); + break; + } +- cookie = next_cookie; +- if (!cookie && !queue) ++ } ++ ++ if (cookieList || list->isEmpty()) ++ return; ++ ++ KHttpCookiePtr currentCookie = mPendingCookies->first(); ++ ++ KHttpCookieList currentList; ++ currentList.append(currentCookie); ++ QString currentHost = currentCookie->host(); ++ ++ cookie = mPendingCookies->next(); ++ while (cookie) ++ { ++ if (cookie->host() == currentHost) + { +- // Check if there are cookies on the pending list from the +- // same host. +- for( cookie = mPendingCookies->first(); +- cookie; +- cookie = mPendingCookies->next()) +- { +- if (cookie->host() == host) +- break; +- } +- if (cookie) ++ currentList.append(cookie); ++ } ++ cookie = mPendingCookies->next(); ++ } ++ ++ KCookieWin *kw; ++ KScrolledCookieWin *skw= 0L; ++ ++ if(mBigScreen) { ++ skw = new KScrolledCookieWin(0L, currentList, ++ mCookieJar->preferredDefaultPolicy(), ++ mCookieJar->showCookieDetails() ); ++ kw = skw->cookieWindow(); ++ }else ++ kw = new KCookieWin( 0L, currentList, ++ mCookieJar->preferredDefaultPolicy(), ++ mCookieJar->showCookieDetails() ); ++ ++ KCookieAdvice userAdvice = kw->advice(mCookieJar, currentCookie); ++ delete kw; ++ delete skw; ++ // Save the cookie config if it has changed ++ mCookieJar->saveConfig( kapp->config() ); ++ ++ // Apply the user's choice to all cookies that are currently ++ // queued for this host. ++ cookie = mPendingCookies->first(); ++ while (cookie) ++ { ++ if (cookie->host() == currentHost) ++ { ++ switch(userAdvice) + { +- // Found a matching cookie, remove it from the pending list. +- cookie = mPendingCookies->take(); ++ case KCookieAccept: ++ mPendingCookies->take(); ++ mCookieJar->addCookie(cookie); ++ cookie = mPendingCookies->current(); ++ break; ++ ++ case KCookieReject: ++ mPendingCookies->take(); ++ delete cookie; ++ cookie = mPendingCookies->current(); ++ break; ++ ++ default: ++ cookie = mPendingCookies->next(); ++ break; + } + } ++ else ++ { ++ cookie = mPendingCookies->next(); ++ } + } + ++ + // Check if we can handle any request + for ( CookieRequest *request = mRequestList->first(); request;) + { +@@ -246,13 +296,13 @@ + { + QCString replyType; + QByteArray replyData; +- QString res = mCookieJar->findCookies( request->url, request->DOM ); ++ QString res = mCookieJar->findCookies( request->url, request->DOM, request->windowId ); + + QDataStream stream2(replyData, IO_WriteOnly); + stream2 << res; + replyType = "QString"; + dcopClient()->endTransaction( request->transaction, +- replyType, replyData); ++ replyType, replyData); + CookieRequest *tmp = request; + request = mRequestList->next(); + mRequestList->removeRef( tmp ); +@@ -271,7 +321,7 @@ + { + delete mTimer; + mTimer = 0; +- QString filename = locateLocal("appdata", "cookies"); ++ QString filename = locateLocal("data", "kcookiejar/cookies"); + mCookieJar->saveCookies(filename); + } + +@@ -333,8 +383,9 @@ + return + ((hasDomain && c->domain() == domain) || + fqdn == c->host()) && +- (c->path() == path) && +- (c->name() == name); ++ (c->path() == path) && ++ (c->name() == name) && ++ (!c->isExpired(time(0))); + } + return false; + } +@@ -343,16 +394,30 @@ + QString + KCookieServer::findCookies(QString url) + { ++ return findCookies(url, 0); ++} ++ ++// DCOP function ++QString ++KCookieServer::findCookies(QString url, long windowId) ++{ + if (cookiesPending(url)) + { + CookieRequest *request = new CookieRequest; + request->transaction = dcopClient()->beginTransaction(); + request->url = url; + request->DOM = false; ++ request->windowId = windowId; + mRequestList->append( request ); + return QString::null; // Talk to you later :-) + } +- return mCookieJar->findCookies(url, false); ++ ++ QString cookies = mCookieJar->findCookies(url, false, windowId); ++ ++ if (mCookieJar->changed() && !mTimer) ++ saveCookieJar(); ++ ++ return cookies; + } + + // DCOP function +@@ -409,16 +474,20 @@ + QString + KCookieServer::findDOMCookies(QString url) + { +- if (cookiesPending(url)) +- { +- CookieRequest *request = new CookieRequest; +- request->transaction = dcopClient()->beginTransaction(); +- request->url = url; +- request->DOM = true; +- mRequestList->append( request ); +- return QString::null; // Talk to you later :-) +- } +- return mCookieJar->findCookies(url, true); ++ return findDOMCookies(url, 0); ++} ++ ++// DCOP function ++QString ++KCookieServer::findDOMCookies(QString url, long windowId) ++{ ++ // We don't wait for pending cookies because it locks up konqueror ++ // which can cause a deadlock if it happens to have a popup-menu up. ++ // Instead we just return pending cookies as if they had been accepted already. ++ KHttpCookieList pendingCookies; ++ cookiesPending(url, &pendingCookies); ++ ++ return mCookieJar->findCookies(url, true, windowId, &pendingCookies); + } + + // DCOP function +@@ -459,18 +528,27 @@ + saveCookieJar(); + } + ++ ++// Qt function + void +-KCookieServer::deleteSessionCookies( long winId ) ++KCookieServer::slotDeleteSessionCookies( long windowId ) + { +- mCookieJar->eatSessionCookies( winId ); ++ deleteSessionCookies(windowId); ++} ++ ++// DCOP function ++void ++KCookieServer::deleteSessionCookies( long windowId ) ++{ ++ mCookieJar->eatSessionCookies( windowId ); + if(!mTimer) + saveCookieJar(); + } + + void +-KCookieServer::deleteSessionCookiesFor(QString fqdn, long winId) ++KCookieServer::deleteSessionCookiesFor(QString fqdn, long windowId) + { +- mCookieJar->eatSessionCookies( fqdn, winId ); ++ mCookieJar->eatSessionCookies( fqdn, windowId ); + if(!mTimer) + saveCookieJar(); + } +@@ -500,7 +578,7 @@ + if (KCookieJar::parseURL(url, fqdn, dummy)) + { + QStringList domains; +- KCookieJar::extractDomains(fqdn, domains); ++ mCookieJar->extractDomains(fqdn, domains); + mCookieJar->setDomainAdvice(domains[0], + KCookieJar::strToAdvice(advice)); + } +@@ -516,7 +594,7 @@ + if (KCookieJar::parseURL(url, fqdn, dummy)) + { + QStringList domains; +- KCookieJar::extractDomains(fqdn, domains); ++ mCookieJar->extractDomains(fqdn, domains); + advice = mCookieJar->getDomainAdvice(domains[0]); + } + return KCookieJar::adviceToStr(advice); +@@ -533,7 +611,7 @@ + void + KCookieServer::shutdown() + { +- quit(); ++ quit(); + } + + #include "kcookieserver.moc" +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver.h~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver.h +@@ -20,7 +20,7 @@ + //---------------------------------------------------------------------------- + // + // KDE Cookie Server +-// $Id: kcookieserver.h,v 1.15.2.1 2001/09/08 22:03:49 adawit Exp $ ++// $Id: kcookieserver.h,v 1.24 2003/06/09 10:56:42 waba Exp $ + + #ifndef KCOOKIESERVER_H + #define KCOOKIESERVER_H +@@ -33,6 +33,7 @@ + class KHttpCookie; + class QTimer; + class RequestList; ++class KConfig; + + class KCookieServer : public KUniqueApplication + { +@@ -46,9 +47,11 @@ + + k_dcop: + QString findCookies(QString); ++ QString findCookies(QString, long); + QStringList findDomains(); + QStringList findCookies(QValueList<int>,QString,QString,QString,QString); + QString findDOMCookies(QString); ++ QString findDOMCookies(QString, long); + void addCookies(QString, QCString, long); + void deleteCookie(QString, QString, QString, QString); + void deleteCookiesFromDomain(QString); +@@ -62,13 +65,14 @@ + void shutdown(); + + public: +- bool cookiesPending(const QString &url); ++ bool cookiesPending(const QString &url, KHttpCookieList *cookieList=0); + void addCookies(const QString &url, const QCString &cookieHeader, + long windowId, bool useDOMFormat); +- void checkCookies(KHttpCookie *cookie, bool queue); ++ void checkCookies(KHttpCookieList *cookieList); + + public slots: + void slotSave(); ++ void slotDeleteSessionCookies(long); + + protected: + KCookieJar *mCookieJar; +@@ -82,6 +86,7 @@ + bool cookieMatches(KHttpCookie*, QString, QString, QString, QString); + void putCookie(QStringList&, KHttpCookie*, const QValueList<int>&); + void saveCookieJar(); ++ bool mBigScreen : 1; + }; + + #endif +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiewin.cpp~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiewin.cpp +@@ -1,8 +1,8 @@ + /* + This file is part of KDE + +- Copyright (C) 2000 Waldo Bastian <bastian@kde.org> +- Copyright (C) 2000-2001 Dawit Alemayehu <adawit@kde.org> ++ Copyright (C) 2000- Waldo Bastian <bastian@kde.org> ++ Copyright (C) 2000- Dawit Alemayehu <adawit@kde.org> + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal +@@ -24,7 +24,7 @@ + //---------------------------------------------------------------------------- + // + // KDE File Manager -- HTTP Cookie Dialogs +-// $Id: kcookiewin.cpp,v 1.26 2001/05/13 23:36:48 adawit Exp $ ++// $Id: kcookiewin.cpp,v 1.55 2004/07/07 15:18:43 waba Exp $ + + // The purpose of the QT_NO_TOOLTIP and QT_NO_WHATSTHIS ifdefs is because + // this file is also used in Konqueror/Embedded. One of the aims of +@@ -54,26 +54,43 @@ + #include <qpushbutton.h> + #include <qradiobutton.h> + #include <qvbuttongroup.h> ++#include <qscrollview.h> ++ ++#ifndef QT_NO_TOOLTIP ++#include <qtooltip.h> ++#endif ++ ++#ifndef QT_NO_WHATSTHIS ++#include <qwhatsthis.h> ++#endif + +-#include <kapp.h> + #include <kwin.h> + #include <klocale.h> + #include <kglobal.h> + #include <kurllabel.h> ++#include <qlineedit.h> + #include <kiconloader.h> + ++#ifndef Q_WS_QWS //FIXME(E): Implement for Qt Embedded ++#include <X11/Xlib.h> ++#else ++#include <qpe/qpeapplication.h> ++#endif ++ + #include "kcookiejar.h" + #include "kcookiewin.h" + +-KCookieWin::KCookieWin( QWidget *parent, KHttpCookie* cookie, ++KCookieWin::KCookieWin( QWidget *parent, KHttpCookieList cookieList, + int defaultButton, bool showDetails ) + :KDialog( parent, "cookiealert", true ) + { +- KWin::setState( winId(), NET::StaysOnTop ); +- KWin::setOnDesktop(winId(), KWin::currentDesktop()); ++#ifndef Q_WS_QWS //FIXME(E): Implement for Qt Embedded + setCaption( i18n("Cookie Alert") ); + setIcon( SmallIcon("cookie") ); +- ++ // all cookies in the list should have the same window at this time, so let's take the first ++ if( cookieList.first()->windowIds().count() > 0 ) ++ XSetTransientForHint( qt_xdisplay(), winId(), cookieList.first()->windowIds().first()); ++#endif + // Main widget's layout manager... + QVBoxLayout* vlayout = new QVBoxLayout( this, KDialog::marginHint(), KDialog::spacingHint() ); + vlayout->setResizeMode( QLayout::Fixed ); +@@ -82,38 +99,35 @@ + QHBox* hBox = new QHBox( this ); + hBox->setSpacing( KDialog::spacingHint() ); + QLabel* icon = new QLabel( hBox ); +- icon->setPixmap( QMessageBox::standardIcon(QMessageBox::Warning, kapp->style().guiStyle()) ); ++ icon->setPixmap( QMessageBox::standardIcon(QMessageBox::Warning, kapp->style().guiStyle() ) ); + icon->setAlignment( Qt::AlignCenter ); + icon->setFixedSize( 2*icon->sizeHint() ); + +- int count = 0; +- KHttpCookie* nextCookie = cookie; +- while ( nextCookie ) +- { +- count++; +- nextCookie = nextCookie->next(); +- } ++ int count = cookieList.count(); + + QVBox* vBox = new QVBox( hBox ); +- QString txt = (count == 1) ? i18n("You received a cookie from"): +- i18n("You received %1 cookies from").arg(count); ++ QString txt = i18n("You received a cookie from", ++ "You received %n cookies from", count); + QLabel* lbl = new QLabel( txt, vBox ); + lbl->setAlignment( Qt::AlignCenter ); ++ KHttpCookiePtr cookie = cookieList.first(); + txt = i18n("<b>%1</b>").arg( cookie->host() ); ++ if (cookie->isCrossDomain()) ++ txt += i18n(" <b>[Cross Domain!]</b>"); + lbl = new QLabel( txt, vBox ); + lbl->setAlignment( Qt::AlignCenter ); +- lbl = new QLabel( i18n("Do you want to accept or reject ?"), vBox ); ++ lbl = new QLabel( i18n("Do you want to accept or reject?"), vBox ); + lbl->setAlignment( Qt::AlignCenter ); + vlayout->addWidget( hBox, 0, Qt::AlignLeft ); + + // Cookie Details dialog... +- m_detailView = new KCookieDetail( cookie, count, this ); ++ m_detailView = new KCookieDetail( cookieList, count, this ); + vlayout->addWidget( m_detailView ); + m_showDetails = showDetails; + m_showDetails ? m_detailView->show():m_detailView->hide(); + + // Cookie policy choice... +- m_btnGrp = new QVButtonGroup( i18n("Apply choice to"), this ); ++ m_btnGrp = new QVButtonGroup( i18n("Apply Choice To"), this ); + m_btnGrp->setRadioButtonExclusive( true ); + + txt = (count == 1)? i18n("&Only this cookie") : i18n("&Only these cookies"); +@@ -128,7 +142,7 @@ + #ifndef QT_NO_WHATSTHIS + QWhatsThis::add( rb, i18n("Select this option to accept/reject all cookies from " + "this site. Choosing this option will add a new policy for " +- "the site this cookie originated from. This policy will be " ++ "the site this cookie originated from. This policy will be " + "permanent until you manually change it from the Control Center " + "<em>(see WebBrowsing/Cookies in the Control Center)</em>.") ); + #endif +@@ -146,7 +160,7 @@ + if ( defaultButton > -1 && defaultButton < 3 ) + m_btnGrp->setButton( defaultButton ); + else +- m_btnGrp->setButton( 0 ); ++ m_btnGrp->setButton( 1 ); + + // Accept/Reject buttons + QWidget* bbox = new QWidget( this ); +@@ -154,25 +168,27 @@ + bbLay->setSpacing( KDialog::spacingHint() ); + QPushButton* btn = new QPushButton( i18n("&Accept"), bbox ); + btn->setDefault( true ); ++ btn->setFocus(); + connect( btn, SIGNAL(clicked()), SLOT(accept()) ); + bbLay->addWidget( btn ); + btn = new QPushButton( i18n("&Reject"), bbox ); + connect( btn, SIGNAL(clicked()), SLOT(reject()) ); + bbLay->addWidget( btn ); +- bbLay->addStretch( 1 ); +- m_button = new QPushButton( bbox ); +- m_button->setText( m_showDetails ? i18n("&Details <<"):i18n("&Details >>") ); +- connect( m_button, SIGNAL(clicked()), SLOT(slotCookieDetails()) ); +- bbLay->addWidget( m_button ); ++ bbLay->addStretch( 1 ); + #ifndef QT_NO_ACCEL + QAccel* a = new QAccel( this ); + a->connectItem( a->insertItem(Qt::Key_Escape), btn, SLOT(animateClick()) ); + #endif +- + ++ m_button = new QPushButton( bbox ); ++ m_button->setText( m_showDetails ? i18n("&Details <<"):i18n("&Details >>") ); ++ connect( m_button, SIGNAL(clicked()), SLOT(slotCookieDetails()) ); ++ bbLay->addWidget( m_button ); + #ifndef QT_NO_WHATSTHIS +- QWhatsThis::add( btn, i18n("See or modify the cookie information") ); ++ QWhatsThis::add( m_button, i18n("See or modify the cookie information") ); + #endif ++ ++ + vlayout->addWidget( bbox ); + setFixedSize( sizeHint() ); + } +@@ -203,11 +219,20 @@ + + KCookieAdvice KCookieWin::advice( KCookieJar *cookiejar, KHttpCookie* cookie ) + { ++#ifdef Q_WS_QWS ++ int result = QPEApplication::execDialog(this); ++#else + int result = exec(); ++#endif ++ ++ cookiejar->setShowCookieDetails ( m_showDetails ); ++ + KCookieAdvice advice = (result==QDialog::Accepted) ? KCookieAccept:KCookieReject; +- cookiejar->defaultRadioButton = m_btnGrp->id( m_btnGrp->selected() ); +- cookiejar->showCookieDetails = m_showDetails; +- switch ( cookiejar->defaultRadioButton ) ++ ++ int preferredPolicy = m_btnGrp->id( m_btnGrp->selected() ); ++ cookiejar->setPreferredDefaultPolicy( preferredPolicy ); ++ ++ switch ( preferredPolicy ) + { + case 2: + cookiejar->setGlobalAdvice( advice ); +@@ -222,11 +247,11 @@ + return advice; + } + +-KCookieDetail::KCookieDetail( KHttpCookie* cookie, int cookieCount, ++KCookieDetail::KCookieDetail( KHttpCookieList cookieList, int cookieCount, + QWidget* parent, const char* name ) + :QGroupBox( parent, name ) + { +- setTitle( i18n("Cookie details") ); ++ setTitle( i18n("Cookie Details") ); + QGridLayout* grid = new QGridLayout( this, 9, 2, + KDialog::spacingHint(), + KDialog::marginHint() ); +@@ -237,8 +262,7 @@ + grid->addWidget( label, 1, 0 ); + m_name = new QLineEdit( this ); + m_name->setReadOnly( true ); +- m_name->setText( cookie->name() ); +- m_name->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_name->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_name, 1 ,1 ); + + //Add the value +@@ -246,46 +270,35 @@ + grid->addWidget( label, 2, 0 ); + m_value = new QLineEdit( this ); + m_value->setReadOnly( true ); +- m_value->setText( cookie->value() ); +- m_value->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_value->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_value, 2, 1); + + label = new QLabel( i18n("Expires:"), this ); + grid->addWidget( label, 3, 0 ); + m_expires = new QLineEdit( this ); + m_expires->setReadOnly( true ); +- QDateTime cookiedate; +- cookiedate.setTime_t( cookie->expireDate() ); +- if ( cookie->expireDate() ) +- m_expires->setText( KGlobal::locale()->formatDateTime(cookiedate) ); +- else +- m_expires->setText( i18n("Not specified") ); +- m_expires->setMaximumWidth(fontMetrics().width('W') * 25 ); ++ m_expires->setMaximumWidth(fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_expires, 3, 1); + + label = new QLabel( i18n("Path:"), this ); + grid->addWidget( label, 4, 0 ); + m_path = new QLineEdit( this ); + m_path->setReadOnly( true ); +- m_path->setText( cookie->path() ); +- m_path->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_path->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_path, 4, 1); + + label = new QLabel( i18n("Domain:"), this ); + grid->addWidget( label, 5, 0 ); + m_domain = new QLineEdit( this ); + m_domain->setReadOnly( true ); +- QString val = cookie->domain(); +- m_domain->setText( val.isEmpty()?i18n("Not specified"):val ); +- m_domain->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_domain->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_domain, 5, 1); + +- label = new QLabel( i18n("Is Secure:"), this ); ++ label = new QLabel( i18n("Exposure:"), this ); + grid->addWidget( label, 6, 0 ); + m_secure = new QLineEdit( this ); + m_secure->setReadOnly( true ); +- m_secure->setText( cookie->isSecure() ? i18n("True"):i18n("False") ); +- m_secure->setMaximumWidth( fontMetrics().width('W') * 25 ); ++ m_secure->setMaximumWidth( fontMetrics().maxWidth() * 25 ); + grid->addWidget( m_secure, 6, 1 ); + + if ( cookieCount > 1 ) +@@ -298,8 +311,9 @@ + QToolTip::add( btnNext, i18n("Show details of the next cookie") ); + #endif + } +- m_cookie = cookie; +- m_cookie_orig = cookie; ++ m_cookieList = cookieList; ++ m_cookie = 0; ++ slotNextCookie(); + } + + KCookieDetail::~KCookieDetail() +@@ -308,9 +322,19 @@ + + void KCookieDetail::slotNextCookie() + { +- m_cookie = m_cookie->next(); +- if ( !m_cookie ) +- m_cookie = m_cookie_orig; ++ KHttpCookiePtr cookie = m_cookieList.first(); ++ if (m_cookie) while(cookie) ++ { ++ if (cookie == m_cookie) ++ { ++ cookie = m_cookieList.next(); ++ break; ++ } ++ cookie = m_cookieList.next(); ++ } ++ m_cookie = cookie; ++ if (!m_cookie) ++ m_cookie = m_cookieList.first(); + + if ( m_cookie ) + { +@@ -326,9 +350,47 @@ + if ( m_cookie->expireDate() ) + m_expires->setText( KGlobal::locale()->formatDateTime(cookiedate) ); + else +- m_expires->setText( i18n("Not specified") ); +- m_secure->setText( m_cookie->isSecure() ? i18n("True"):i18n("False") ); ++ m_expires->setText( i18n("End of Session") ); ++ QString sec; ++ if (m_cookie->isSecure()) ++ { ++ if (m_cookie->isHttpOnly()) ++ sec = i18n("Secure servers only"); ++ else ++ sec = i18n("Secure servers, page scripts"); ++ } ++ else ++ { ++ if (m_cookie->isHttpOnly()) ++ sec = i18n("Servers"); ++ else ++ sec = i18n("Servers, page scripts"); ++ } ++ m_secure->setText( sec ); + } + } + ++ ++//////////// ++/// The Adapter ++/// ++/////////// ++KScrolledCookieWin::KScrolledCookieWin( QWidget *parent, KHttpCookieList cookieList, ++ int defaultButton, bool showDetails ) ++ : KDialog( parent, "scrolled_cookiealert", true ) ++{ ++ QVBoxLayout *layout = new QVBoxLayout( this ); ++ QScrollView *view = new QScrollView( this, "cookie_view" ); ++ m_cookieWin = new KCookieWin( view->viewport(), cookieList, defaultButton, ++ showDetails ); ++ view->addChild( m_cookieWin ); ++ layout->addWidget( view ); ++} ++ ++KCookieWin* KScrolledCookieWin::cookieWindow()const ++{ ++ return m_cookieWin; ++} ++ ++ + #include "kcookiewin.moc" +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiewin.h~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookiewin.h +@@ -1,8 +1,8 @@ + /* + This file is part of the KDE File Manager + +- Copyright (C) 1998-2000 Waldo Bastian (bastian@kde.org) +- Copyright (C) 2000 Dawit Alemayehu (adawit@kde.org) ++ Copyright (C) 1998- Waldo Bastian (bastian@kde.org) ++ Copyright (C) 2000- Dawit Alemayehu (adawit@kde.org) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License +@@ -22,7 +22,7 @@ + //---------------------------------------------------------------------------- + // + // KDE File Manager -- HTTP Cookie Dialogs +-// $Id: kcookiewin.h,v 1.9 2001/04/26 23:45:12 waba Exp $ ++// $Id: kcookiewin.h,v 1.12 2002/05/20 05:35:37 adawit Exp $ + + #ifndef _KCOOKIEWIN_H_ + #define _KCOOKIEWIN_H_ +@@ -42,7 +42,7 @@ + Q_OBJECT + + public : +- KCookieDetail( KHttpCookie* cookie, int cookieCount, QWidget *parent=0, ++ KCookieDetail( KHttpCookieList cookieList, int cookieCount, QWidget *parent=0, + const char *name=0 ); + ~KCookieDetail(); + +@@ -54,8 +54,8 @@ + QLineEdit* m_path; + QLineEdit* m_secure; + +- KHttpCookie* m_cookie; +- KHttpCookie* m_cookie_orig; ++ KHttpCookieList m_cookieList; ++ KHttpCookiePtr m_cookie; + + private slots: + void slotNextCookie(); +@@ -66,7 +66,7 @@ + Q_OBJECT + + public : +- KCookieWin( QWidget *parent, KHttpCookie* cookie, int defaultButton=0, ++ KCookieWin( QWidget *parent, KHttpCookieList cookieList, int defaultButton=0, + bool showDetails=false ); + ~KCookieWin(); + +@@ -81,4 +81,21 @@ + private slots: + void slotCookieDetails(); + }; ++ ++/** ++ * A small Scrolled Adapter for KCookieWin ++ * to be used on big screen ++ */ ++class KScrolledCookieWin : public KDialog ++{ ++ Q_OBJECT ++ ++public: ++ KScrolledCookieWin( QWidget *parent, KHttpCookieList cookieList, int defaultButton=0, ++ bool showDetails=false ); ++ KCookieWin* cookieWindow()const; ++ ++private: ++ KCookieWin *m_cookieWin; ++}; + #endif +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver_skel.cpp~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/kcookiejar/kcookieserver_skel.cpp +@@ -6,18 +6,20 @@ + ** + *****************************************************************************/ + +-#include "./kcookieserver.h" ++#include "kcookieserver.h" + + #include <kdatastream.h> + #include <qasciidict.h> + + +-static const int KCookieServer_fhash = 17; +-static const char* const KCookieServer_ftable[16][3] = { ++static const int KCookieServer_fhash = 19; ++static const char* const KCookieServer_ftable[18][3] = { + { "QString", "findCookies(QString)", "findCookies(QString)" }, ++ { "QString", "findCookies(QString,long int)", "findCookies(QString,long int)" }, + { "QStringList", "findDomains()", "findDomains()" }, + { "QStringList", "findCookies(QValueList<int>,QString,QString,QString,QString)", "findCookies(QValueList<int>,QString,QString,QString,QString)" }, + { "QString", "findDOMCookies(QString)", "findDOMCookies(QString)" }, ++ { "QString", "findDOMCookies(QString,long int)", "findDOMCookies(QString,long int)" }, + { "void", "addCookies(QString,QCString,long int)", "addCookies(QString,QCString,long int)" }, + { "void", "deleteCookie(QString,QString,QString,QString)", "deleteCookie(QString,QString,QString,QString)" }, + { "void", "deleteCookiesFromDomain(QString)", "deleteCookiesFromDomain(QString)" }, +@@ -50,12 +52,22 @@ + QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << findCookies(arg0 ); + } break; +- case 1: { // QStringList findDomains() ++ case 1: { // QString findCookies(QString,long int) ++ QString arg0; ++ long int arg1; ++ QDataStream arg( data, IO_ReadOnly ); ++ arg >> arg0; ++ arg >> arg1; + replyType = KCookieServer_ftable[1][0]; + QDataStream _replyStream( replyData, IO_WriteOnly ); ++ _replyStream << findCookies(arg0, arg1 ); ++ } break; ++ case 2: { // QStringList findDomains() ++ replyType = KCookieServer_ftable[2][0]; ++ QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << findDomains( ); + } break; +- case 2: { // QStringList findCookies(QValueList<int>,QString,QString,QString,QString) ++ case 3: { // QStringList findCookies(QValueList<int>,QString,QString,QString,QString) + QValueList<int> arg0; + QString arg1; + QString arg2; +@@ -67,19 +79,29 @@ + arg >> arg2; + arg >> arg3; + arg >> arg4; +- replyType = KCookieServer_ftable[2][0]; ++ replyType = KCookieServer_ftable[3][0]; + QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << findCookies(arg0, arg1, arg2, arg3, arg4 ); + } break; +- case 3: { // QString findDOMCookies(QString) ++ case 4: { // QString findDOMCookies(QString) + QString arg0; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; +- replyType = KCookieServer_ftable[3][0]; ++ replyType = KCookieServer_ftable[4][0]; + QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << findDOMCookies(arg0 ); + } break; +- case 4: { // void addCookies(QString,QCString,long int) ++ case 5: { // QString findDOMCookies(QString,long int) ++ QString arg0; ++ long int arg1; ++ QDataStream arg( data, IO_ReadOnly ); ++ arg >> arg0; ++ arg >> arg1; ++ replyType = KCookieServer_ftable[5][0]; ++ QDataStream _replyStream( replyData, IO_WriteOnly ); ++ _replyStream << findDOMCookies(arg0, arg1 ); ++ } break; ++ case 6: { // void addCookies(QString,QCString,long int) + QString arg0; + QCString arg1; + long int arg2; +@@ -87,10 +109,10 @@ + arg >> arg0; + arg >> arg1; + arg >> arg2; +- replyType = KCookieServer_ftable[4][0]; ++ replyType = KCookieServer_ftable[6][0]; + addCookies(arg0, arg1, arg2 ); + } break; +- case 5: { // void deleteCookie(QString,QString,QString,QString) ++ case 7: { // void deleteCookie(QString,QString,QString,QString) + QString arg0; + QString arg1; + QString arg2; +@@ -100,37 +122,37 @@ + arg >> arg1; + arg >> arg2; + arg >> arg3; +- replyType = KCookieServer_ftable[5][0]; ++ replyType = KCookieServer_ftable[7][0]; + deleteCookie(arg0, arg1, arg2, arg3 ); + } break; +- case 6: { // void deleteCookiesFromDomain(QString) ++ case 8: { // void deleteCookiesFromDomain(QString) + QString arg0; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; +- replyType = KCookieServer_ftable[6][0]; ++ replyType = KCookieServer_ftable[8][0]; + deleteCookiesFromDomain(arg0 ); + } break; +- case 7: { // void deleteSessionCookies(long int) ++ case 9: { // void deleteSessionCookies(long int) + long int arg0; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; +- replyType = KCookieServer_ftable[7][0]; ++ replyType = KCookieServer_ftable[9][0]; + deleteSessionCookies(arg0 ); + } break; +- case 8: { // void deleteSessionCookiesFor(QString,long int) ++ case 10: { // void deleteSessionCookiesFor(QString,long int) + QString arg0; + long int arg1; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; + arg >> arg1; +- replyType = KCookieServer_ftable[8][0]; ++ replyType = KCookieServer_ftable[10][0]; + deleteSessionCookiesFor(arg0, arg1 ); + } break; +- case 9: { // void deleteAllCookies() +- replyType = KCookieServer_ftable[9][0]; ++ case 11: { // void deleteAllCookies() ++ replyType = KCookieServer_ftable[11][0]; + deleteAllCookies( ); + } break; +- case 10: { // void addDOMCookies(QString,QCString,long int) ++ case 12: { // void addDOMCookies(QString,QCString,long int) + QString arg0; + QCString arg1; + long int arg2; +@@ -138,38 +160,38 @@ + arg >> arg0; + arg >> arg1; + arg >> arg2; +- replyType = KCookieServer_ftable[10][0]; ++ replyType = KCookieServer_ftable[12][0]; + addDOMCookies(arg0, arg1, arg2 ); + } break; +- case 11: { // void setDomainAdvice(QString,QString) ++ case 13: { // void setDomainAdvice(QString,QString) + QString arg0; + QString arg1; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; + arg >> arg1; +- replyType = KCookieServer_ftable[11][0]; ++ replyType = KCookieServer_ftable[13][0]; + setDomainAdvice(arg0, arg1 ); + } break; +- case 12: { // QString getDomainAdvice(QString) ++ case 14: { // QString getDomainAdvice(QString) + QString arg0; + QDataStream arg( data, IO_ReadOnly ); + arg >> arg0; +- replyType = KCookieServer_ftable[12][0]; ++ replyType = KCookieServer_ftable[14][0]; + QDataStream _replyStream( replyData, IO_WriteOnly ); + _replyStream << getDomainAdvice(arg0 ); + } break; +- case 13: { // void reloadPolicy() +- replyType = KCookieServer_ftable[13][0]; ++ case 15: { // void reloadPolicy() ++ replyType = KCookieServer_ftable[15][0]; + reloadPolicy( ); + } break; +- case 14: { // void shutdown() +- replyType = KCookieServer_ftable[14][0]; ++ case 16: { // void shutdown() ++ replyType = KCookieServer_ftable[16][0]; + shutdown( ); + } break; + default: + return KUniqueApplication::process( fun, data, replyType, replyData ); + } +- return TRUE; ++ return true; + } + + QCStringList KCookieServer::interfaces() +--- konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/http.cc~kcookiejar-merge.patch ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kio/http/http.cc +@@ -200,9 +200,9 @@ + kdDebug(7103) << "(" << getpid() << ") Proxy URL is now: " << m_proxyURL.url() << endl; + } + +- m_bUseCookiejar = config()->readBoolEntry("Cookies"); +- m_bUseCache = config()->readBoolEntry("UseCache"); +- m_strCacheDir = config()->readEntry("CacheDir"); ++ m_bUseCookiejar = config()->readBoolEntry("Cookies", true); ++ m_bUseCache = config()->readBoolEntry("UseCache", true); ++ m_strCacheDir = config()->readEntry("CacheDir", "/tmp/"); + m_maxCacheAge = config()->readNumEntry("MaxCacheAge"); + m_request.window = config()->readEntry("window-id"); + diff --git a/packages/konqueror/konqueror-embedded-20030705/konq-embedrc b/packages/konqueror/konqueror-embedded-20030705/konq-embedrc index e69de29bb2..5c476b4b6e 100644 --- a/packages/konqueror/konqueror-embedded-20030705/konq-embedrc +++ b/packages/konqueror/konqueror-embedded-20030705/konq-embedrc @@ -0,0 +1,20 @@ +[External Protocols] +mailto=opiemail +aj=@http://www.ask.com/main/askJeeves.asp?ask= +av=@http://www.altavista.com/sites/search/web?q= +dj=@http://www.deja.com/dnquery.xp?QRY= +ex=@http://search.excite.com/search.gw?search= +gg=@http://www.google.com/search?q= +hb=@http://hotbot.lycos.com/?MT= +ly=@http://search.lycos.com/main/?query= +ya=@http://search.yahoo.com/bin/search?p= + +[Local Protocols] + +[http Settings] +UseCache=true +CacheDir=/tmp + +[HTML Settings] +FixedFontSize=0 + diff --git a/packages/konqueror/konqueror-embedded-20030705/malformed.patch b/packages/konqueror/konqueror-embedded-20030705/malformed.patch index e69de29bb2..542d2079d3 100644 --- a/packages/konqueror/konqueror-embedded-20030705/malformed.patch +++ b/packages/konqueror/konqueror-embedded-20030705/malformed.patch @@ -0,0 +1,19 @@ +diff -uNr konq.orig/konq-embed/src/mainwindowbase.cc konqueror-embedded-snapshot-20030705/konq-embed/src/mainwindowbase.cc +--- konq.orig/konq-embed/src/mainwindowbase.cc 2005-01-26 14:34:06.335579881 +0100 ++++ konqueror-embedded-snapshot-20030705/konq-embed/src/mainwindowbase.cc 2005-01-26 14:35:55.839632151 +0100 +@@ -357,12 +357,12 @@ + + if ( u.isMalformed() ) + { +- if ( QRegExp( "^www" ).match( text ) == 0 ) +- u = KURL( text.prepend( "http://" ) ); + #if defined(ENABLE_FTP) +- else if ( QRegExp( "^ftp" ).match( text ) == 0 ) ++ if ( QRegExp( "^ftp" ).match( text ) == 0 ) + u = KURL( text.prepend( "ftp://" ) ); ++ else + #endif ++ u = KURL( text.prepend( "http://" ) ); + } + + if ( !u.isMalformed() ) diff --git a/packages/konqueror/konqueror-embedded-20030705/opie1.patch b/packages/konqueror/konqueror-embedded-20030705/opie1.patch index e69de29bb2..de8943a74c 100644 --- a/packages/konqueror/konqueror-embedded-20030705/opie1.patch +++ b/packages/konqueror/konqueror-embedded-20030705/opie1.patch @@ -0,0 +1,34 @@ +diff -urN konqueror-old/configure konqueror-embedded-snapshot-20030705/configure +--- konqueror-old/configure 2003-08-03 17:49:31.000000000 -0700 ++++ konqueror-embedded-snapshot-20030705/configure 2003-08-03 17:50:02.000000000 -0700 +@@ -24232,14 +24232,14 @@ + if test "x$want_qpe" = "xyes"; then + + +- if test -z "1.5.0"; then ++ if test -z "1.0.0"; then + qtopia_minver_maj=1 + qtopia_minver_min=5 + qtopia_minver_pat=0 + else +- qtopia_minver_maj=`echo "1.5.0" | sed -e "s/^\(.*\)\..*\..*$/\1/"` +- qtopia_minver_min=`echo "1.5.0" | sed -e "s/^.*\.\(.*\)\..*$/\1/"` +- qtopia_minver_pat=`echo "1.5.0" | sed -e "s/^.*\..*\.\(.*\)$/\1/"` ++ qtopia_minver_maj=`echo "1.0.0" | sed -e "s/^\(.*\)\..*\..*$/\1/"` ++ qtopia_minver_min=`echo "1.0.0" | sed -e "s/^.*\.\(.*\)\..*$/\1/"` ++ qtopia_minver_pat=`echo "1.0.0" | sed -e "s/^.*\..*\.\(.*\)$/\1/"` + fi + + qtopia_minver="$qtopia_minver_maj$qtopia_minver_min$qtopia_minver_pat" +diff -urN konqueror-old/configure.in konqueror-embedded-snapshot-20030705/configure.in +--- konqueror-old/configure.in 2003-08-03 17:49:31.000000000 -0700 ++++ konqueror-embedded-snapshot-20030705/configure.in 2003-08-03 17:49:47.000000000 -0700 +@@ -53,7 +53,7 @@ + want_qpe=$enableval,want_qpe=no) + + if test "x$want_qpe" = "xyes"; then +- AC_PATH_QTOPIA(1.5.0) ++ AC_PATH_QTOPIA(1.0.0) + dnl hack + CXXFLAGS="$CXXFLAGS -D_QT_QPE_" + fi diff --git a/packages/konqueror/konqueror-embedded-20030705/packing.patch b/packages/konqueror/konqueror-embedded-20030705/packing.patch index e69de29bb2..37a3754854 100644 --- a/packages/konqueror/konqueror-embedded-20030705/packing.patch +++ b/packages/konqueror/konqueror-embedded-20030705/packing.patch @@ -0,0 +1,17 @@ +diff -ur konqe.old/konq-embed/kdesrc/kjs/ustring.h konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kjs/ustring.h +--- konqe.old/konq-embed/kdesrc/kjs/ustring.h 2001-07-28 17:32:15.000000000 +0200 ++++ konqueror-embedded-snapshot-20030705/konq-embed/kdesrc/kjs/ustring.h 2004-08-22 21:30:04.000000000 +0200 +@@ -154,11 +154,11 @@ + /** + * @return Lower byte. + */ +- unsigned char& low() const { return ref().lo; } ++ unsigned char& low() const { return *(&ref().lo); } + /** + * @return Higher byte. + */ +- unsigned char& high() const { return ref().hi; } ++ unsigned char& high() const { return *(&ref().hi); } + /** + * @return Character converted to lower case. + */ diff --git a/packages/konqueror/konqueror-embedded-20030705/useragent.patch b/packages/konqueror/konqueror-embedded-20030705/useragent.patch index e69de29bb2..c2d9a10c44 100644 --- a/packages/konqueror/konqueror-embedded-20030705/useragent.patch +++ b/packages/konqueror/konqueror-embedded-20030705/useragent.patch @@ -0,0 +1,27 @@ +--- konqueror-embedded-snapshot-20030705/konq-embed/dropin/kio/slavebase.cpp.old 2002-11-17 15:55:22.000000000 +0100 ++++ konqueror-embedded-snapshot-20030705/konq-embed/dropin/kio/slavebase.cpp 2004-08-23 20:47:06.000000000 +0200 +@@ -398,8 +398,8 @@ + + if ( m_config.find( key ) != m_config.end() ) + return true; +- +- return false; ++ ++ return key == QString::fromLatin1("UserAgent"); + } + + QString SlaveBase::metaData( const QString &key ) const +@@ -410,7 +410,12 @@ + { + it = m_config.find( key ); + +- if ( it == m_config.end() ) ++ /* ++ * special case in hasMetaData and metaData ++ */ ++ if ( it == m_config.end() && key == QString::fromLatin1("UserAgent") ) ++ return KProtocolManager::defaultUserAgent("me"); ++ else + return QString::null; + } + diff --git a/packages/konqueror/konqueror-embedded-20030705/vit.patch b/packages/konqueror/konqueror-embedded-20030705/vit.patch index e69de29bb2..b45e9e6ed2 100644 --- a/packages/konqueror/konqueror-embedded-20030705/vit.patch +++ b/packages/konqueror/konqueror-embedded-20030705/vit.patch @@ -0,0 +1,18 @@ +--- konqueror-embedded-snapshot-20030705/konq-embed/src/main.cc~ 2003-07-03 21:37:09.000000000 +0400 ++++ konqueror-embedded-snapshot-20030705/konq-embed/src/main.cc 2005-02-21 23:02:24.000000000 +0300 +@@ -369,6 +369,7 @@ + toplevel->show(); + + app.setMainWidget( toplevel ); ++#endif + + for ( int i = 1; i < argc; i++ ) + { +@@ -382,7 +383,6 @@ + } + } + } +-#endif + + if ( !openedMainWindow ) + openedMainWindow = toplevel->goSpecialURL( "init" ); |