summaryrefslogtreecommitdiffstats
path: root/tdeioslaves/imap4/imap4.cc
diff options
context:
space:
mode:
Diffstat (limited to 'tdeioslaves/imap4/imap4.cc')
-rw-r--r--tdeioslaves/imap4/imap4.cc2734
1 files changed, 2734 insertions, 0 deletions
diff --git a/tdeioslaves/imap4/imap4.cc b/tdeioslaves/imap4/imap4.cc
new file mode 100644
index 000000000..0069b22da
--- /dev/null
+++ b/tdeioslaves/imap4/imap4.cc
@@ -0,0 +1,2734 @@
+/**********************************************************************
+ *
+ * imap4.cc - IMAP4rev1 KIOSlave
+ * Copyright (C) 2001-2002 Michael Haeckel <haeckel@kde.org>
+ * Copyright (C) 1999 John Corey
+ *
+ * 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>
+
+#ifdef HAVE_LIBSASL2
+extern "C" {
+#include <sasl/sasl.h>
+}
+#endif
+
+#include <tqbuffer.h>
+#include <tqdatetime.h>
+#include <tqregexp.h>
+#include <kprotocolmanager.h>
+#include <kmessagebox.h>
+#include <kdebug.h>
+#include <tdeio/connection.h>
+#include <tdeio/slaveinterface.h>
+#include <tdeio/passdlg.h>
+#include <klocale.h>
+#include <kmimetype.h>
+#include <kmdcodec.h>
+
+#include "tdepimmacros.h"
+
+#define IMAP_PROTOCOL "imap"
+#define IMAP_SSL_PROTOCOL "imaps"
+
+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 ("kio_imap4");
+ if (argc != 4)
+ {
+ fprintf(stderr, "Usage: kio_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)
+{
+ int pid, status;
+
+ while (true && 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);
+ return;
+ }
+ }
+}
+
+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;
+ 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, false)) 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 kio_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) memcpy(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;
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-17 05:48:44 +0000