path: root/packages/konqueror/konqueror-embedded-20030705/kcookiejar-merge.patch

#
# 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");