/********************************************************************** * * imap4.cc - IMAP4rev1 KIOSlave * Copyright (C) 2001-2002 Michael Haeckel * 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 #endif #include "imap4.h" #include "rfcdecoder.h" #include #include #include #include #include #include #ifdef HAVE_LIBSASL2 extern "C" { #include } #endif #include #include #include #include #include #include #include #include #include #include #include #include #include "tdepimmacros.h" #define IMAP_PROTOCOL "imap" #define IMAP_SSL_PROTOCOL "imaps" #define IMAP_PORT 143 #define IMAPS_PORT 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) { 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); 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 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) ? IMAPS_PORT : IMAP_PORT; 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, 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 attributes (name and value) TQString entry; TQMap 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; }