Renaming of files in preparation for code style tools.

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 3a75bdfe83b71ef1dbc2fbf52f2d18b8174e22e5)

1 files changed, 2746 insertions, 0 deletions

diff --git a/tdeioslave/imap4/imap4.cpp b/tdeioslave/imap4/imap4.cpp
new file mode 100644
index 000000000..280cbde70
--- /dev/null
+++ b/tdeioslave/imap4/imap4.cpp
@@ -0,0 +1,2746 @@
+/**********************************************************************
+ *
+ *   imap4.cpp  - IMAP4rev1 KIOSlave
+ *   Copyright (C) 2001-2002  Michael Haeckel <haeckel@kde.org>
+ *   Copyright (C) 1999  John Corey <jcorey@fruity.ath.cx>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ *   Send comments and bug fixes to jcorey@fruity.ath.cx
+ *
+ *********************************************************************/
+
+/**
+ * @class IMAP4Protocol
+ * @note References:
+ *   - RFC 2060 - Internet Message Access Protocol - Version 4rev1 - December 1996
+ *   - RFC 2192 - IMAP URL Scheme - September 1997
+ *   - RFC 1731 - IMAP Authentication Mechanisms - December 1994
+ *              (Discusses KERBEROSv4, GSSAPI, and S/Key)
+ *   - RFC 2195 - IMAP/POP AUTHorize Extension for Simple Challenge/Response
+ *            - September 1997 (CRAM-MD5 authentication method)
+ *   - RFC 2104 - HMAC: Keyed-Hashing for Message Authentication - February 1997
+ *   - RFC 2086 - IMAP4 ACL extension - January 1997
+ *   - http://www.ietf.org/internet-drafts/draft-daboo-imap-annotatemore-05.txt
+ *          IMAP ANNOTATEMORE draft - April 2004.
+ *
+ *
+ * Supported URLs:
+ * \verbatim
+imap://server/
+imap://user:pass@server/
+imap://user;AUTH=method:pass@server/
+imap://server/folder/
+ * \endverbatim
+ * These URLs cause the following actions (in order):
+ *   - Prompt for user/pass, list all folders in home directory
+ *   - Uses LOGIN to log in
+ *   - Uses AUTHENTICATE to log in
+ *   - List messages in folder
+ *
+ * @note API notes:
+ *   Not receiving the required write access for a folder means
+ *       ERR_CANNOT_OPEN_FOR_WRITING.
+ *  ERR_DOES_NOT_EXIST is reserved for folders.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "imap4.h"
+
+#include "rfcdecoder.h"
+
+#include <sys/stat.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <errno.h>
+
+#ifdef HAVE_LIBSASL2
+extern "C" {
+#include <sasl/sasl.h>
+}
+#endif
+
+#include <tqbuffer.h>
+#include <tqdatetime.h>
+#include <tqregexp.h>
+#include <tdeprotocolmanager.h>
+#include <tdemessagebox.h>
+#include <kdebug.h>
+#include <tdeio/connection.h>
+#include <tdeio/slaveinterface.h>
+#include <tdeio/passdlg.h>
+#include <tdelocale.h>
+#include <kmimetype.h>
+#include <kmdcodec.h>
+
+#include "tdepimmacros.h"
+
+#define IMAP_PROTOCOL "imap"
+#define IMAP_SSL_PROTOCOL "imaps"
+const int ImapPort = 143;
+const int ImapsPort = 993;
+
+using namespace TDEIO;
+
+extern "C"
+{
+  void sigalrm_handler (int);
+  KDE_EXPORT int kdemain (int argc, char **argv);
+}
+
+int
+kdemain (int argc, char **argv)
+{
+  kdDebug(7116) << "IMAP4::kdemain" << endl;
+
+  TDEInstance instance ("tdeio_imap4");
+  if (argc != 4)
+  {
+    fprintf(stderr, "Usage: tdeio_imap4 protocol domain-socket1 domain-socket2\n");
+    ::exit (-1);
+  }
+
+#ifdef HAVE_LIBSASL2
+  if ( sasl_client_init( NULL ) != SASL_OK ) {
+    fprintf(stderr, "SASL library initialization failed!\n");
+    ::exit (-1);
+  }
+#endif
+
+  //set debug handler
+
+  IMAP4Protocol *slave;
+  if (strcasecmp (argv[1], IMAP_SSL_PROTOCOL) == 0)
+    slave = new IMAP4Protocol (argv[2], argv[3], true);
+  else if (strcasecmp (argv[1], IMAP_PROTOCOL) == 0)
+    slave = new IMAP4Protocol (argv[2], argv[3], false);
+  else
+    abort ();
+  slave->dispatchLoop ();
+  delete slave;
+
+#ifdef HAVE_LIBSASL2
+  sasl_done();
+#endif
+
+  return 0;
+}
+
+void
+sigchld_handler (int signo)
+{
+  // A signal handler that calls for example waitpid has to save errno
+  // before and restore it afterwards.
+  // (cf. https://www.securecoding.cert.org/confluence/display/cplusplus/ERR32-CPP.+Do+not+rely+on+indeterminate+values+of+errno)
+  const int save_errno = errno;
+  int pid, status;
+
+  while (signo == SIGCHLD)
+  {
+    pid = waitpid (-1, &status, WNOHANG);
+    if (pid <= 0)
+    {
+      // Reinstall signal handler, since Linux resets to default after
+      // the signal occurred ( BSD handles it different, but it should do
+      // no harm ).
+      signal (SIGCHLD, sigchld_handler);
+      break;
+    }
+  }
+
+  errno = save_errno;
+}
+
+IMAP4Protocol::IMAP4Protocol (const TQCString & pool, const TQCString & app, bool isSSL):TCPSlaveBase ((isSSL ? 993 : 143),
+        (isSSL ? IMAP_SSL_PROTOCOL : IMAP_PROTOCOL), pool,
+              app, isSSL), imapParser (), mimeIO (), outputBuffer(outputCache)
+{
+  outputBufferIndex = 0;
+  mySSL = isSSL;
+  readBuffer[0] = 0x00;
+  relayEnabled = false;
+  readBufferLen = 0;
+  cacheOutput = false;
+  decodeContent = false;
+  mTimeOfLastNoop = TQDateTime();
+}
+
+IMAP4Protocol::~IMAP4Protocol ()
+{
+  closeDescriptor();
+  kdDebug(7116) << "IMAP4: Finishing" << endl;
+}
+
+void
+IMAP4Protocol::get (const KURL & _url)
+{
+  if (!makeLogin()) return;
+  kdDebug(7116) << "IMAP4::get -  " << _url.prettyURL() << endl;
+  TQString aBox, aSequence, aType, aSection, aValidity, aDelimiter, aInfo;
+  enum IMAP_TYPE aEnum =
+    parseURL (_url, aBox, aSection, aType, aSequence, aValidity, aDelimiter, aInfo);
+  if (aEnum != ITYPE_ATTACH)
+    mimeType (getMimeType(aEnum));
+  if (aInfo == "DECODE")
+    decodeContent = true;
+
+  if (aSequence == "0:0" && getState() == ISTATE_SELECT)
+  {
+    imapCommand *cmd = doCommand (imapCommand::clientNoop());
+    completeQueue.removeRef(cmd);
+  }
+
+  if (aSequence.isEmpty ())
+  {
+    aSequence = "1:*";
+  }
+
+  mProcessedSize = 0;
+  imapCommand *cmd = NULL;
+  if (!assureBox (aBox, true)) return;
+
+#ifdef USE_VALIDITY
+  if (selectInfo.uidValidityAvailable () && !aValidity.isEmpty ()
+      && selectInfo.uidValidity () != aValidity.toULong ())
+  {
+    // this url is stale
+    error (ERR_COULD_NOT_READ, _url.prettyURL());
+    return;
+  }
+  else
+#endif
+  {
+    // The "section" specified by the application can be:
+    // * empty (which means body, size and flags)
+    // * a known keyword, like STRUCTURE, ENVELOPE, HEADER, BODY.PEEK[...]
+    //        (in which case the slave has some logic to add the necessary items)
+    // * Otherwise, it specifies the exact data items to request. In this case, all
+    //        the logic is in the app.
+
+    TQString aUpper = aSection.upper();
+    if (aUpper.find ("STRUCTURE") != -1)
+    {
+      aSection = "BODYSTRUCTURE";
+    }
+    else if (aUpper.find ("ENVELOPE") != -1)
+    {
+      aSection = "UID RFC822.SIZE FLAGS ENVELOPE";
+      if (hasCapability("IMAP4rev1")) {
+        aSection += " BODY.PEEK[HEADER.FIELDS (REFERENCES)]";
+      } else {
+        // imap4 does not know HEADER.FIELDS
+        aSection += " RFC822.HEADER.LINES (REFERENCES)";
+      }
+    }
+    else if (aUpper == "HEADER")
+    {
+      aSection = "UID RFC822.HEADER RFC822.SIZE FLAGS";
+    }
+    else if (aUpper.find ("BODY.PEEK[") != -1)
+    {
+      if (aUpper.find ("BODY.PEEK[]") != -1)
+      {
+        if (!hasCapability("IMAP4rev1")) // imap4 does not know BODY.PEEK[]
+          aSection.replace("BODY.PEEK[]", "RFC822.PEEK");
+      }
+      aSection.prepend("UID RFC822.SIZE FLAGS ");
+    }
+    else if (aSection.isEmpty())
+    {
+      aSection = "UID BODY[] RFC822.SIZE FLAGS";
+    }
+    if (aEnum == ITYPE_BOX || aEnum == ITYPE_DIR_AND_BOX)
+    {
+      // write the digest header
+      cacheOutput = true;
+      outputLine
+        ("Content-Type: multipart/digest; boundary=\"IMAPDIGEST\"\r\n", 55);
+      if (selectInfo.recentAvailable ())
+        outputLineStr ("X-Recent: " +
+                       TQString::number(selectInfo.recent ()) + "\r\n");
+      if (selectInfo.countAvailable ())
+        outputLineStr ("X-Count: " + TQString::number(selectInfo.count ()) +
+                       "\r\n");
+      if (selectInfo.unseenAvailable ())
+        outputLineStr ("X-Unseen: " +
+                       TQString::number(selectInfo.unseen ()) + "\r\n");
+      if (selectInfo.uidValidityAvailable ())
+        outputLineStr ("X-uidValidity: " +
+                       TQString::number(selectInfo.uidValidity ()) +
+                       "\r\n");
+      if (selectInfo.uidNextAvailable ())
+        outputLineStr ("X-UidNext: " +
+                       TQString::number(selectInfo.uidNext ()) + "\r\n");
+      if (selectInfo.flagsAvailable ())
+        outputLineStr ("X-Flags: " + TQString::number(selectInfo.flags ()) +
+                       "\r\n");
+      if (selectInfo.permanentFlagsAvailable ())
+        outputLineStr ("X-PermanentFlags: " +
+                       TQString::number(selectInfo.permanentFlags ()) + "\r\n");
+      if (selectInfo.readWriteAvailable ()) {
+        if (selectInfo.readWrite()) {
+          outputLine ("X-Access: Read/Write\r\n", 22);
+        } else {
+          outputLine ("X-Access: Read only\r\n", 21);
+        }
+      }
+      outputLine ("\r\n", 2);
+      flushOutput(TQString());
+      cacheOutput = false;
+    }
+
+    if (aEnum == ITYPE_MSG || (aEnum == ITYPE_ATTACH && !decodeContent))
+      relayEnabled = true; // normal mode, relay data
+
+    if (aSequence != "0:0")
+    {
+      TQString contentEncoding;
+      if (aEnum == ITYPE_ATTACH && decodeContent)
+      {
+        // get the MIME header and fill getLastHandled()
+        TQString mySection = aSection;
+        mySection.replace("]", ".MIME]");
+        cmd = sendCommand (imapCommand::clientFetch (aSequence, mySection));
+        do
+        {
+          while (!parseLoop ()) ;
+        }
+        while (!cmd->isComplete ());
+        completeQueue.removeRef (cmd);
+        // get the content encoding now because getLastHandled will be cleared
+        if (getLastHandled() && getLastHandled()->getHeader())
+          contentEncoding = getLastHandled()->getHeader()->getEncoding();
+
+        // from here on collect the data
+        // it is send to the client in flushOutput in one go
+        // needed to decode the content
+        cacheOutput = true;
+      }
+
+      cmd = sendCommand (imapCommand::clientFetch (aSequence, aSection));
+      int res;
+      aUpper = aSection.upper();
+      do
+      {
+        while (!(res = parseLoop())) ;
+        if (res == -1) break;
+
+        mailHeader *lastone = 0;
+        imapCache *cache = getLastHandled ();
+        if (cache)
+          lastone = cache->getHeader ();
+
+        if (cmd && !cmd->isComplete ())
+        {
+          if ((aUpper.find ("BODYSTRUCTURE") != -1)
+                    || (aUpper.find ("FLAGS") != -1)
+                    || (aUpper.find ("UID") != -1)
+                    || (aUpper.find ("ENVELOPE") != -1)
+                    || (aUpper.find ("BODY.PEEK[0]") != -1
+                        && (aEnum == ITYPE_BOX || aEnum == ITYPE_DIR_AND_BOX)))
+          {
+            if (aEnum == ITYPE_BOX || aEnum == ITYPE_DIR_AND_BOX)
+            {
+              // write the mime header (default is here message/rfc822)
+              outputLine ("--IMAPDIGEST\r\n", 14);
+              cacheOutput = true;
+              if (cache && cache->getUid () != 0)
+                outputLineStr ("X-UID: " +
+                               TQString::number(cache->getUid ()) + "\r\n");
+              if (cache && cache->getSize () != 0)
+                outputLineStr ("X-Length: " +
+                               TQString::number(cache->getSize ()) + "\r\n");
+              if (cache && !cache->getDate ().isEmpty())
+                outputLineStr ("X-Date: " + cache->getDate () + "\r\n");
+              if (cache && cache->getFlags () != 0)
+                outputLineStr ("X-Flags: " +
+                               TQString::number(cache->getFlags ()) + "\r\n");
+            } else cacheOutput = true;
+            if ( lastone && !decodeContent )
+              lastone->outputPart (*this);
+            cacheOutput = false;
+            flushOutput(contentEncoding);
+          }
+        } // if not complete
+      }
+      while (cmd && !cmd->isComplete ());
+      if (aEnum == ITYPE_BOX || aEnum == ITYPE_DIR_AND_BOX)
+      {
+        // write the end boundary
+        outputLine ("--IMAPDIGEST--\r\n", 16);
+      }
+
+      completeQueue.removeRef (cmd);
+    }
+  }
+
+  // just to keep everybody happy when no data arrived
+  data (TQByteArray ());
+
+  finished ();
+  relayEnabled = false;
+  cacheOutput = false;
+  kdDebug(7116) << "IMAP4::get -  finished" << endl;
+}
+
+void
+IMAP4Protocol::listDir (const KURL & _url)
+{
+  kdDebug(7116) << " IMAP4::listDir - " << _url.prettyURL() << endl;
+
+  if (_url.path().isEmpty())
+  {
+    KURL url = _url;
+    url.setPath("/");
+    redirection( url );
+    finished();
+    return;
+  }
+
+  TQString myBox, mySequence, myLType, mySection, myValidity, myDelimiter, myInfo;
+  // parseURL with caching
+  enum IMAP_TYPE myType =
+    parseURL (_url, myBox, mySection, myLType, mySequence, myValidity,
+      myDelimiter, myInfo, true);
+
+  if (!makeLogin()) return;
+
+  if (myType == ITYPE_DIR || myType == ITYPE_DIR_AND_BOX)
+  {
+    TQString listStr = myBox;
+    imapCommand *cmd;
+
+    if (!listStr.isEmpty () && !listStr.endsWith(myDelimiter) &&
+        mySection != "FOLDERONLY")
+      listStr += myDelimiter;
+
+    if (mySection.isEmpty())
+    {
+      listStr += "%";
+    } else if (mySection == "COMPLETE") {
+      listStr += "*";
+    }
+    kdDebug(7116) << "IMAP4Protocol::listDir - listStr=" << listStr << endl;
+    cmd =
+      doCommand (imapCommand::clientList ("", listStr,
+            (myLType == "LSUB" || myLType == "LSUBNOCHECK")));
+    if (cmd->result () == "OK")
+    {
+      TQString mailboxName;
+      UDSEntry entry;
+      UDSAtom atom;
+      KURL aURL = _url;
+      if (aURL.path().find(';') != -1)
+        aURL.setPath(aURL.path().left(aURL.path().find(';')));
+
+      kdDebug(7116) << "IMAP4Protocol::listDir - got " << listResponses.count () << endl;
+
+      if (myLType == "LSUB")
+      {
+        // fire the same command as LIST to check if the box really exists
+        TQValueList<imapList> listResponsesSave = listResponses;
+        doCommand (imapCommand::clientList ("", listStr, false));
+        for (TQValueListIterator < imapList > it = listResponsesSave.begin ();
+            it != listResponsesSave.end (); ++it)
+        {
+          bool boxOk = false;
+          for (TQValueListIterator < imapList > it2 = listResponses.begin ();
+              it2 != listResponses.end (); ++it2)
+          {
+            if ((*it2).name() == (*it).name())
+            {
+              boxOk = true;
+              // copy the flags from the LIST-command
+              (*it) = (*it2);
+              break;
+            }
+          }
+          if (boxOk)
+            doListEntry (aURL, myBox, (*it), (mySection != "FOLDERONLY"));
+          else // this folder is dead
+            kdDebug(7116) << "IMAP4Protocol::listDir - suppress " << (*it).name() << endl;
+        }
+        listResponses = listResponsesSave;
+      }
+      else // LIST or LSUBNOCHECK
+      {
+        for (TQValueListIterator < imapList > it = listResponses.begin ();
+            it != listResponses.end (); ++it)
+        {
+          doListEntry (aURL, myBox, (*it), (mySection != "FOLDERONLY"));
+        }
+      }
+      entry.clear ();
+      listEntry (entry, true);
+    }
+    else
+    {
+      error (ERR_CANNOT_ENTER_DIRECTORY, _url.prettyURL());
+      completeQueue.removeRef (cmd);
+      return;
+    }
+    completeQueue.removeRef (cmd);
+  }
+  if ((myType == ITYPE_BOX || myType == ITYPE_DIR_AND_BOX)
+      && myLType != "LIST" && myLType != "LSUB" && myLType != "LSUBNOCHECK")
+  {
+    KURL aURL = _url;
+    aURL.setQuery (TQString());
+    const TQString encodedUrl = aURL.url(0, 106); // utf-8
+
+    if (!_url.query ().isEmpty ())
+    {
+      TQString query = KURL::decode_string (_url.query ());
+      query = query.right (query.length () - 1);
+      if (!query.isEmpty())
+      {
+        imapCommand *cmd = NULL;
+
+        if (!assureBox (myBox, true)) return;
+
+        if (!selectInfo.countAvailable() || selectInfo.count())
+        {
+          cmd = doCommand (imapCommand::clientSearch (query));
+          if (cmd->result() != "OK")
+          {
+            error(ERR_UNSUPPORTED_ACTION, _url.prettyURL());
+            completeQueue.removeRef (cmd);
+            return;
+          }
+          completeQueue.removeRef (cmd);
+
+          TQStringList list = getResults ();
+          int stretch = 0;
+
+          if (selectInfo.uidNextAvailable ())
+            stretch = TQString::number(selectInfo.uidNext ()).length ();
+          UDSEntry entry;
+          imapCache fake;
+
+          for (TQStringList::ConstIterator it = list.begin(); it != list.end();
+               ++it)
+          {
+            fake.setUid((*it).toULong());
+            doListEntry (encodedUrl, stretch, &fake);
+          }
+          entry.clear ();
+          listEntry (entry, true);
+        }
+      }
+    }
+    else
+    {
+      if (!assureBox (myBox, true)) return;
+
+      kdDebug(7116) << "IMAP4: select returned:" << endl;
+      if (selectInfo.recentAvailable ())
+        kdDebug(7116) << "Recent: " << selectInfo.recent () << "d" << endl;
+      if (selectInfo.countAvailable ())
+        kdDebug(7116) << "Count: " << selectInfo.count () << "d" << endl;
+      if (selectInfo.unseenAvailable ())
+        kdDebug(7116) << "Unseen: " << selectInfo.unseen () << "d" << endl;
+      if (selectInfo.uidValidityAvailable ())
+        kdDebug(7116) << "uidValidity: " << selectInfo.uidValidity () << "d" << endl;
+      if (selectInfo.flagsAvailable ())
+        kdDebug(7116) << "Flags: " << selectInfo.flags () << "d" << endl;
+      if (selectInfo.permanentFlagsAvailable ())
+        kdDebug(7116) << "PermanentFlags: " << selectInfo.permanentFlags () << "d" << endl;
+      if (selectInfo.readWriteAvailable ())
+        kdDebug(7116) << "Access: " << (selectInfo.readWrite ()? "Read/Write" : "Read only") << endl;
+
+#ifdef USE_VALIDITY
+      if (selectInfo.uidValidityAvailable ()
+          && selectInfo.uidValidity () != myValidity.toULong ())
+      {
+        //redirect
+        KURL newUrl = _url;
+
+        newUrl.setPath ("/" + myBox + ";UIDVALIDITY=" +
+                        TQString::number(selectInfo.uidValidity ()));
+        kdDebug(7116) << "IMAP4::listDir - redirecting to " << newUrl.prettyURL() << endl;
+        redirection (newUrl);
+
+
+      }
+      else
+#endif
+      if (selectInfo.count () > 0)
+      {
+        int stretch = 0;
+
+        if (selectInfo.uidNextAvailable ())
+          stretch = TQString::number(selectInfo.uidNext ()).length ();
+        //        kdDebug(7116) << selectInfo.uidNext() << "d used to stretch " << stretch << endl;
+        UDSEntry entry;
+
+        if (mySequence.isEmpty()) mySequence = "1:*";
+
+        bool withSubject = mySection.isEmpty();
+        if (mySection.isEmpty()) mySection = "UID RFC822.SIZE ENVELOPE";
+
+        bool withFlags = mySection.upper().find("FLAGS") != -1;
+        imapCommand *fetch =
+          sendCommand (imapCommand::
+                       clientFetch (mySequence, mySection));
+        imapCache *cache;
+        do
+        {
+          while (!parseLoop ()) ;
+
+          cache = getLastHandled ();
+
+          if (cache && !fetch->isComplete())
+            doListEntry (encodedUrl, stretch, cache, withFlags, withSubject);
+        }
+        while (!fetch->isComplete ());
+        entry.clear ();
+        listEntry (entry, true);
+      }
+    }
+  }
+  if ( !selectInfo.alert().isNull() ) {
+    if ( !myBox.isEmpty() ) {
+      warning( i18n( "Message from %1 while processing '%2': %3" ).arg( myHost, myBox, selectInfo.alert() ) );
+    } else {
+      warning( i18n( "Message from %1: %2" ).arg( myHost, TQString(selectInfo.alert()) ) );
+    }
+    selectInfo.setAlert( 0 );
+  }
+
+  kdDebug(7116) << "IMAP4Protocol::listDir - Finishing listDir" << endl;
+  finished ();
+}
+
+void
+IMAP4Protocol::setHost (const TQString & _host, int _port,
+                        const TQString & _user, const TQString & _pass)
+{
+  if (myHost != _host || myPort != _port || myUser != _user || myPass != _pass)
+  { // what's the point of doing 4 string compares to avoid 4 string copies?
+    // DF: I guess to avoid calling closeConnection() unnecessarily.
+    if (!myHost.isEmpty ())
+      closeConnection ();
+    myHost = _host;
+    if (_port == 0) 
+        myPort = (mySSL) ? ImapsPort : ImapPort;
+    else 
+        myPort = _port;
+    myUser = _user;
+    myPass = _pass;
+  }
+}
+
+void
+IMAP4Protocol::parseRelay (const TQByteArray & buffer)
+{
+  if (relayEnabled) {
+    // relay data immediately
+    data( buffer );
+    mProcessedSize += buffer.size();
+    processedSize( mProcessedSize );
+  } else if (cacheOutput)
+  {
+    // collect data
+    if ( !outputBuffer.isOpen() ) {
+      outputBuffer.open(IO_WriteOnly);
+    }
+    outputBuffer.at(outputBufferIndex);
+    outputBuffer.writeBlock(buffer, buffer.size());
+    outputBufferIndex += buffer.size();
+  }
+}
+
+void
+IMAP4Protocol::parseRelay (ulong len)
+{
+  if (relayEnabled)
+    totalSize (len);
+}
+
+
+bool IMAP4Protocol::parseRead(TQByteArray & buffer, ulong len, ulong relay)
+{
+  char buf[8192];
+  while (buffer.size() < len)
+  {
+    ssize_t readLen = myRead(buf, TQMIN(len - buffer.size(), sizeof(buf) - 1));
+    if (readLen == 0)
+    {
+      kdDebug(7116) << "parseRead: readLen == 0 - connection broken" << endl;
+      error (ERR_CONNECTION_BROKEN, myHost);
+      setState(ISTATE_CONNECT);
+      closeConnection();
+      return FALSE;
+    }
+    if (relay > buffer.size())
+    {
+      TQByteArray relayData;
+      ssize_t relbuf = relay - buffer.size();
+      int currentRelay = TQMIN(relbuf, readLen);
+      relayData.setRawData(buf, currentRelay);
+      parseRelay(relayData);
+      relayData.resetRawData(buf, currentRelay);
+    }
+    {
+      TQBuffer stream (buffer);
+      stream.open (IO_WriteOnly);
+      stream.at (buffer.size ());
+      stream.writeBlock (buf, readLen);
+      stream.close ();
+    }
+  }
+  return (buffer.size() == len);
+}
+
+
+bool IMAP4Protocol::parseReadLine (TQByteArray & buffer, ulong relay)
+{
+  if (myHost.isEmpty()) return FALSE;
+
+  while (true) {
+    ssize_t copyLen = 0;
+    if (readBufferLen > 0)
+    {
+      while (copyLen < readBufferLen && readBuffer[copyLen] != '\n') copyLen++;
+      if (copyLen < readBufferLen) copyLen++;
+      if (relay > 0)
+      {
+        TQByteArray relayData;
+
+        if (copyLen < (ssize_t) relay)
+          relay = copyLen;
+        relayData.setRawData (readBuffer, relay);
+        parseRelay (relayData);
+        relayData.resetRawData (readBuffer, relay);
+//        kdDebug(7116) << "relayed : " << relay << "d" << endl;
+      }
+      // append to buffer
+      {
+        TQBuffer stream (buffer);
+
+        stream.open (IO_WriteOnly);
+        stream.at (buffer.size ());
+        stream.writeBlock (readBuffer, copyLen);
+        stream.close ();
+//        kdDebug(7116) << "appended " << copyLen << "d got now " << buffer.size() << endl;
+      }
+
+      readBufferLen -= copyLen;
+      if (readBufferLen)
+        memmove(readBuffer, &readBuffer[copyLen], readBufferLen);
+      if (buffer[buffer.size() - 1] == '\n') return TRUE;
+    }
+    if (!isConnectionValid())
+    {
+      kdDebug(7116) << "parseReadLine - connection broken" << endl;
+      error (ERR_CONNECTION_BROKEN, myHost);
+      setState(ISTATE_CONNECT);
+      closeConnection();
+      return FALSE;
+    }
+    if (!waitForResponse( responseTimeout() ))
+    {
+      error(ERR_SERVER_TIMEOUT, myHost);
+      setState(ISTATE_CONNECT);
+      closeConnection();
+      return FALSE;
+    }
+    readBufferLen = read(readBuffer, IMAP_BUFFER - 1);
+    if (readBufferLen == 0)
+    {
+      kdDebug(7116) << "parseReadLine: readBufferLen == 0 - connection broken" << endl;
+      error (ERR_CONNECTION_BROKEN, myHost);
+      setState(ISTATE_CONNECT);
+      closeConnection();
+      return FALSE;
+    }
+  }
+}
+
+void
+IMAP4Protocol::setSubURL (const KURL & _url)
+{
+  kdDebug(7116) << "IMAP4::setSubURL - " << _url.prettyURL() << endl;
+  TDEIO::TCPSlaveBase::setSubURL (_url);
+}
+
+void
+IMAP4Protocol::put (const KURL & _url, int, bool, bool)
+{
+  kdDebug(7116) << "IMAP4::put - " << _url.prettyURL() << endl;
+//  TDEIO::TCPSlaveBase::put(_url,permissions,overwrite,resume);
+  TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+  enum IMAP_TYPE aType =
+    parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+
+  // see if it is a box
+  if (aType != ITYPE_BOX && aType != ITYPE_DIR_AND_BOX)
+  {
+    if (aBox[aBox.length () - 1] == '/')
+      aBox = aBox.right (aBox.length () - 1);
+    imapCommand *cmd = doCommand (imapCommand::clientCreate (aBox));
+
+    if (cmd->result () != "OK") {
+      error (ERR_COULD_NOT_WRITE, _url.prettyURL());
+      completeQueue.removeRef (cmd);
+      return;
+    }
+    completeQueue.removeRef (cmd);
+  }
+  else
+  {
+    TQPtrList < TQByteArray > bufferList;
+    int length = 0;
+
+    int result;
+    // Loop until we got 'dataEnd'
+    do
+    {
+      TQByteArray *buffer = new TQByteArray ();
+      dataReq ();               // Request for data
+      result = readData (*buffer);
+      if (result > 0)
+      {
+        bufferList.append (buffer);
+        length += result;
+      } else {
+        delete buffer;
+      }
+    }
+    while (result > 0);
+
+    if (result != 0)
+    {
+      error (ERR_ABORTED, _url.prettyURL());
+      return;
+    }
+
+    imapCommand *cmd =
+      sendCommand (imapCommand::clientAppend (aBox, aSection, length));
+    while (!parseLoop ()) ;
+
+    // see if server is waiting
+    if (!cmd->isComplete () && !getContinuation ().isEmpty ())
+    {
+      bool sendOk = true;
+      ulong wrote = 0;
+
+      TQByteArray *buffer;
+      // send data to server
+      while (!bufferList.isEmpty () && sendOk)
+      {
+        buffer = bufferList.take (0);
+
+        sendOk =
+          (write (buffer->data (), buffer->size ()) ==
+           (ssize_t) buffer->size ());
+        wrote += buffer->size ();
+        processedSize(wrote);
+        delete buffer;
+        if (!sendOk)
+        {
+          error (ERR_CONNECTION_BROKEN, myHost);
+          completeQueue.removeRef (cmd);
+          setState(ISTATE_CONNECT);
+          closeConnection();
+          return;
+        }
+      }
+      parseWriteLine ("");
+      // Wait until cmd is complete, or connection breaks.
+      while (!cmd->isComplete () && getState() != ISTATE_NO)
+        parseLoop ();
+      if ( getState() == ISTATE_NO ) {
+        // TODO KDE4: pass cmd->resultInfo() as third argument.
+        // ERR_CONNECTION_BROKEN expects a host, no way to pass details about the problem.
+        error( ERR_CONNECTION_BROKEN, myHost );
+        completeQueue.removeRef (cmd);
+        closeConnection();
+        return;
+      }
+      else if (cmd->result () != "OK") {
+        error( ERR_SLAVE_DEFINED, cmd->resultInfo() );
+        completeQueue.removeRef (cmd);
+        return;
+      }
+      else
+      {
+        if (hasCapability("UIDPLUS"))
+        {
+          TQString uid = cmd->resultInfo();
+          if (uid.find("APPENDUID") != -1)
+          {
+            uid = uid.section(" ", 2, 2);
+            uid.truncate(uid.length()-1);
+            infoMessage("UID "+uid);
+          }
+        }
+        // MUST reselect to get the new message
+        else if (aBox == getCurrentBox ())
+        {
+          cmd =
+            doCommand (imapCommand::
+                       clientSelect (aBox, !selectInfo.readWrite ()));
+          completeQueue.removeRef (cmd);
+        }
+      }
+    }
+    else
+    {
+      //error (ERR_COULD_NOT_WRITE, myHost);
+      // Better ship the error message, e.g. "Over Quota"
+      error (ERR_SLAVE_DEFINED, cmd->resultInfo());
+      completeQueue.removeRef (cmd);
+      return;
+    }
+
+    completeQueue.removeRef (cmd);
+  }
+
+  finished ();
+}
+
+void
+IMAP4Protocol::mkdir (const KURL & _url, int)
+{
+  kdDebug(7116) << "IMAP4::mkdir - " << _url.prettyURL() << endl;
+  TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+  parseURL(_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+  kdDebug(7116) << "IMAP4::mkdir - create " << aBox << endl;
+  imapCommand *cmd = doCommand (imapCommand::clientCreate(aBox));
+
+  if (cmd->result () != "OK")
+  {
+    kdDebug(7116) << "IMAP4::mkdir - " << cmd->resultInfo() << endl;
+    error (ERR_COULD_NOT_MKDIR, _url.prettyURL());
+    completeQueue.removeRef (cmd);
+    return;
+  }
+  completeQueue.removeRef (cmd);
+
+  // start a new listing to find the type of the folder
+  enum IMAP_TYPE type =
+    parseURL(_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+  if (type == ITYPE_BOX)
+  {
+    bool ask = ( aInfo.find( "ASKUSER" ) != -1 );
+    if ( ask &&
+        messageBox(QuestionYesNo,
+          i18n("The following folder will be created on the server: %1 "
+               "What do you want to store in this folder?").arg( aBox ),
+          i18n("Create Folder"),
+          i18n("&Messages"), i18n("&Subfolders")) == KMessageBox::No )
+    {
+      cmd = doCommand(imapCommand::clientDelete(aBox));
+      completeQueue.removeRef (cmd);
+      cmd = doCommand(imapCommand::clientCreate(aBox + aDelimiter));
+      if (cmd->result () != "OK")
+      {
+        error (ERR_COULD_NOT_MKDIR, _url.prettyURL());
+        completeQueue.removeRef (cmd);
+        return;
+      }
+      completeQueue.removeRef (cmd);
+    }
+  }
+
+  cmd = doCommand(imapCommand::clientSubscribe(aBox));
+  completeQueue.removeRef(cmd);
+
+  finished ();
+}
+
+void
+IMAP4Protocol::copy (const KURL & src, const KURL & dest, int, bool overwrite)
+{
+  kdDebug(7116) << "IMAP4::copy - [" << (overwrite ? "Overwrite" : "NoOverwrite") << "] " << src.prettyURL() << " -> " << dest.prettyURL() << endl;
+  TQString sBox, sSequence, sLType, sSection, sValidity, sDelimiter, sInfo;
+  TQString dBox, dSequence, dLType, dSection, dValidity, dDelimiter, dInfo;
+  enum IMAP_TYPE sType =
+    parseURL (src, sBox, sSection, sLType, sSequence, sValidity, sDelimiter, sInfo);
+  enum IMAP_TYPE dType =
+    parseURL (dest, dBox, dSection, dLType, dSequence, dValidity, dDelimiter, dInfo);
+
+  // see if we have to create anything
+  if (dType != ITYPE_BOX && dType != ITYPE_DIR_AND_BOX)
+  {
+    // this might be konqueror
+    int sub = dBox.find (sBox);
+
+    // might be moving to upper folder
+    if (sub > 0)
+    {
+      KURL testDir = dest;
+
+      TQString subDir = dBox.right (dBox.length () - dBox.findRev ('/'));
+      TQString topDir = dBox.left (sub);
+      testDir.setPath ("/" + topDir);
+      dType =
+        parseURL (testDir, topDir, dSection, dLType, dSequence, dValidity,
+          dDelimiter, dInfo);
+
+      kdDebug(7116) << "IMAP4::copy - checking this destination " << topDir << endl;
+      // see if this is what the user wants
+      if (dType == ITYPE_BOX || dType == ITYPE_DIR_AND_BOX)
+      {
+        kdDebug(7116) << "IMAP4::copy - assuming this destination " << topDir << endl;
+        dBox = topDir;
+      }
+      else
+      {
+
+        // maybe if we create a new mailbox
+        topDir = "/" + topDir + subDir;
+        testDir.setPath (topDir);
+        kdDebug(7116) << "IMAP4::copy - checking this destination " << topDir << endl;
+        dType =
+          parseURL (testDir, topDir, dSection, dLType, dSequence, dValidity,
+            dDelimiter, dInfo);
+        if (dType != ITYPE_BOX && dType != ITYPE_DIR_AND_BOX)
+        {
+          // ok then we'll create a mailbox
+          imapCommand *cmd = doCommand (imapCommand::clientCreate (topDir));
+
+          // on success we'll use it, else we'll just try to create the given dir
+          if (cmd->result () == "OK")
+          {
+            kdDebug(7116) << "IMAP4::copy - assuming this destination " << topDir << endl;
+            dType = ITYPE_BOX;
+            dBox = topDir;
+          }
+          else
+          {
+            completeQueue.removeRef (cmd);
+            cmd = doCommand (imapCommand::clientCreate (dBox));
+            if (cmd->result () == "OK")
+              dType = ITYPE_BOX;
+            else
+              error (ERR_COULD_NOT_WRITE, dest.prettyURL());
+          }
+          completeQueue.removeRef (cmd);
+        }
+      }
+
+    }
+  }
+  if (sType == ITYPE_MSG || sType == ITYPE_BOX || sType == ITYPE_DIR_AND_BOX)
+  {
+    //select the source box
+    if (!assureBox(sBox, true)) return;
+    kdDebug(7116) << "IMAP4::copy - " << sBox << " -> " << dBox << endl;
+
+    //issue copy command
+    imapCommand *cmd =
+      doCommand (imapCommand::clientCopy (dBox, sSequence));
+    if (cmd->result () != "OK")
+    {
+      kdError(5006) << "IMAP4::copy - " << cmd->resultInfo() << endl;
+      error (ERR_COULD_NOT_WRITE, dest.prettyURL());
+      completeQueue.removeRef (cmd);
+      return;
+    } else {
+      if (hasCapability("UIDPLUS"))
+      {
+        TQString uid = cmd->resultInfo();
+        if (uid.find("COPYUID") != -1)
+        {
+          uid = uid.section(" ", 2, 3);
+          uid.truncate(uid.length()-1);
+          infoMessage("UID "+uid);
+        }
+      }
+    }
+    completeQueue.removeRef (cmd);
+  }
+  else
+  {
+    error (ERR_ACCESS_DENIED, src.prettyURL());
+    return;
+  }
+  finished ();
+}
+
+void
+IMAP4Protocol::del (const KURL & _url, bool isFile)
+{
+  kdDebug(7116) << "IMAP4::del - [" << (isFile ? "File" : "NoFile") << "] " << _url.prettyURL() << endl;
+  TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+  enum IMAP_TYPE aType =
+    parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+
+  switch (aType)
+  {
+  case ITYPE_BOX:
+  case ITYPE_DIR_AND_BOX:
+    if (!aSequence.isEmpty ())
+    {
+      if (aSequence == "*")
+      {
+        if (!assureBox (aBox, false)) return;
+        imapCommand *cmd = doCommand (imapCommand::clientExpunge ());
+        if (cmd->result () != "OK") {
+          error (ERR_CANNOT_DELETE, _url.prettyURL());
+          completeQueue.removeRef (cmd);
+          return;
+        }
+        completeQueue.removeRef (cmd);
+      }
+      else
+      {
+        // if open for read/write
+        if (!assureBox (aBox, false)) return;
+        imapCommand *cmd =
+          doCommand (imapCommand::
+                     clientStore (aSequence, "+FLAGS.SILENT", "\\DELETED"));
+        if (cmd->result () != "OK") {
+          error (ERR_CANNOT_DELETE, _url.prettyURL());
+          completeQueue.removeRef (cmd);
+          return;
+        }
+        completeQueue.removeRef (cmd);
+      }
+    }
+    else
+    {
+      if (getCurrentBox() == aBox)
+      {
+        imapCommand *cmd = doCommand(imapCommand::clientClose());
+        completeQueue.removeRef(cmd);
+        setState(ISTATE_LOGIN);
+      }
+      // We unsubscribe, otherwise we get ghost folders on UW-IMAP
+      imapCommand *cmd = doCommand(imapCommand::clientUnsubscribe(aBox));
+      completeQueue.removeRef(cmd);
+      cmd = doCommand(imapCommand::clientDelete (aBox));
+      // If this doesn't work, we try to empty the mailbox first
+      if (cmd->result () != "OK")
+      {
+        completeQueue.removeRef(cmd);
+        if (!assureBox(aBox, false)) return;
+        bool stillOk = true;
+        if (stillOk)
+        {
+          imapCommand *cmd = doCommand(
+            imapCommand::clientStore("1:*", "+FLAGS.SILENT", "\\DELETED"));
+          if (cmd->result () != "OK") stillOk = false;
+          completeQueue.removeRef(cmd);
+        }
+        if (stillOk)
+        {
+          imapCommand *cmd = doCommand(imapCommand::clientClose());
+          if (cmd->result () != "OK") stillOk = false;
+          completeQueue.removeRef(cmd);
+          setState(ISTATE_LOGIN);
+        }
+        if (stillOk)
+        {
+          imapCommand *cmd = doCommand (imapCommand::clientDelete(aBox));
+          if (cmd->result () != "OK") stillOk = false;
+          completeQueue.removeRef(cmd);
+        }
+        if (!stillOk)
+        {
+          error (ERR_COULD_NOT_RMDIR, _url.prettyURL());
+          return;
+        }
+      } else {
+        completeQueue.removeRef (cmd);
+      }
+    }
+    break;
+
+  case ITYPE_DIR:
+    {
+      imapCommand *cmd = doCommand (imapCommand::clientDelete (aBox));
+      if (cmd->result () != "OK") {
+        error (ERR_COULD_NOT_RMDIR, _url.prettyURL());
+        completeQueue.removeRef (cmd);
+        return;
+      }
+      completeQueue.removeRef (cmd);
+    }
+    break;
+
+  case ITYPE_MSG:
+    {
+      // if open for read/write
+      if (!assureBox (aBox, false)) return;
+      imapCommand *cmd =
+        doCommand (imapCommand::
+                   clientStore (aSequence, "+FLAGS.SILENT", "\\DELETED"));
+      if (cmd->result () != "OK") {
+        error (ERR_CANNOT_DELETE, _url.prettyURL());
+        completeQueue.removeRef (cmd);
+        return;
+      }
+      completeQueue.removeRef (cmd);
+    }
+    break;
+
+  case ITYPE_UNKNOWN:
+  case ITYPE_ATTACH:
+    error (ERR_CANNOT_DELETE, _url.prettyURL());
+    break;
+  }
+  finished ();
+}
+
+/*
+ * Copy a mail: data = 'C' + srcURL (KURL) + destURL (KURL)
+ * Capabilities: data = 'c'. Result shipped in infoMessage() signal
+ * No-op: data = 'N'
+ * Namespace: data = 'n'. Result shipped in infoMessage() signal
+ *                        The format is: section=namespace=delimiter
+ *                        Note that the namespace can be empty
+ * Unsubscribe: data = 'U' + URL (KURL)
+ * Subscribe: data = 'u' + URL (KURL)
+ * Change the status: data = 'S' + URL (KURL) + Flags (TQCString)
+ * ACL commands: data = 'A' + command + URL (KURL) + command-dependent args
+ * AnnotateMore commands: data = 'M' + 'G'et/'S'et + URL + entry + command-dependent args
+ * Search: data = 'E' + URL (KURL)
+ * Quota commands: data = 'Q' + 'R'oot/'G'et/'S'et + URL + entry + command-dependent args
+ * Custom command: data = 'X' + 'N'ormal/'E'xtended + command + command-dependent args
+ */
+void
+IMAP4Protocol::special (const TQByteArray & aData)
+{
+  kdDebug(7116) << "IMAP4Protocol::special" << endl;
+  if (!makeLogin()) return;
+
+  TQDataStream stream(aData, IO_ReadOnly);
+
+  int tmp;
+  stream >> tmp;
+
+  switch (tmp) {
+  case 'C':
+  {
+    // copy
+    KURL src;
+    KURL dest;
+    stream >> src >> dest;
+    copy(src, dest, 0, FALSE);
+    break;
+  }
+  case 'c':
+  {
+    // capabilities
+    infoMessage(imapCapabilities.join(" "));
+    finished();
+    break;
+  }
+  case 'N':
+  {
+    // NOOP
+    imapCommand *cmd = doCommand(imapCommand::clientNoop());
+    if (cmd->result () != "OK")
+    {
+      kdDebug(7116) << "NOOP did not succeed - connection broken" << endl;
+      completeQueue.removeRef (cmd);
+      error (ERR_CONNECTION_BROKEN, myHost);
+      return;
+    }
+    completeQueue.removeRef (cmd);
+    finished();
+    break;
+  }
+  case 'n':
+  {
+    // namespace in the form "section=namespace=delimiter"
+    // entries are separated by ,
+    infoMessage( imapNamespaces.join(",") );
+    finished();
+    break;
+  }
+  case 'U':
+  {
+    // unsubscribe
+    KURL _url;
+    stream >> _url;
+    TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+    parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+    imapCommand *cmd = doCommand(imapCommand::clientUnsubscribe(aBox));
+    if (cmd->result () != "OK")
+    {
+      completeQueue.removeRef (cmd);
+      error(ERR_SLAVE_DEFINED, i18n("Unsubscribe of folder %1 "
+                                    "failed. The server returned: %2")
+            .arg(_url.prettyURL())
+            .arg(cmd->resultInfo()));
+      return;
+    }
+    completeQueue.removeRef (cmd);
+    finished();
+    break;
+  }
+  case 'u':
+  {
+    // subscribe
+    KURL _url;
+    stream >> _url;
+    TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+    parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+    imapCommand *cmd = doCommand(imapCommand::clientSubscribe(aBox));
+    if (cmd->result () != "OK")
+    {
+      completeQueue.removeRef (cmd);
+      error(ERR_SLAVE_DEFINED, i18n("Subscribe of folder %1 "
+                                    "failed. The server returned: %2")
+            .arg(_url.prettyURL())
+            .arg(cmd->resultInfo()));
+      return;
+    }
+    completeQueue.removeRef (cmd);
+    finished();
+    break;
+  }
+  case 'A':
+  {
+    // acl
+    int cmd;
+    stream >> cmd;
+    if ( hasCapability( "ACL" ) ) {
+      specialACLCommand( cmd, stream );
+    } else {
+      error( ERR_UNSUPPORTED_ACTION, "ACL" );
+    }
+    break;
+  }
+  case 'M':
+  {
+    // annotatemore
+    int cmd;
+    stream >> cmd;
+    if ( hasCapability( "ANNOTATEMORE" ) ) {
+      specialAnnotateMoreCommand( cmd, stream );
+    } else {
+      error( ERR_UNSUPPORTED_ACTION, "ANNOTATEMORE" );
+    }
+    break;
+  }
+  case 'Q':
+  {
+    // quota
+    int cmd;
+    stream >> cmd;
+    if ( hasCapability( "QUOTA" ) ) {
+      specialQuotaCommand( cmd, stream );
+    } else {
+      error( ERR_UNSUPPORTED_ACTION, "QUOTA" );
+    }
+    break;
+  }
+  case 'S':
+  {
+    // status
+    KURL _url;
+    TQCString newFlags;
+    stream >> _url >> newFlags;
+
+    TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+    parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+    if (!assureBox(aBox, false)) return;
+
+    // make sure we only touch flags we know
+    TQCString knownFlags = "\\SEEN \\ANSWERED \\FLAGGED \\DRAFT";
+    const imapInfo info = getSelected();
+    if ( info.permanentFlagsAvailable() && (info.permanentFlags() & imapInfo::User) ) {
+      knownFlags += " KMAILFORWARDED KMAILTODO KMAILWATCHED KMAILIGNORED $FORWARDED $TODO $WATCHED $IGNORED";
+    }
+
+    imapCommand *cmd = doCommand (imapCommand::
+                                  clientStore (aSequence, "-FLAGS.SILENT", knownFlags));
+    if (cmd->result () != "OK")
+    {
+      completeQueue.removeRef (cmd);
+      error(ERR_COULD_NOT_WRITE, i18n("Changing the flags of message %1 "
+                                      "failed.").arg(_url.prettyURL()));
+      return;
+    }
+    completeQueue.removeRef (cmd);
+    if (!newFlags.isEmpty())
+    {
+      cmd = doCommand (imapCommand::
+                       clientStore (aSequence, "+FLAGS.SILENT", newFlags));
+      if (cmd->result () != "OK")
+      {
+        completeQueue.removeRef (cmd);
+        error(ERR_COULD_NOT_WRITE, i18n("Changing the flags of message %1 "
+                                        "failed.").arg(_url.prettyURL()));
+        return;
+      }
+      completeQueue.removeRef (cmd);
+    }
+    finished();
+    break;
+  }
+  case 's':
+  {
+    // seen
+    KURL _url;
+    bool seen;
+    TQCString newFlags;
+    stream >> _url >> seen;
+
+    TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+    parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+    if ( !assureBox(aBox, true) ) // read-only because changing SEEN should be possible even then
+      return;
+
+    imapCommand *cmd;
+    if ( seen )
+      cmd = doCommand( imapCommand::clientStore( aSequence, "+FLAGS.SILENT", "\\SEEN" ) );
+    else
+      cmd = doCommand( imapCommand::clientStore( aSequence, "-FLAGS.SILENT", "\\SEEN" ) );
+
+    if (cmd->result () != "OK")
+    {
+      completeQueue.removeRef (cmd);
+      error(ERR_COULD_NOT_WRITE, i18n("Changing the flags of message %1 "
+                                      "failed.").arg(_url.prettyURL()));
+      return;
+    }
+    completeQueue.removeRef (cmd);
+    finished();
+    break;
+  }
+
+  case 'E':
+  {
+    // search
+    specialSearchCommand( stream );
+    break;
+  }
+  case 'X':
+  {
+    // custom command
+    specialCustomCommand( stream );
+    break;
+  }
+  default:
+    kdWarning(7116) << "Unknown command in special(): " << tmp << endl;
+    error( ERR_UNSUPPORTED_ACTION, TQString(TQChar(tmp)) );
+    break;
+  }
+}
+
+void
+IMAP4Protocol::specialACLCommand( int command, TQDataStream& stream )
+{
+  // All commands start with the URL to the box
+  KURL _url;
+  stream >> _url;
+  TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+  parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+
+  switch( command ) {
+  case 'S': // SETACL
+  {
+    TQString user, acl;
+    stream >> user >> acl;
+    kdDebug(7116) << "SETACL " << aBox << " " << user << " " << acl << endl;
+    imapCommand *cmd = doCommand(imapCommand::clientSetACL(aBox, user, acl));
+    if (cmd->result () != "OK")
+    {
+      error(ERR_SLAVE_DEFINED, i18n("Setting the Access Control List on folder %1 "
+                                      "for user %2 failed. The server returned: %3")
+            .arg(_url.prettyURL())
+            .arg(user)
+            .arg(cmd->resultInfo()));
+      return;
+    }
+    completeQueue.removeRef (cmd);
+    finished();
+    break;
+  }
+  case 'D': // DELETEACL
+  {
+    TQString user;
+    stream >> user;
+    kdDebug(7116) << "DELETEACL " << aBox << " " << user << endl;
+    imapCommand *cmd = doCommand(imapCommand::clientDeleteACL(aBox, user));
+    if (cmd->result () != "OK")
+    {
+      error(ERR_SLAVE_DEFINED, i18n("Deleting the Access Control List on folder %1 "
+                                    "for user %2 failed. The server returned: %3")
+            .arg(_url.prettyURL())
+            .arg(user)
+            .arg(cmd->resultInfo()));
+      return;
+    }
+    completeQueue.removeRef (cmd);
+    finished();
+    break;
+  }
+  case 'G': // GETACL
+  {
+    kdDebug(7116) << "GETACL " << aBox << endl;
+    imapCommand *cmd = doCommand(imapCommand::clientGetACL(aBox));
+    if (cmd->result () != "OK")
+    {
+      error(ERR_SLAVE_DEFINED, i18n("Retrieving the Access Control List on folder %1 "
+                                     "failed. The server returned: %2")
+            .arg(_url.prettyURL())
+            .arg(cmd->resultInfo()));
+      return;
+    }
+    // Returning information to the application from a special() command isn't easy.
+    // I'm reusing the infoMessage trick seen above (for capabilities), but this
+    // limits me to a string instead of a stringlist. Using DQUOTE as separator,
+    // because it's forbidden in userids by rfc3501
+    kdDebug(7116) << getResults() << endl;
+    infoMessage(getResults().join( "\"" ));
+    finished();
+    break;
+  }
+  case 'L': // LISTRIGHTS
+  {
+    // Do we need this one? It basically shows which rights are tied together, but that's all?
+    error( ERR_UNSUPPORTED_ACTION, TQString(TQChar(command)) );
+    break;
+  }
+  case 'M': // MYRIGHTS
+  {
+    kdDebug(7116) << "MYRIGHTS " << aBox << endl;
+    imapCommand *cmd = doCommand(imapCommand::clientMyRights(aBox));
+    if (cmd->result () != "OK")
+    {
+      error(ERR_SLAVE_DEFINED, i18n("Retrieving the Access Control List on folder %1 "
+                                    "failed. The server returned: %2")
+            .arg(_url.prettyURL())
+            .arg(cmd->resultInfo()));
+      return;
+    }
+    TQStringList lst = getResults();
+    kdDebug(7116) << "myrights results: " << lst << endl;
+    if ( !lst.isEmpty() ) {
+      Q_ASSERT( lst.count() == 1 );
+      infoMessage( lst.first() );
+    }
+    finished();
+    break;
+  }
+  default:
+    kdWarning(7116) << "Unknown special ACL command:" << command << endl;
+    error( ERR_UNSUPPORTED_ACTION, TQString(TQChar(command)) );
+  }
+}
+
+void
+IMAP4Protocol::specialSearchCommand( TQDataStream& stream )
+{
+  kdDebug(7116) << "IMAP4Protocol::specialSearchCommand" << endl;
+  KURL _url;
+  stream >> _url;
+  TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+  parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+  if (!assureBox(aBox, true)) return;
+
+  imapCommand *cmd = doCommand (imapCommand::clientSearch( aSection ));
+  if (cmd->result () != "OK")
+  {
+    error(ERR_SLAVE_DEFINED, i18n("Searching of folder %1 "
+          "failed. The server returned: %2")
+        .arg(aBox)
+        .arg(cmd->resultInfo()));
+    return;
+  }
+  completeQueue.removeRef(cmd);
+  TQStringList lst = getResults();
+  kdDebug(7116) << "IMAP4Protocol::specialSearchCommand '" << aSection <<
+    "' returns " << lst << endl;
+  infoMessage( lst.join( " " ) );
+
+  finished();
+}
+
+void
+IMAP4Protocol::specialCustomCommand( TQDataStream& stream )
+{
+  kdDebug(7116) << "IMAP4Protocol::specialCustomCommand" << endl;
+
+  TQString command, arguments;
+  int type;
+  stream >> type;
+  stream >> command >> arguments;
+
+  /**
+   * In 'normal' mode we send the command with all information in one go
+   * and retrieve the result.
+   */
+  if ( type == 'N' ) {
+    kdDebug(7116) << "IMAP4Protocol::specialCustomCommand: normal mode" << endl;
+    imapCommand *cmd = doCommand (imapCommand::clientCustom( command, arguments ));
+    if (cmd->result () != "OK")
+    {
+      error(ERR_SLAVE_DEFINED, i18n("Custom command %1:%2 "
+            "failed. The server returned: %3")
+          .arg(command)
+          .arg(arguments)
+          .arg(cmd->resultInfo()));
+      return;
+    }
+    completeQueue.removeRef(cmd);
+    TQStringList lst = getResults();
+    kdDebug(7116) << "IMAP4Protocol::specialCustomCommand '" << command <<
+      ":" << arguments <<
+      "' returns " << lst << endl;
+    infoMessage( lst.join( " " ) );
+
+    finished();
+  } else
+  /**
+   * In 'extended' mode we send a first header and push the data of the request in
+   * streaming mode.
+   */
+  if ( type == 'E' ) {
+    kdDebug(7116) << "IMAP4Protocol::specialCustomCommand: extended mode" << endl;
+    imapCommand *cmd = sendCommand (imapCommand::clientCustom( command, TQString() ));
+    while ( !parseLoop () ) ;
+
+    // see if server is waiting
+    if (!cmd->isComplete () && !getContinuation ().isEmpty ())
+    {
+      const TQByteArray buffer = arguments.utf8();
+
+      // send data to server
+      bool sendOk = (write (buffer.data (), buffer.size ()) == (ssize_t)buffer.size ());
+      processedSize( buffer.size() );
+
+      if ( !sendOk ) {
+        error ( ERR_CONNECTION_BROKEN, myHost );
+        completeQueue.removeRef ( cmd );
+        setState(ISTATE_CONNECT);
+        closeConnection();
+        return;
+      }
+    }
+    parseWriteLine ("");
+
+    do
+    {
+      while (!parseLoop ()) ;
+    }
+    while (!cmd->isComplete ());
+
+    completeQueue.removeRef (cmd);
+
+    TQStringList lst = getResults();
+    kdDebug(7116) << "IMAP4Protocol::specialCustomCommand: returns " << lst << endl;
+    infoMessage( lst.join( " " ) );
+
+    finished ();
+  }
+}
+
+void
+IMAP4Protocol::specialAnnotateMoreCommand( int command, TQDataStream& stream )
+{
+  // All commands start with the URL to the box
+  KURL _url;
+  stream >> _url;
+  TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+  parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+
+  switch( command ) {
+  case 'S': // SETANNOTATION
+  {
+    // Params:
+    //  KURL URL of the mailbox
+    //  TQString entry (should be an actual entry name, no % or *; empty for server entries)
+    //  TQMap<TQString,TQString> attributes (name and value)
+    TQString entry;
+    TQMap<TQString, TQString> attributes;
+    stream >> entry >> attributes;
+    kdDebug(7116) << "SETANNOTATION " << aBox << " " << entry << " " << attributes.count() << " attributes" << endl;
+    imapCommand *cmd = doCommand(imapCommand::clientSetAnnotation(aBox, entry, attributes));
+    if (cmd->result () != "OK")
+    {
+      error(ERR_SLAVE_DEFINED, i18n("Setting the annotation %1 on folder %2 "
+                                    " failed. The server returned: %3")
+            .arg(entry)
+            .arg(_url.prettyURL())
+            .arg(cmd->resultInfo()));
+      return;
+    }
+    completeQueue.removeRef (cmd);
+    finished();
+    break;
+  }
+  case 'G': // GETANNOTATION.
+  {
+    // Params:
+    //  KURL URL of the mailbox
+    //  TQString entry (should be an actual entry name, no % or *; empty for server entries)
+    //  TQStringList attributes (list of attributes to be retrieved, possibly with % or *)
+    TQString entry;
+    TQStringList attributeNames;
+    stream >> entry >> attributeNames;
+    kdDebug(7116) << "GETANNOTATION " << aBox << " " << entry << " " << attributeNames << endl;
+    imapCommand *cmd = doCommand(imapCommand::clientGetAnnotation(aBox, entry, attributeNames));
+    if (cmd->result () != "OK")
+    {
+      error(ERR_SLAVE_DEFINED, i18n("Retrieving the annotation %1 on folder %2 "
+                                     "failed. The server returned: %3")
+            .arg(entry)
+            .arg(_url.prettyURL())
+            .arg(cmd->resultInfo()));
+      return;
+    }
+    // Returning information to the application from a special() command isn't easy.
+    // I'm reusing the infoMessage trick seen above (for capabilities and acls), but this
+    // limits me to a string instead of a stringlist. Let's use \r as separator.
+    kdDebug(7116) << getResults() << endl;
+    infoMessage(getResults().join( "\r" ));
+    finished();
+    break;
+  }
+  default:
+    kdWarning(7116) << "Unknown special annotate command:" << command << endl;
+    error( ERR_UNSUPPORTED_ACTION, TQString(TQChar(command)) );
+  }
+}
+
+void
+IMAP4Protocol::specialQuotaCommand( int command, TQDataStream& stream )
+{
+  // All commands start with the URL to the box
+  KURL _url;
+  stream >> _url;
+  TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+  parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter, aInfo);
+
+  switch( command ) {
+    case 'R': // GETQUOTAROOT
+      {
+        kdDebug(7116) << "QUOTAROOT " << aBox << endl;
+        imapCommand *cmd = doCommand(imapCommand::clientGetQuotaroot( aBox ) );
+        if (cmd->result () != "OK")
+        {
+          error(ERR_SLAVE_DEFINED, i18n("Retrieving the quota root information on folder %1 "
+                "failed. The server returned: %2")
+              .arg(_url.prettyURL())
+              .arg(cmd->resultInfo()));
+          return;
+        }
+        infoMessage(getResults().join( "\r" ));
+        finished();
+        break;
+      }
+    case 'G': // GETQUOTA
+      {
+        kdDebug(7116) << "GETQUOTA command" << endl;
+        kdWarning(7116) << "UNIMPLEMENTED" << endl;
+        break;
+      }
+    case 'S': // SETQUOTA
+      {
+        kdDebug(7116) << "SETQUOTA command" << endl;
+        kdWarning(7116) << "UNIMPLEMENTED" << endl;
+        break;
+      }
+    default:
+      kdWarning(7116) << "Unknown special quota command:" << command << endl;
+      error( ERR_UNSUPPORTED_ACTION, TQString(TQChar(command)) );
+  }
+}
+
+void
+IMAP4Protocol::rename (const KURL & src, const KURL & dest, bool overwrite)
+{
+  kdDebug(7116) << "IMAP4::rename - [" << (overwrite ? "Overwrite" : "NoOverwrite") << "] " << src.prettyURL() << " -> " << dest.prettyURL() << endl;
+  TQString sBox, sSequence, sLType, sSection, sValidity, sDelimiter, sInfo;
+  TQString dBox, dSequence, dLType, dSection, dValidity, dDelimiter, dInfo;
+  enum IMAP_TYPE sType =
+    parseURL (src, sBox, sSection, sLType, sSequence, sValidity, sDelimiter, sInfo, false);
+  enum IMAP_TYPE dType =
+    parseURL (dest, dBox, dSection, dLType, dSequence, dValidity, dDelimiter, dInfo, false);
+
+  if (dType == ITYPE_UNKNOWN)
+  {
+    switch (sType)
+    {
+    case ITYPE_BOX:
+    case ITYPE_DIR:
+    case ITYPE_DIR_AND_BOX:
+      {
+        if (getState() == ISTATE_SELECT && sBox == getCurrentBox())
+        {
+          kdDebug(7116) << "IMAP4::rename - close " << getCurrentBox() << endl;
+          // mailbox can only be renamed if it is closed
+          imapCommand *cmd = doCommand (imapCommand::clientClose());
+          bool ok = cmd->result() == "OK";
+          completeQueue.removeRef(cmd);
+          if (!ok)
+          {
+            kdWarning(7116) << "Unable to close mailbox!" << endl;
+            error(ERR_CANNOT_RENAME, src.path());
+            return;
+          }
+          setState(ISTATE_LOGIN);
+        }
+        imapCommand *cmd = doCommand (imapCommand::clientRename (sBox, dBox));
+        if (cmd->result () != "OK") {
+          error (ERR_CANNOT_RENAME, src.path());
+          completeQueue.removeRef (cmd);
+          return;
+        }
+        completeQueue.removeRef (cmd);
+      }
+      break;
+
+    case ITYPE_MSG:
+    case ITYPE_ATTACH:
+    case ITYPE_UNKNOWN:
+      error (ERR_CANNOT_RENAME, src.path());
+      break;
+    }
+  }
+  else
+  {
+    error (ERR_CANNOT_RENAME, src.path());
+    return;
+  }
+  finished ();
+}
+
+void
+IMAP4Protocol::slave_status ()
+{
+  bool connected = (getState() != ISTATE_NO) && isConnectionValid();
+  kdDebug(7116) << "IMAP4::slave_status " << connected << endl;
+  slaveStatus ( connected ? myHost : TQString(), connected );
+}
+
+void
+IMAP4Protocol::dispatch (int command, const TQByteArray & data)
+{
+  kdDebug(7116) << "IMAP4::dispatch - command=" << command << endl;
+  TDEIO::TCPSlaveBase::dispatch (command, data);
+}
+
+void
+IMAP4Protocol::stat (const KURL & _url)
+{
+  kdDebug(7116) << "IMAP4::stat - " << _url.prettyURL() << endl;
+  TQString aBox, aSequence, aLType, aSection, aValidity, aDelimiter, aInfo;
+  // parseURL with caching
+  enum IMAP_TYPE aType =
+    parseURL (_url, aBox, aSection, aLType, aSequence, aValidity, aDelimiter,
+        aInfo, true);
+
+  UDSEntry entry;
+  UDSAtom atom;
+
+  atom.m_uds = UDS_NAME;
+  atom.m_str = aBox;
+  entry.append (atom);
+
+  if (!aSection.isEmpty())
+  {
+    if (getState() == ISTATE_SELECT && aBox == getCurrentBox())
+    {
+      imapCommand *cmd = doCommand (imapCommand::clientClose());
+      bool ok = cmd->result() == "OK";
+      completeQueue.removeRef(cmd);
+      if (!ok)
+      {
+        error(ERR_COULD_NOT_STAT, aBox);
+        return;
+      }
+      setState(ISTATE_LOGIN);
+    }
+    bool ok = false;
+    TQString cmdInfo;
+    if (aType == ITYPE_MSG || aType == ITYPE_ATTACH)
+      ok = true;
+    else
+    {
+      imapCommand *cmd = doCommand(imapCommand::clienStatus(aBox, aSection));
+      ok = cmd->result() == "OK";
+      cmdInfo = cmd->resultInfo();
+      completeQueue.removeRef(cmd);
+    }
+    if (!ok)
+    {
+      bool found = false;
+      imapCommand *cmd = doCommand (imapCommand::clientList ("", aBox));
+      if (cmd->result () == "OK")
+      {
+        for (TQValueListIterator < imapList > it = listResponses.begin ();
+             it != listResponses.end (); ++it)
+        {
+          if (aBox == (*it).name ()) found = true;
+        }
+      }
+      completeQueue.removeRef (cmd);
+      if (found)
+        error(ERR_COULD_NOT_STAT, aBox);
+      else
+        error(TDEIO::ERR_DOES_NOT_EXIST, aBox);
+      return;
+    }
+    if ((aSection == "UIDNEXT" && geStatus().uidNextAvailable())
+      || (aSection == "UNSEEN" && geStatus().unseenAvailable()))
+    {
+      atom.m_uds = UDS_SIZE;
+      atom.m_str = TQString();
+      atom.m_long = (aSection == "UIDNEXT") ? geStatus().uidNext()
+        : geStatus().unseen();
+      entry.append(atom);
+    }
+  } else
+  if (aType == ITYPE_BOX || aType == ITYPE_DIR_AND_BOX || aType == ITYPE_MSG ||
+      aType == ITYPE_ATTACH)
+  {
+    ulong validity = 0;
+    // see if the box is already in select/examine state
+    if (aBox == getCurrentBox ())
+      validity = selectInfo.uidValidity ();
+    else
+    {
+      // do a status lookup on the box
+      // only do this if the box is not selected
+      // the server might change the validity for new select/examine
+      imapCommand *cmd =
+        doCommand (imapCommand::clienStatus (aBox, "UIDVALIDITY"));
+      completeQueue.removeRef (cmd);
+      validity = geStatus ().uidValidity ();
+    }
+    validity = 0;               // temporary
+
+    if (aType == ITYPE_BOX || aType == ITYPE_DIR_AND_BOX)
+    {
+      // has no or an invalid uidvalidity
+      if (validity > 0 && validity != aValidity.toULong ())
+      {
+        //redirect
+        KURL newUrl = _url;
+
+        newUrl.setPath ("/" + aBox + ";UIDVALIDITY=" +
+                        TQString::number(validity));
+        kdDebug(7116) << "IMAP4::stat - redirecting to " << newUrl.prettyURL() << endl;
+        redirection (newUrl);
+      }
+    }
+    else if (aType == ITYPE_MSG || aType == ITYPE_ATTACH)
+    {
+      //must determine if this message exists
+      //cause konqueror will check this on paste operations
+
+      // has an invalid uidvalidity
+      // or no messages in box
+      if (validity > 0 && validity != aValidity.toULong ())
+      {
+        aType = ITYPE_UNKNOWN;
+        kdDebug(7116) << "IMAP4::stat - url has invalid validity [" << validity << "d] " << _url.prettyURL() << endl;
+      }
+    }
+  }
+
+  atom.m_uds = UDS_MIME_TYPE;
+  atom.m_str = getMimeType (aType);
+  entry.append (atom);
+
+  kdDebug(7116) << "IMAP4: stat: " << atom.m_str << endl;
+  switch (aType)
+  {
+  case ITYPE_DIR:
+    atom.m_uds = UDS_FILE_TYPE;
+    atom.m_str = TQString();
+    atom.m_long = S_IFDIR;
+    entry.append (atom);
+    break;
+
+  case ITYPE_BOX:
+  case ITYPE_DIR_AND_BOX:
+    atom.m_uds = UDS_FILE_TYPE;
+    atom.m_str = TQString();
+    atom.m_long = S_IFDIR;
+    entry.append (atom);
+    break;
+
+  case ITYPE_MSG:
+  case ITYPE_ATTACH:
+    atom.m_uds = UDS_FILE_TYPE;
+    atom.m_str = TQString();
+    atom.m_long = S_IFREG;
+    entry.append (atom);
+    break;
+
+  case ITYPE_UNKNOWN:
+    error (ERR_DOES_NOT_EXIST, _url.prettyURL());
+    break;
+  }
+
+  statEntry (entry);
+  kdDebug(7116) << "IMAP4::stat - Finishing stat" << endl;
+  finished ();
+}
+
+void IMAP4Protocol::openConnection()
+{
+  if (makeLogin()) connected();
+}
+
+void IMAP4Protocol::closeConnection()
+{
+  if (getState() == ISTATE_NO) return;
+  if (getState() == ISTATE_SELECT && metaData("expunge") == "auto")
+  {
+    imapCommand *cmd = doCommand (imapCommand::clientExpunge());
+    completeQueue.removeRef (cmd);
+  }
+  if (getState() != ISTATE_CONNECT)
+  {
+    imapCommand *cmd = doCommand (imapCommand::clientLogout());
+    completeQueue.removeRef (cmd);
+  }
+  closeDescriptor();
+  setState(ISTATE_NO);
+  completeQueue.clear();
+  sentQueue.clear();
+  lastHandled = 0;
+  currentBox = TQString();
+  readBufferLen = 0;
+}
+
+bool IMAP4Protocol::makeLogin ()
+{
+  if (getState () == ISTATE_LOGIN || getState () == ISTATE_SELECT)
+    return true;
+
+  kdDebug(7116) << "IMAP4::makeLogin - checking login" << endl;
+  bool alreadyConnected = getState() == ISTATE_CONNECT;
+  kdDebug(7116) << "IMAP4::makeLogin - alreadyConnected " << alreadyConnected << endl;
+  if (alreadyConnected || connectToHost (myHost.latin1(), myPort))
+  {
+//      fcntl (m_iSock, F_SETFL, (fcntl (m_iSock, F_GETFL) | O_NDELAY));
+
+    setState(ISTATE_CONNECT);
+
+    myAuth = metaData("auth");
+    myTLS  = metaData("tls");
+    kdDebug(7116) << "myAuth: " << myAuth << endl;
+
+    imapCommand *cmd;
+
+    unhandled.clear ();
+    if (!alreadyConnected) while (!parseLoop ()) ;    //get greeting
+    TQString greeting;
+    if (!unhandled.isEmpty()) greeting = unhandled.first().stripWhiteSpace();
+    unhandled.clear ();       //get rid of it
+    cmd = doCommand (new imapCommand ("CAPABILITY", ""));
+
+    kdDebug(7116) << "IMAP4: setHost: capability" << endl;
+    for (TQStringList::Iterator it = imapCapabilities.begin ();
+         it != imapCapabilities.end (); ++it)
+    {
+      kdDebug(7116) << "'" << (*it) << "'" << endl;
+    }
+    completeQueue.removeRef (cmd);
+
+    if (!hasCapability("IMAP4") && !hasCapability("IMAP4rev1"))
+    {
+      error(ERR_COULD_NOT_LOGIN, i18n("The server %1 supports neither "
+        "IMAP4 nor IMAP4rev1.\nIt identified itself with: %2")
+        .arg(myHost).arg(greeting));
+      closeConnection();
+      return false;
+    }
+
+    if (metaData("nologin") == "on") return TRUE;
+
+    if (myTLS == "on" && !hasCapability(TQString("STARTTLS")))
+    {
+      error(ERR_COULD_NOT_LOGIN, i18n("The server does not support TLS.\n"
+        "Disable this security feature to connect unencrypted."));
+      closeConnection();
+      return false;
+    }
+    if ((myTLS == "on" || (canUseTLS() && myTLS != "off")) &&
+      hasCapability(TQString("STARTTLS")))
+    {
+      imapCommand *cmd = doCommand (imapCommand::clientStartTLS());
+      if (cmd->result () == "OK")
+      {
+        completeQueue.removeRef(cmd);
+        int tlsrc = startTLS();
+        if (tlsrc == 1)
+        {
+          kdDebug(7116) << "TLS mode has been enabled." << endl;
+          imapCommand *cmd2 = doCommand (new imapCommand ("CAPABILITY", ""));
+          for (TQStringList::Iterator it = imapCapabilities.begin ();
+                                     it != imapCapabilities.end (); ++it)
+          {
+            kdDebug(7116) << "'" << (*it) << "'" << endl;
+          }
+          completeQueue.removeRef (cmd2);
+        } else {
+          kdWarning(7116) << "TLS mode setup has failed.  Aborting." << endl;
+          error (ERR_COULD_NOT_LOGIN, i18n("Starting TLS failed."));
+          closeConnection();
+          return false;
+        }
+      } else completeQueue.removeRef(cmd);
+    }
+
+    if (myAuth.isEmpty () || myAuth == "*") {
+      if (hasCapability (TQString ("LOGINDISABLED"))) {
+        error (ERR_COULD_NOT_LOGIN, i18n("LOGIN is disabled by the server."));
+        closeConnection();
+        return false;
+      }
+    }
+    else {
+      if (!hasCapability (TQString ("AUTH=") + myAuth)) {
+        error (ERR_COULD_NOT_LOGIN, i18n("The authentication method %1 is not "
+          "supported by the server.").arg(myAuth));
+        closeConnection();
+        return false;
+      }
+    }
+
+    if ( greeting.contains(  TQRegExp(  "Cyrus IMAP4 v2.1" ) ) ) {
+      removeCapability( "ANNOTATEMORE" );
+    }
+
+    // starting from Cyrus IMAP 2.3.9, shared seen flags are available
+    TQRegExp regExp( "Cyrus\\sIMAP[4]{0,1}\\sv(\\d+)\\.(\\d+)\\.(\\d+)", false );
+    if ( regExp.search( greeting ) >= 0 ) {
+      const int major = regExp.cap( 1 ).toInt();
+      const int minor = regExp.cap( 2 ).toInt();
+      const int patch = regExp.cap( 3 ).toInt();
+      if ( major > 2 || (major == 2 && (minor > 3 || (minor == 3 && patch > 9))) ) {
+        kdDebug(7116) << k_funcinfo << "Cyrus IMAP >= 2.3.9 detected, enabling shared seen flag support" << endl;
+        imapCapabilities.append( "x-kmail-sharedseen" );
+      }
+    }
+
+    kdDebug(7116) << "IMAP4::makeLogin - attempting login" << endl;
+
+    TDEIO::AuthInfo authInfo;
+    authInfo.username = myUser;
+    authInfo.password = myPass;
+    authInfo.prompt = i18n ("Username and password for your IMAP account:");
+
+    kdDebug(7116) << "IMAP4::makeLogin - open_PassDlg said user=" << myUser << " pass=xx" << endl;
+
+    TQString resultInfo;
+    if (myAuth.isEmpty () || myAuth == "*")
+    {
+      if (myUser.isEmpty () || myPass.isEmpty ()) {
+        if(openPassDlg (authInfo)) {
+          myUser = authInfo.username;
+          myPass = authInfo.password;
+        }
+      }
+      if (!clientLogin (myUser, myPass, resultInfo))
+        error(TDEIO::ERR_COULD_NOT_AUTHENTICATE, i18n("Unable to login. Probably the "
+        "password is wrong.\nThe server %1 replied:\n%2").arg(myHost).arg(resultInfo));
+    }
+    else
+    {
+#ifdef HAVE_LIBSASL2
+      if (!clientAuthenticate (this, authInfo, myHost, myAuth, mySSL, resultInfo))
+        error(TDEIO::ERR_COULD_NOT_AUTHENTICATE, i18n("Unable to authenticate via %1.\n"
+	"The server %2 replied:\n%3").arg(myAuth).arg(myHost).arg(resultInfo));
+      else {
+        myUser = authInfo.username;
+        myPass = authInfo.password;
+      }
+#else
+      error(TDEIO::ERR_COULD_NOT_LOGIN, i18n("SASL authentication is not compiled into tdeio_imap4."));
+#endif
+    }
+    if ( hasCapability("NAMESPACE") )
+    {
+      // get all namespaces and save the namespace - delimiter association
+      cmd = doCommand( imapCommand::clientNamespace() );
+      if (cmd->result () == "OK")
+      {
+        kdDebug(7116) << "makeLogin - registered namespaces" << endl;
+      }
+      completeQueue.removeRef (cmd);
+    }
+    // get the default delimiter (empty listing)
+    cmd = doCommand( imapCommand::clientList("", "") );
+    if (cmd->result () == "OK")
+    {
+      TQValueListIterator < imapList > it = listResponses.begin();
+      if ( it == listResponses.end() )
+      {
+          // empty answer - this is a buggy imap server
+          // as a fallback we fire a normal listing and take the first answer
+          completeQueue.removeRef (cmd);
+          cmd = doCommand( imapCommand::clientList("", "%") );
+          if (cmd->result () == "OK")
+          {
+              it = listResponses.begin();
+          }
+      }
+      if ( it != listResponses.end() )
+      {
+        namespaceToDelimiter[TQString()] = (*it).hierarchyDelimiter();
+        kdDebug(7116) << "makeLogin - delimiter for empty ns='" <<
+          (*it).hierarchyDelimiter() << "'" << endl;
+        if ( !hasCapability("NAMESPACE") )
+        {
+          // server does not support namespaces
+          TQString nsentry = TQString::number( 0 ) + "=="
+            + (*it).hierarchyDelimiter();
+          imapNamespaces.append( nsentry );
+        }
+      }
+    }
+    completeQueue.removeRef (cmd);
+  } else {
+    kdDebug(7116) << "makeLogin - NO login" << endl;
+  }
+
+  return getState() == ISTATE_LOGIN;
+}
+
+void
+IMAP4Protocol::parseWriteLine (const TQString & aStr)
+{
+  //kdDebug(7116) << "Writing: " << aStr << endl;
+  TQCString writer = aStr.utf8();
+  int len = writer.length();
+
+  // append CRLF if necessary
+  if (len == 0 || (writer[len - 1] != '\n')) {
+    len += 2;
+    writer += "\r\n";
+  }
+
+  // write it
+  write(writer.data(), len);
+}
+
+TQString
+IMAP4Protocol::getMimeType (enum IMAP_TYPE aType)
+{
+  switch (aType)
+  {
+  case ITYPE_DIR:
+    return "inode/directory";
+    break;
+
+  case ITYPE_BOX:
+    return "message/digest";
+    break;
+
+  case ITYPE_DIR_AND_BOX:
+    return "message/directory";
+    break;
+
+  case ITYPE_MSG:
+    return "message/rfc822";
+    break;
+
+  // this should be handled by flushOutput
+  case ITYPE_ATTACH:
+    return "application/octet-stream";
+    break;
+
+  case ITYPE_UNKNOWN:
+  default:
+    return "unknown/unknown";
+  }
+}
+
+
+
+void
+IMAP4Protocol::doListEntry (const KURL & _url, int stretch, imapCache * cache,
+  bool withFlags, bool withSubject)
+{
+  KURL aURL = _url;
+  aURL.setQuery (TQString());
+  const TQString encodedUrl = aURL.url(0, 106); // utf-8
+  doListEntry(encodedUrl, stretch, cache, withFlags, withSubject);
+}
+
+
+
+void
+IMAP4Protocol::doListEntry (const TQString & encodedUrl, int stretch, imapCache * cache,
+  bool withFlags, bool withSubject)
+{
+  if (cache)
+  {
+    UDSEntry entry;
+    UDSAtom atom;
+
+    entry.clear ();
+
+    const TQString uid = TQString::number(cache->getUid());
+
+    atom.m_uds = UDS_NAME;
+    atom.m_str = uid;
+    atom.m_long = 0;
+    if (stretch > 0)
+    {
+      atom.m_str = "0000000000000000" + atom.m_str;
+      atom.m_str = atom.m_str.right (stretch);
+    }
+    if (withSubject)
+    {
+      mailHeader *header = cache->getHeader();
+      if (header)
+        atom.m_str += " " + header->getSubject();
+    }
+    entry.append (atom);
+
+    atom.m_uds = UDS_URL;
+    atom.m_str = encodedUrl; // utf-8
+    if (atom.m_str[atom.m_str.length () - 1] != '/')
+      atom.m_str += '/';
+    atom.m_str += ";UID=" + uid;
+    atom.m_long = 0;
+    entry.append (atom);
+
+    atom.m_uds = UDS_FILE_TYPE;
+    atom.m_str = TQString();
+    atom.m_long = S_IFREG;
+    entry.append (atom);
+
+    atom.m_uds = UDS_SIZE;
+    atom.m_long = cache->getSize();
+    entry.append (atom);
+
+    atom.m_uds = UDS_MIME_TYPE;
+    atom.m_str = "message/rfc822";
+    atom.m_long = 0;
+    entry.append (atom);
+
+    atom.m_uds = UDS_USER;
+    atom.m_str = myUser;
+    entry.append (atom);
+
+    atom.m_uds = TDEIO::UDS_ACCESS;
+    atom.m_long = (withFlags) ? cache->getFlags() : S_IRUSR | S_IXUSR | S_IWUSR;
+    entry.append (atom);
+
+    listEntry (entry, false);
+  }
+}
+
+void
+IMAP4Protocol::doListEntry (const KURL & _url, const TQString & myBox,
+                            const imapList & item, bool appendPath)
+{
+  KURL aURL = _url;
+  aURL.setQuery (TQString());
+  UDSEntry entry;
+  UDSAtom atom;
+  int hdLen = item.hierarchyDelimiter().length();
+
+  {
+    // mailboxName will be appended to the path if appendPath is true
+    TQString mailboxName = item.name ();
+
+    // some beautification
+    if (mailboxName.find (myBox) == 0 && mailboxName.length() > myBox.length())
+    {
+      mailboxName =
+        mailboxName.right (mailboxName.length () - myBox.length ());
+    }
+    if (mailboxName[0] == '/')
+        mailboxName = mailboxName.right (mailboxName.length () - 1);
+    if (mailboxName.left(hdLen) == item.hierarchyDelimiter())
+      mailboxName = mailboxName.right(mailboxName.length () - hdLen);
+    if (mailboxName.right(hdLen) == item.hierarchyDelimiter())
+      mailboxName.truncate(mailboxName.length () - hdLen);
+
+    atom.m_uds = UDS_NAME;
+    if (!item.hierarchyDelimiter().isEmpty() &&
+        mailboxName.find(item.hierarchyDelimiter()) != -1)
+      atom.m_str = mailboxName.section(item.hierarchyDelimiter(), -1);
+    else
+      atom.m_str = mailboxName;
+
+    // konqueror will die with an assertion failure otherwise
+    if (atom.m_str.isEmpty ())
+      atom.m_str = "..";
+
+    if (!atom.m_str.isEmpty ())
+    {
+      atom.m_long = 0;
+      entry.append (atom);
+
+      if (!item.noSelect ())
+      {
+        atom.m_uds = UDS_MIME_TYPE;
+        if (!item.noInferiors ())
+        {
+          atom.m_str = "message/directory";
+        } else {
+          atom.m_str = "message/digest";
+        }
+        atom.m_long = 0;
+        entry.append (atom);
+        mailboxName += '/';
+
+        // explicitly set this as a directory for KFileDialog
+        atom.m_uds = UDS_FILE_TYPE;
+        atom.m_str = TQString();
+        atom.m_long = S_IFDIR;
+        entry.append (atom);
+      }
+      else if (!item.noInferiors ())
+      {
+        atom.m_uds = UDS_MIME_TYPE;
+        atom.m_str = "inode/directory";
+        atom.m_long = 0;
+        entry.append (atom);
+        mailboxName += '/';
+
+        // explicitly set this as a directory for KFileDialog
+        atom.m_uds = UDS_FILE_TYPE;
+        atom.m_str = TQString();
+        atom.m_long = S_IFDIR;
+        entry.append (atom);
+      }
+      else
+      {
+        atom.m_uds = UDS_MIME_TYPE;
+        atom.m_str = "unknown/unknown";
+        atom.m_long = 0;
+        entry.append (atom);
+      }
+
+      atom.m_uds = UDS_URL;
+      TQString path = aURL.path();
+      atom.m_str = aURL.url (0, 106); // utf-8
+      if (appendPath)
+      {
+        if (path[path.length() - 1] == '/' && !path.isEmpty() && path != "/")
+          path.truncate(path.length() - 1);
+        if (!path.isEmpty() && path != "/"
+            && path.right(hdLen) != item.hierarchyDelimiter()) {
+          path += item.hierarchyDelimiter();
+        }
+        path += mailboxName;
+        if (path.upper() == "/INBOX/") {
+            // make sure the client can rely on INBOX
+            path = path.upper();
+        }
+      }
+      aURL.setPath(path);
+      atom.m_str = aURL.url(0, 106); // utf-8
+      atom.m_long = 0;
+      entry.append (atom);
+
+      atom.m_uds = UDS_USER;
+      atom.m_str = myUser;
+      entry.append (atom);
+
+      atom.m_uds = UDS_ACCESS;
+      atom.m_long = S_IRUSR | S_IXUSR | S_IWUSR;
+      entry.append (atom);
+
+      atom.m_uds = UDS_EXTRA;
+      atom.m_str = item.attributesAsString();
+      atom.m_long = 0;
+      entry.append (atom);
+
+      listEntry (entry, false);
+    }
+  }
+}
+
+enum IMAP_TYPE
+IMAP4Protocol::parseURL (const KURL & _url, TQString & _box,
+                         TQString & _section, TQString & _type, TQString & _uid,
+                         TQString & _validity, TQString & _hierarchyDelimiter,
+                         TQString & _info, bool cache)
+{
+  enum IMAP_TYPE retVal;
+  retVal = ITYPE_UNKNOWN;
+
+  imapParser::parseURL (_url, _box, _section, _type, _uid, _validity, _info);
+//  kdDebug(7116) << "URL: query - '" << KURL::decode_string(_url.query()) << "'" << endl;
+
+  // get the delimiter
+  TQString myNamespace = namespaceForBox( _box );
+  kdDebug(7116) << "IMAP4::parseURL - namespace=" << myNamespace << endl;
+  if ( namespaceToDelimiter.contains(myNamespace) )
+  {
+    _hierarchyDelimiter = namespaceToDelimiter[myNamespace];
+    kdDebug(7116) << "IMAP4::parseURL - delimiter=" << _hierarchyDelimiter << endl;
+  }
+
+  if (!_box.isEmpty ())
+  {
+    kdDebug(7116) << "IMAP4::parseURL - box=" << _box << endl;
+
+    if (makeLogin ())
+    {
+      if (getCurrentBox () != _box ||
+          _type == "LIST" || _type == "LSUB" || _type == "LSUBNOCHECK")
+      {
+        if ( cache )
+        {
+          // assume a normal box
+          retVal = ITYPE_DIR_AND_BOX;
+        } else
+        {
+          // start a listing for the box to get the type
+          imapCommand *cmd;
+
+          cmd = doCommand (imapCommand::clientList ("", _box));
+          if (cmd->result () == "OK")
+          {
+            for (TQValueListIterator < imapList > it = listResponses.begin ();
+                it != listResponses.end (); ++it)
+            {
+              //kdDebug(7116) << "IMAP4::parseURL - checking " << _box << " to " << (*it).name() << endl;
+              if (_box == (*it).name ())
+              {
+                if ( !(*it).hierarchyDelimiter().isEmpty() )
+                  _hierarchyDelimiter = (*it).hierarchyDelimiter();
+                if ((*it).noSelect ())
+                {
+                  retVal = ITYPE_DIR;
+                }
+                else if ((*it).noInferiors ())
+                {
+                  retVal = ITYPE_BOX;
+                }
+                else
+                {
+                  retVal = ITYPE_DIR_AND_BOX;
+                }
+              }
+            }
+            // if we got no list response for the box see if it's a prefix
+            if ( retVal == ITYPE_UNKNOWN &&
+                 namespaceToDelimiter.contains(_box) ) {
+              retVal = ITYPE_DIR;
+            }
+          } else {
+            kdDebug(7116) << "IMAP4::parseURL - got error for " << _box << endl;
+          }
+          completeQueue.removeRef (cmd);
+        } // cache
+      }
+      else // current == box
+      {
+        retVal = ITYPE_BOX;
+      }
+    }
+    else
+      kdDebug(7116) << "IMAP4::parseURL: no login!" << endl;
+
+  }
+  else // empty box
+  {
+    // the root is just a dir
+    kdDebug(7116) << "IMAP4: parseURL: box [root]" << endl;
+    retVal = ITYPE_DIR;
+  }
+
+  // see if it is a real sequence or a simple uid
+  if (retVal == ITYPE_BOX || retVal == ITYPE_DIR_AND_BOX)
+  {
+    if (!_uid.isEmpty ())
+    {
+      if (_uid.find (':') == -1 && _uid.find (',') == -1
+          && _uid.find ('*') == -1)
+        retVal = ITYPE_MSG;
+    }
+  }
+  if (retVal == ITYPE_MSG)
+  {
+    if ( (_section.find ("BODY.PEEK[", 0, false) != -1 ||
+          _section.find ("BODY[", 0, false) != -1) &&
+         _section.find(".MIME") == -1 &&
+         _section.find(".HEADER") == -1 )
+      retVal = ITYPE_ATTACH;
+  }
+  if ( _hierarchyDelimiter.isEmpty() &&
+       (_type == "LIST" || _type == "LSUB" || _type == "LSUBNOCHECK") )
+  {
+    // this shouldn't happen but when the delimiter is really empty
+    // we try to reconstruct it from the URL
+    if (!_box.isEmpty())
+    {
+      int start = _url.path().findRev(_box);
+      if (start != -1)
+        _hierarchyDelimiter = _url.path().mid(start-1, start);
+      kdDebug(7116) << "IMAP4::parseURL - reconstructed delimiter:" << _hierarchyDelimiter
+        << " from URL " << _url.path() << endl;
+    }
+    if (_hierarchyDelimiter.isEmpty())
+      _hierarchyDelimiter = "/";
+  }
+  kdDebug(7116) << "IMAP4::parseURL - return " << retVal << endl;
+
+  return retVal;
+}
+
+int
+IMAP4Protocol::outputLine (const TQCString & _str, int len)
+{
+  if (len == -1) {
+    len = _str.length();
+  }
+
+  if (cacheOutput)
+  {
+    if ( !outputBuffer.isOpen() ) {
+      outputBuffer.open(IO_WriteOnly);
+    }
+    outputBuffer.at(outputBufferIndex);
+    outputBuffer.writeBlock(_str.data(), len);
+    outputBufferIndex += len;
+    return 0;
+  }
+
+  TQByteArray temp;
+  bool relay = relayEnabled;
+
+  relayEnabled = true;
+  temp.setRawData (_str.data (), len);
+  parseRelay (temp);
+  temp.resetRawData (_str.data (), len);
+
+  relayEnabled = relay;
+  return 0;
+}
+
+void IMAP4Protocol::flushOutput(TQString contentEncoding)
+{
+  // send out cached data to the application
+  if (outputBufferIndex == 0)
+    return;
+  outputBuffer.close();
+  outputCache.resize(outputBufferIndex);
+  if (decodeContent)
+  {
+    // get the coding from the MIME header
+    TQByteArray decoded;
+    if (contentEncoding.find("quoted-printable", 0, false) == 0)
+      decoded = KCodecs::quotedPrintableDecode(outputCache);
+    else if (contentEncoding.find("base64", 0, false) == 0)
+      KCodecs::base64Decode(outputCache, decoded);
+    else
+      decoded = outputCache;
+
+    TQString mimetype = KMimeType::findByContent( decoded )->name();
+    kdDebug(7116) << "IMAP4::flushOutput - mimeType " << mimetype << endl;
+    mimeType(mimetype);
+    decodeContent = false;
+    data( decoded );
+  } else {
+    data( outputCache );
+  }
+  mProcessedSize += outputBufferIndex;
+  processedSize( mProcessedSize );
+  outputBufferIndex = 0;
+  outputCache[0] = '\0';
+  outputBuffer.setBuffer(outputCache);
+}
+
+ssize_t IMAP4Protocol::myRead(void *data, ssize_t len)
+{
+  if (readBufferLen)
+  {
+    ssize_t copyLen = (len < readBufferLen) ? len : readBufferLen;
+    memcpy(data, readBuffer, copyLen);
+    readBufferLen -= copyLen;
+    if (readBufferLen) memmove(readBuffer, &readBuffer[copyLen], readBufferLen);
+    return copyLen;
+  }
+  if (!isConnectionValid()) return 0;
+  waitForResponse( responseTimeout() );
+  return read(data, len);
+}
+
+bool
+IMAP4Protocol::assureBox (const TQString & aBox, bool readonly)
+{
+  if (aBox.isEmpty()) return false;
+
+  imapCommand *cmd = 0;
+
+  if (aBox != getCurrentBox () || (!getSelected().readWrite() && !readonly))
+  {
+    // open the box with the appropriate mode
+    kdDebug(7116) << "IMAP4Protocol::assureBox - opening box" << endl;
+    selectInfo = imapInfo();
+    cmd = doCommand (imapCommand::clientSelect (aBox, readonly));
+    bool ok = cmd->result() == "OK";
+    TQString cmdInfo = cmd->resultInfo();
+    completeQueue.removeRef (cmd);
+
+    if (!ok)
+    {
+      bool found = false;
+      cmd = doCommand (imapCommand::clientList ("", aBox));
+      if (cmd->result () == "OK")
+      {
+        for (TQValueListIterator < imapList > it = listResponses.begin ();
+             it != listResponses.end (); ++it)
+        {
+          if (aBox == (*it).name ()) found = true;
+        }
+      }
+      completeQueue.removeRef (cmd);
+      if (found) {
+        if (cmdInfo.find("permission", 0, false) != -1) {
+          // not allowed to enter this folder
+          error(ERR_ACCESS_DENIED, cmdInfo);
+        } else {
+          error(ERR_SLAVE_DEFINED, i18n("Unable to open folder %1. The server replied: %2").arg(aBox).arg(cmdInfo));
+        }
+      } else {
+        error(TDEIO::ERR_DOES_NOT_EXIST, aBox);
+      }
+      return false;
+    }
+  }
+  else
+  {
+    // Give the server a chance to deliver updates every ten seconds.
+    // Doing this means a server roundtrip and since assureBox is called
+    // after every mail, we do it with a timeout.
+    kdDebug(7116) << "IMAP4Protocol::assureBox - reusing box" << endl;
+    if ( mTimeOfLastNoop.secsTo( TQDateTime::currentDateTime() ) > 10 ) {
+      cmd = doCommand (imapCommand::clientNoop ());
+      completeQueue.removeRef (cmd);
+      mTimeOfLastNoop = TQDateTime::currentDateTime();
+      kdDebug(7116) << "IMAP4Protocol::assureBox - noop timer fired" << endl;
+    }
+  }
+
+  // if it is the mode we want
+  if (!getSelected().readWrite() && !readonly)
+  {
+    error(TDEIO::ERR_CANNOT_OPEN_FOR_WRITING, aBox);
+    return false;
+  }
+
+  return true;
+}