diff options
Diffstat (limited to 'kmail/kmmessage.cpp')
| -rw-r--r-- | kmail/kmmessage.cpp | 4373 |
1 files changed, 4373 insertions, 0 deletions
diff --git a/kmail/kmmessage.cpp b/kmail/kmmessage.cpp new file mode 100644 index 000000000..9c006b685 --- /dev/null +++ b/kmail/kmmessage.cpp @@ -0,0 +1,4373 @@ +// -*- mode: C++; c-file-style: "gnu" -*- +// kmmessage.cpp + +// if you do not want GUI elements in here then set ALLOW_GUI to 0. +#include <config.h> +// needed temporarily until KMime is replacing the partNode helper class: +#include "partNode.h" + + +#define ALLOW_GUI 1 +#include "kmkernel.h" +#include "kmmessage.h" +#include "mailinglist-magic.h" +#include "messageproperty.h" +using KMail::MessageProperty; +#include "objecttreeparser.h" +using KMail::ObjectTreeParser; +#include "kmfolderindex.h" +#include "undostack.h" +#include "kmversion.h" +#include "headerstrategy.h" +#include "globalsettings.h" +using KMail::HeaderStrategy; +#include "kmaddrbook.h" +#include "kcursorsaver.h" +#include "templateparser.h" + +#include <libkpimidentities/identity.h> +#include <libkpimidentities/identitymanager.h> +#include <libemailfunctions/email.h> + +#include <kasciistringtools.h> + +#include <kpgpblock.h> +#include <kaddrbook.h> + +#include <kapplication.h> +#include <kglobalsettings.h> +#include <kdebug.h> +#include <kconfig.h> +#include <khtml_part.h> +#include <kuser.h> +#include <kidna.h> +#include <kasciistricmp.h> + +#include <qcursor.h> +#include <qtextcodec.h> +#include <qmessagebox.h> +#include <kmime_util.h> +#include <kmime_charfreq.h> + +#include <kmime_header_parsing.h> +using KMime::HeaderParsing::parseAddressList; +using namespace KMime::Types; + +#include <mimelib/body.h> +#include <mimelib/field.h> +#include <mimelib/mimepp.h> +#include <mimelib/string.h> +#include <assert.h> +#include <sys/time.h> +#include <time.h> +#include <klocale.h> +#include <stdlib.h> +#include <unistd.h> +#include "util.h" + +#if ALLOW_GUI +#include <kmessagebox.h> +#endif + +using namespace KMime; + +static DwString emptyString(""); + +// Values that are set from the config file with KMMessage::readConfig() +static QString sReplyLanguage, sReplyStr, sReplyAllStr, sIndentPrefixStr; +static bool sSmartQuote, + sWordWrap; +static int sWrapCol; +static QStringList sPrefCharsets; + +QString KMMessage::sForwardStr; +const HeaderStrategy * KMMessage::sHeaderStrategy = HeaderStrategy::rich(); +//helper +static void applyHeadersToMessagePart( DwHeaders& headers, KMMessagePart* aPart ); + +QValueList<KMMessage*> KMMessage::sPendingDeletes; + +//----------------------------------------------------------------------------- +KMMessage::KMMessage(DwMessage* aMsg) + : KMMsgBase() +{ + init( aMsg ); + // aMsg might need assembly + mNeedsAssembly = true; +} + +//----------------------------------------------------------------------------- +KMMessage::KMMessage(KMFolder* parent): KMMsgBase(parent) +{ + init(); +} + + +//----------------------------------------------------------------------------- +KMMessage::KMMessage(KMMsgInfo& msgInfo): KMMsgBase() +{ + init(); + // now overwrite a few from the msgInfo + mMsgSize = msgInfo.msgSize(); + mFolderOffset = msgInfo.folderOffset(); + mStatus = msgInfo.status(); + mEncryptionState = msgInfo.encryptionState(); + mSignatureState = msgInfo.signatureState(); + mMDNSentState = msgInfo.mdnSentState(); + mDate = msgInfo.date(); + mFileName = msgInfo.fileName(); + KMMsgBase::assign(&msgInfo); +} + + +//----------------------------------------------------------------------------- +KMMessage::KMMessage(const KMMessage& other) : + KMMsgBase( other ), + ISubject(), + mMsg(0) +{ + init(); // to be safe + assign( other ); +} + +void KMMessage::init( DwMessage* aMsg ) +{ + mNeedsAssembly = false; + if ( aMsg ) { + mMsg = aMsg; + } else { + mMsg = new DwMessage; + } + mOverrideCodec = 0; + mDecodeHTML = false; + mComplete = true; + mReadyToShow = true; + mMsgSize = 0; + mMsgLength = 0; + mFolderOffset = 0; + mStatus = KMMsgStatusNew; + mEncryptionState = KMMsgEncryptionStateUnknown; + mSignatureState = KMMsgSignatureStateUnknown; + mMDNSentState = KMMsgMDNStateUnknown; + mDate = 0; + mUnencryptedMsg = 0; + mLastUpdated = 0; + mCursorPos = 0; + mMsgInfo = 0; + mIsParsed = false; +} + +void KMMessage::assign( const KMMessage& other ) +{ + MessageProperty::forget( this ); + delete mMsg; + delete mUnencryptedMsg; + + mNeedsAssembly = true;//other.mNeedsAssembly; + if( other.mMsg ) + mMsg = new DwMessage( *(other.mMsg) ); + else + mMsg = 0; + mOverrideCodec = other.mOverrideCodec; + mDecodeHTML = other.mDecodeHTML; + mMsgSize = other.mMsgSize; + mMsgLength = other.mMsgLength; + mFolderOffset = other.mFolderOffset; + mStatus = other.mStatus; + mEncryptionState = other.mEncryptionState; + mSignatureState = other.mSignatureState; + mMDNSentState = other.mMDNSentState; + mIsParsed = other.mIsParsed; + mDate = other.mDate; + if( other.hasUnencryptedMsg() ) + mUnencryptedMsg = new KMMessage( *other.unencryptedMsg() ); + else + mUnencryptedMsg = 0; + setDrafts( other.drafts() ); + setTemplates( other.templates() ); + //mFileName = ""; // we might not want to copy the other messages filename (?) + //KMMsgBase::assign( &other ); +} + +//----------------------------------------------------------------------------- +KMMessage::~KMMessage() +{ + delete mMsgInfo; + delete mMsg; + kmkernel->undoStack()->msgDestroyed( this ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setReferences(const QCString& aStr) +{ + if (!aStr) return; + mMsg->Headers().References().FromString(aStr); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::id() const +{ + DwHeaders& header = mMsg->Headers(); + if (header.HasMessageId()) + return KMail::Util::CString( header.MessageId().AsString() ); + else + return ""; +} + + +//----------------------------------------------------------------------------- +//WARNING: This method updates the memory resident cache of serial numbers +//WARNING: held in MessageProperty, but it does not update the persistent +//WARNING: store of serial numbers on the file system that is managed by +//WARNING: KMMsgDict +void KMMessage::setMsgSerNum(unsigned long newMsgSerNum) +{ + MessageProperty::setSerialCache( this, newMsgSerNum ); +} + + +//----------------------------------------------------------------------------- +bool KMMessage::isMessage() const +{ + return true; +} + +//----------------------------------------------------------------------------- +bool KMMessage::transferInProgress() const +{ + return MessageProperty::transferInProgress( getMsgSerNum() ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setTransferInProgress(bool value, bool force) +{ + MessageProperty::setTransferInProgress( getMsgSerNum(), value, force ); + if ( !transferInProgress() && sPendingDeletes.contains( this ) ) { + sPendingDeletes.remove( this ); + if ( parent() ) { + int idx = parent()->find( this ); + if ( idx > 0 ) { + parent()->removeMsg( idx ); + } + } + } +} + + + +bool KMMessage::isUrgent() const { + return headerField( "Priority" ).contains( "urgent", false ) + || headerField( "X-Priority" ).startsWith( "2" ); +} + +//----------------------------------------------------------------------------- +void KMMessage::setUnencryptedMsg( KMMessage* unencrypted ) +{ + delete mUnencryptedMsg; + mUnencryptedMsg = unencrypted; +} + +//----------------------------------------------------------------------------- +//FIXME: move to libemailfunctions +KPIM::EmailParseResult KMMessage::isValidEmailAddressList( const QString& aStr, + QString& brokenAddress ) +{ + if ( aStr.isEmpty() ) { + return KPIM::AddressEmpty; + } + + QStringList list = KPIM::splitEmailAddrList( aStr ); + for( QStringList::const_iterator it = list.begin(); it != list.end(); ++it ) { + KPIM::EmailParseResult errorCode = KPIM::isValidEmailAddress( *it ); + if ( errorCode != KPIM::AddressOk ) { + brokenAddress = ( *it ); + return errorCode; + } + } + return KPIM::AddressOk; +} + +//----------------------------------------------------------------------------- +const DwString& KMMessage::asDwString() const +{ + if (mNeedsAssembly) + { + mNeedsAssembly = false; + mMsg->Assemble(); + } + return mMsg->AsString(); +} + +//----------------------------------------------------------------------------- +const DwMessage* KMMessage::asDwMessage() +{ + if (mNeedsAssembly) + { + mNeedsAssembly = false; + mMsg->Assemble(); + } + return mMsg; +} + +//----------------------------------------------------------------------------- +QCString KMMessage::asString() const { + return KMail::Util::CString( asDwString() ); +} + + +QByteArray KMMessage::asSendableString() const +{ + KMMessage msg( new DwMessage( *this->mMsg ) ); + msg.removePrivateHeaderFields(); + msg.removeHeaderField("Bcc"); + return KMail::Util::ByteArray( msg.asDwString() ); // and another copy again! +} + +QCString KMMessage::headerAsSendableString() const +{ + KMMessage msg( new DwMessage( *this->mMsg ) ); + msg.removePrivateHeaderFields(); + msg.removeHeaderField("Bcc"); + return msg.headerAsString().latin1(); +} + +void KMMessage::removePrivateHeaderFields() { + removeHeaderField("Status"); + removeHeaderField("X-Status"); + removeHeaderField("X-KMail-EncryptionState"); + removeHeaderField("X-KMail-SignatureState"); + removeHeaderField("X-KMail-MDN-Sent"); + removeHeaderField("X-KMail-Transport"); + removeHeaderField("X-KMail-Identity"); + removeHeaderField("X-KMail-Fcc"); + removeHeaderField("X-KMail-Redirect-From"); + removeHeaderField("X-KMail-Link-Message"); + removeHeaderField("X-KMail-Link-Type"); + removeHeaderField( "X-KMail-Markup" ); +} + +//----------------------------------------------------------------------------- +void KMMessage::setStatusFields() +{ + char str[2] = { 0, 0 }; + + setHeaderField("Status", status() & KMMsgStatusNew ? "R" : "RO"); + setHeaderField("X-Status", statusToStr(status())); + + str[0] = (char)encryptionState(); + setHeaderField("X-KMail-EncryptionState", str); + + str[0] = (char)signatureState(); + //kdDebug(5006) << "Setting SignatureState header field to " << str[0] << endl; + setHeaderField("X-KMail-SignatureState", str); + + str[0] = static_cast<char>( mdnSentState() ); + setHeaderField("X-KMail-MDN-Sent", str); + + // We better do the assembling ourselves now to prevent the + // mimelib from changing the message *body*. (khz, 10.8.2002) + mNeedsAssembly = false; + mMsg->Headers().Assemble(); + mMsg->Assemble( mMsg->Headers(), + mMsg->Body() ); +} + + +//---------------------------------------------------------------------------- +QString KMMessage::headerAsString() const +{ + DwHeaders& header = mMsg->Headers(); + header.Assemble(); + if ( header.AsString().empty() ) + return QString::null; + return QString::fromLatin1( header.AsString().c_str() ); +} + + +//----------------------------------------------------------------------------- +DwMediaType& KMMessage::dwContentType() +{ + return mMsg->Headers().ContentType(); +} + +void KMMessage::fromByteArray( const QByteArray & ba, bool setStatus ) { + return fromDwString( DwString( ba.data(), ba.size() ), setStatus ); +} + +void KMMessage::fromString( const QCString & str, bool aSetStatus ) { + return fromDwString( KMail::Util::dwString( str ), aSetStatus ); +} + +void KMMessage::fromDwString(const DwString& str, bool aSetStatus) +{ + delete mMsg; + mMsg = new DwMessage; + mMsg->FromString( str ); + mMsg->Parse(); + + if (aSetStatus) { + setStatus(headerField("Status").latin1(), headerField("X-Status").latin1()); + setEncryptionStateChar( headerField("X-KMail-EncryptionState").at(0) ); + setSignatureStateChar( headerField("X-KMail-SignatureState").at(0) ); + setMDNSentState( static_cast<KMMsgMDNSentState>( headerField("X-KMail-MDN-Sent").at(0).latin1() ) ); + } + if (attachmentState() == KMMsgAttachmentUnknown && readyToShow()) + updateAttachmentState(); + + mNeedsAssembly = false; + mDate = date(); +} + + +//----------------------------------------------------------------------------- +QString KMMessage::formatString(const QString& aStr) const +{ + QString result, str; + QChar ch; + uint j; + + if (aStr.isEmpty()) + return aStr; + + unsigned int strLength(aStr.length()); + for (uint i=0; i<strLength;) { + ch = aStr[i++]; + if (ch == '%') { + ch = aStr[i++]; + switch ((char)ch) { + case 'D': + /* I'm not too sure about this change. Is it not possible + to have a long form of the date used? I don't + like this change to a short XX/XX/YY date format. + At least not for the default. -sanders */ + result += KMime::DateFormatter::formatDate( KMime::DateFormatter::Localized, + date(), sReplyLanguage, false ); + break; + case 'e': + result += from(); + break; + case 'F': + result += fromStrip(); + break; + case 'f': + { + str = fromStrip(); + + for (j=0; str[j]>' '; j++) + ; + unsigned int strLength(str.length()); + for (; j < strLength && str[j] <= ' '; j++) + ; + result += str[0]; + if (str[j]>' ') + result += str[j]; + else + if (str[1]>' ') + result += str[1]; + } + break; + case 'T': + result += toStrip(); + break; + case 't': + result += to(); + break; + case 'C': + result += ccStrip(); + break; + case 'c': + result += cc(); + break; + case 'S': + result += subject(); + break; + case '_': + result += ' '; + break; + case 'L': + result += "\n"; + break; + case '%': + result += '%'; + break; + default: + result += '%'; + result += ch; + break; + } + } else + result += ch; + } + return result; +} + +static void removeTrailingSpace( QString &line ) +{ + int i = line.length()-1; + while( (i >= 0) && ((line[i] == ' ') || (line[i] == '\t'))) + i--; + line.truncate( i+1); +} + +static QString splitLine( QString &line) +{ + removeTrailingSpace( line ); + int i = 0; + int j = -1; + int l = line.length(); + + // TODO: Replace tabs with spaces first. + + while(i < l) + { + QChar c = line[i]; + if ((c == '>') || (c == ':') || (c == '|')) + j = i+1; + else if ((c != ' ') && (c != '\t')) + break; + i++; + } + + if ( j <= 0 ) + { + return ""; + } + if ( i == l ) + { + QString result = line.left(j); + line = QString::null; + return result; + } + + QString result = line.left(j); + line = line.mid(j); + return result; +} + +static QString flowText(QString &text, const QString& indent, int maxLength) +{ + maxLength--; + if (text.isEmpty()) + { + return indent+"<NULL>\n"; + } + QString result; + while (1) + { + int i; + if ((int) text.length() > maxLength) + { + i = maxLength; + while( (i >= 0) && (text[i] != ' ')) + i--; + if (i <= 0) + { + // Couldn't break before maxLength. + i = maxLength; +// while( (i < (int) text.length()) && (text[i] != ' ')) +// i++; + } + } + else + { + i = text.length(); + } + + QString line = text.left(i); + if (i < (int) text.length()) + text = text.mid(i); + else + text = QString::null; + + result += indent + line + '\n'; + + if (text.isEmpty()) + return result; + } +} + +static bool flushPart(QString &msg, QStringList &part, + const QString &indent, int maxLength) +{ + maxLength -= indent.length(); + if (maxLength < 20) maxLength = 20; + + // Remove empty lines at end of quote + while ((part.begin() != part.end()) && part.last().isEmpty()) + { + part.remove(part.fromLast()); + } + + QString text; + for(QStringList::Iterator it2 = part.begin(); + it2 != part.end(); + it2++) + { + QString line = (*it2); + + if (line.isEmpty()) + { + if (!text.isEmpty()) + msg += flowText(text, indent, maxLength); + msg += indent + '\n'; + } + else + { + if (text.isEmpty()) + text = line; + else + text += ' '+line.stripWhiteSpace(); + + if (((int) text.length() < maxLength) || ((int) line.length() < (maxLength-10))) + msg += flowText(text, indent, maxLength); + } + } + if (!text.isEmpty()) + msg += flowText(text, indent, maxLength); + + bool appendEmptyLine = true; + if (!part.count()) + appendEmptyLine = false; + + part.clear(); + return appendEmptyLine; +} + +static QString stripSignature( const QString & msg, bool clearSigned ) { + if ( clearSigned ) + return msg.left( msg.findRev( QRegExp( "\n--\\s?\n" ) ) ); + else + return msg.left( msg.findRev( "\n-- \n" ) ); +} + +QString KMMessage::smartQuote( const QString & msg, int maxLineLength ) +{ + QStringList part; + QString oldIndent; + bool firstPart = true; + + + const QStringList lines = QStringList::split('\n', msg, true); + + QString result; + for(QStringList::const_iterator it = lines.begin(); + it != lines.end(); + ++it) + { + QString line = *it; + + const QString indent = splitLine( line ); + + if ( line.isEmpty()) + { + if (!firstPart) + part.append(QString::null); + continue; + }; + + if (firstPart) + { + oldIndent = indent; + firstPart = false; + } + + if (oldIndent != indent) + { + QString fromLine; + // Search if the last non-blank line could be "From" line + if (part.count() && (oldIndent.length() < indent.length())) + { + QStringList::Iterator it2 = part.fromLast(); + while( (it2 != part.end()) && (*it2).isEmpty()) + --it2; + + if ((it2 != part.end()) && ((*it2).endsWith(":"))) + { + fromLine = oldIndent + (*it2) + '\n'; + part.remove(it2); + } + } + if (flushPart( result, part, oldIndent, maxLineLength)) + { + if (oldIndent.length() > indent.length()) + result += indent + '\n'; + else + result += oldIndent + '\n'; + } + if (!fromLine.isEmpty()) + { + result += fromLine; + } + oldIndent = indent; + } + part.append(line); + } + flushPart( result, part, oldIndent, maxLineLength); + return result; +} + + +//----------------------------------------------------------------------------- +void KMMessage::parseTextStringFromDwPart( partNode * root, + QCString& parsedString, + const QTextCodec*& codec, + bool& isHTML ) const +{ + if ( !root ) return; + + isHTML = false; + // initialy parse the complete message to decrypt any encrypted parts + { + ObjectTreeParser otp( 0, 0, true, false, true ); + otp.parseObjectTree( root ); + } + partNode * curNode = root->findType( DwMime::kTypeText, + DwMime::kSubtypeUnknown, + true, + false ); + kdDebug(5006) << "\n\n======= KMMessage::parseTextStringFromDwPart() - " + << ( curNode ? "text part found!\n" : "sorry, no text node!\n" ) << endl; + if( curNode ) { + isHTML = DwMime::kSubtypeHtml == curNode->subType(); + // now parse the TEXT message part we want to quote + ObjectTreeParser otp( 0, 0, true, false, true ); + otp.parseObjectTree( curNode ); + parsedString = otp.rawReplyString(); + codec = curNode->msgPart().codec(); + } +} + +//----------------------------------------------------------------------------- + +QString KMMessage::asPlainText( bool aStripSignature, bool allowDecryption ) const { + QCString parsedString; + bool isHTML = false; + const QTextCodec * codec = 0; + + partNode * root = partNode::fromMessage( this ); + if ( !root ) return QString::null; + parseTextStringFromDwPart( root, parsedString, codec, isHTML ); + delete root; + + if ( mOverrideCodec || !codec ) + codec = this->codec(); + + if ( parsedString.isEmpty() ) + return QString::null; + + bool clearSigned = false; + QString result; + + // decrypt + if ( allowDecryption ) { + QPtrList<Kpgp::Block> pgpBlocks; + QStrList nonPgpBlocks; + if ( Kpgp::Module::prepareMessageForDecryption( parsedString, + pgpBlocks, + nonPgpBlocks ) ) { + // Only decrypt/strip off the signature if there is only one OpenPGP + // block in the message + if ( pgpBlocks.count() == 1 ) { + Kpgp::Block * block = pgpBlocks.first(); + if ( block->type() == Kpgp::PgpMessageBlock || + block->type() == Kpgp::ClearsignedBlock ) { + if ( block->type() == Kpgp::PgpMessageBlock ) { + // try to decrypt this OpenPGP block + block->decrypt(); + } else { + // strip off the signature + block->verify(); + clearSigned = true; + } + + result = codec->toUnicode( nonPgpBlocks.first() ) + + codec->toUnicode( block->text() ) + + codec->toUnicode( nonPgpBlocks.last() ); + } + } + } + } + + if ( result.isEmpty() ) { + result = codec->toUnicode( parsedString ); + if ( result.isEmpty() ) + return result; + } + + // html -> plaintext conversion, if necessary: + if ( isHTML && mDecodeHTML ) { + KHTMLPart htmlPart; + htmlPart.setOnlyLocalReferences( true ); + htmlPart.setMetaRefreshEnabled( false ); + htmlPart.setPluginsEnabled( false ); + htmlPart.setJScriptEnabled( false ); + htmlPart.setJavaEnabled( false ); + htmlPart.begin(); + htmlPart.write( result ); + htmlPart.end(); + htmlPart.selectAll(); + result = htmlPart.selectedText(); + } + + // strip the signature (footer): + if ( aStripSignature ) + return stripSignature( result, clearSigned ); + else + return result; +} + +QString KMMessage::asQuotedString( const QString& aHeaderStr, + const QString& aIndentStr, + const QString& selection /* = QString::null */, + bool aStripSignature /* = true */, + bool allowDecryption /* = true */) const +{ + QString content = selection.isEmpty() ? + asPlainText( aStripSignature, allowDecryption ) : selection ; + + // Remove blank lines at the beginning: + const int firstNonWS = content.find( QRegExp( "\\S" ) ); + const int lineStart = content.findRev( '\n', firstNonWS ); + if ( lineStart >= 0 ) + content.remove( 0, static_cast<unsigned int>( lineStart ) ); + + const QString indentStr = formatString( aIndentStr ); + + content.replace( '\n', '\n' + indentStr ); + content.prepend( indentStr ); + content += '\n'; + + const QString headerStr = formatString( aHeaderStr ); + if ( sSmartQuote && sWordWrap ) + return headerStr + smartQuote( content, sWrapCol ); + return headerStr + content; +} + +//----------------------------------------------------------------------------- +KMMessage* KMMessage::createReply( KMail::ReplyStrategy replyStrategy, + QString selection /* = QString::null */, + bool noQuote /* = false */, + bool allowDecryption /* = true */, + bool selectionIsBody /* = false */, + const QString &tmpl /* = QString::null */ ) +{ + KMMessage* msg = new KMMessage; + QString str, replyStr, mailingListStr, replyToStr, toStr; + QStringList mailingListAddresses; + QCString refStr, headerName; + bool replyAll = true; + + msg->initFromMessage(this); + + MailingList::name(this, headerName, mailingListStr); + replyToStr = replyTo(); + + msg->setCharset("utf-8"); + + // determine the mailing list posting address + if ( parent() && parent()->isMailingListEnabled() && + !parent()->mailingListPostAddress().isEmpty() ) { + mailingListAddresses << parent()->mailingListPostAddress(); + } + if ( headerField("List-Post").find( "mailto:", 0, false ) != -1 ) { + QString listPost = headerField("List-Post"); + QRegExp rx( "<mailto:([^@>]+)@([^>]+)>", false ); + if ( rx.search( listPost, 0 ) != -1 ) // matched + mailingListAddresses << rx.cap(1) + '@' + rx.cap(2); + } + + // use the "On ... Joe User wrote:" header by default + replyStr = sReplyAllStr; + + switch( replyStrategy ) { + case KMail::ReplySmart : { + if ( !headerField( "Mail-Followup-To" ).isEmpty() ) { + toStr = headerField( "Mail-Followup-To" ); + } + else if ( !replyToStr.isEmpty() ) { + // assume a Reply-To header mangling mailing list + toStr = replyToStr; + } + else if ( !mailingListAddresses.isEmpty() ) { + toStr = mailingListAddresses[0]; + } + else { + // doesn't seem to be a mailing list, reply to From: address + toStr = from(); + replyStr = sReplyStr; // reply to author, so use "On ... you wrote:" + replyAll = false; + } + // strip all my addresses from the list of recipients + QStringList recipients = KPIM::splitEmailAddrList( toStr ); + toStr = stripMyAddressesFromAddressList( recipients ).join(", "); + // ... unless the list contains only my addresses (reply to self) + if ( toStr.isEmpty() && !recipients.isEmpty() ) + toStr = recipients[0]; + + break; + } + case KMail::ReplyList : { + if ( !headerField( "Mail-Followup-To" ).isEmpty() ) { + toStr = headerField( "Mail-Followup-To" ); + } + else if ( !mailingListAddresses.isEmpty() ) { + toStr = mailingListAddresses[0]; + } + else if ( !replyToStr.isEmpty() ) { + // assume a Reply-To header mangling mailing list + toStr = replyToStr; + } + // strip all my addresses from the list of recipients + QStringList recipients = KPIM::splitEmailAddrList( toStr ); + toStr = stripMyAddressesFromAddressList( recipients ).join(", "); + + break; + } + case KMail::ReplyAll : { + QStringList recipients; + QStringList ccRecipients; + + // add addresses from the Reply-To header to the list of recipients + if( !replyToStr.isEmpty() ) { + recipients += KPIM::splitEmailAddrList( replyToStr ); + // strip all possible mailing list addresses from the list of Reply-To + // addresses + for ( QStringList::const_iterator it = mailingListAddresses.begin(); + it != mailingListAddresses.end(); + ++it ) { + recipients = stripAddressFromAddressList( *it, recipients ); + } + } + + if ( !mailingListAddresses.isEmpty() ) { + // this is a mailing list message + if ( recipients.isEmpty() && !from().isEmpty() ) { + // The sender didn't set a Reply-to address, so we add the From + // address to the list of CC recipients. + ccRecipients += from(); + kdDebug(5006) << "Added " << from() << " to the list of CC recipients" + << endl; + } + // if it is a mailing list, add the posting address + recipients.prepend( mailingListAddresses[0] ); + } + else { + // this is a normal message + if ( recipients.isEmpty() && !from().isEmpty() ) { + // in case of replying to a normal message only then add the From + // address to the list of recipients if there was no Reply-to address + recipients += from(); + kdDebug(5006) << "Added " << from() << " to the list of recipients" + << endl; + } + } + + // strip all my addresses from the list of recipients + toStr = stripMyAddressesFromAddressList( recipients ).join(", "); + + // merge To header and CC header into a list of CC recipients + if( !cc().isEmpty() || !to().isEmpty() ) { + QStringList list; + if (!to().isEmpty()) + list += KPIM::splitEmailAddrList(to()); + if (!cc().isEmpty()) + list += KPIM::splitEmailAddrList(cc()); + for( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) { + if( !addressIsInAddressList( *it, recipients ) + && !addressIsInAddressList( *it, ccRecipients ) ) { + ccRecipients += *it; + kdDebug(5006) << "Added " << *it << " to the list of CC recipients" + << endl; + } + } + } + + if ( !ccRecipients.isEmpty() ) { + // strip all my addresses from the list of CC recipients + ccRecipients = stripMyAddressesFromAddressList( ccRecipients ); + + // in case of a reply to self toStr might be empty. if that's the case + // then propagate a cc recipient to To: (if there is any). + if ( toStr.isEmpty() && !ccRecipients.isEmpty() ) { + toStr = ccRecipients[0]; + ccRecipients.pop_front(); + } + + msg->setCc( ccRecipients.join(", ") ); + } + + if ( toStr.isEmpty() && !recipients.isEmpty() ) { + // reply to self without other recipients + toStr = recipients[0]; + } + break; + } + case KMail::ReplyAuthor : { + if ( !replyToStr.isEmpty() ) { + QStringList recipients = KPIM::splitEmailAddrList( replyToStr ); + // strip the mailing list post address from the list of Reply-To + // addresses since we want to reply in private + for ( QStringList::const_iterator it = mailingListAddresses.begin(); + it != mailingListAddresses.end(); + ++it ) { + recipients = stripAddressFromAddressList( *it, recipients ); + } + if ( !recipients.isEmpty() ) { + toStr = recipients.join(", "); + } + else { + // there was only the mailing list post address in the Reply-To header, + // so use the From address instead + toStr = from(); + } + } + else if ( !from().isEmpty() ) { + toStr = from(); + } + replyStr = sReplyStr; // reply to author, so use "On ... you wrote:" + replyAll = false; + break; + } + case KMail::ReplyNone : { + // the addressees will be set by the caller + } + } + + msg->setTo(toStr); + + refStr = getRefStr(); + if (!refStr.isEmpty()) + msg->setReferences(refStr); + //In-Reply-To = original msg-id + msg->setReplyToId(msgId()); + +// if (!noQuote) { +// if( selectionIsBody ){ +// QCString cStr = selection.latin1(); +// msg->setBody( cStr ); +// }else{ +// msg->setBody(asQuotedString(replyStr + "\n", sIndentPrefixStr, selection, +// sSmartQuote, allowDecryption).utf8()); +// } +// } + + msg->setSubject( replySubject() ); + + TemplateParser parser( msg, (replyAll ? TemplateParser::ReplyAll : TemplateParser::Reply), + selection, sSmartQuote, noQuote, allowDecryption, selectionIsBody ); + if ( !tmpl.isEmpty() ) { + parser.process( tmpl, this ); + } else { + parser.process( this ); + } + + // setStatus(KMMsgStatusReplied); + msg->link(this, KMMsgStatusReplied); + + if ( parent() && parent()->putRepliesInSameFolder() ) + msg->setFcc( parent()->idString() ); + + // replies to an encrypted message should be encrypted as well + if ( encryptionState() == KMMsgPartiallyEncrypted || + encryptionState() == KMMsgFullyEncrypted ) { + msg->setEncryptionState( KMMsgFullyEncrypted ); + } + + return msg; +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::getRefStr() const +{ + QCString firstRef, lastRef, refStr, retRefStr; + int i, j; + + refStr = headerField("References").stripWhiteSpace().latin1(); + + if (refStr.isEmpty()) + return headerField("Message-Id").latin1(); + + i = refStr.find('<'); + j = refStr.find('>'); + firstRef = refStr.mid(i, j-i+1); + if (!firstRef.isEmpty()) + retRefStr = firstRef + ' '; + + i = refStr.findRev('<'); + j = refStr.findRev('>'); + + lastRef = refStr.mid(i, j-i+1); + if (!lastRef.isEmpty() && lastRef != firstRef) + retRefStr += lastRef + ' '; + + retRefStr += headerField("Message-Id").latin1(); + return retRefStr; +} + + +KMMessage* KMMessage::createRedirect( const QString &toStr ) +{ + // copy the message 1:1 + KMMessage* msg = new KMMessage( new DwMessage( *this->mMsg ) ); + KMMessagePart msgPart; + + uint id = 0; + QString strId = msg->headerField( "X-KMail-Identity" ).stripWhiteSpace(); + if ( !strId.isEmpty()) + id = strId.toUInt(); + const KPIM::Identity & ident = + kmkernel->identityManager()->identityForUoidOrDefault( id ); + + // X-KMail-Redirect-From: content + QString strByWayOf = QString("%1 (by way of %2 <%3>)") + .arg( from() ) + .arg( ident.fullName() ) + .arg( ident.emailAddr() ); + + // Resent-From: content + QString strFrom = QString("%1 <%2>") + .arg( ident.fullName() ) + .arg( ident.emailAddr() ); + + // format the current date to be used in Resent-Date: + QString origDate = msg->headerField( "Date" ); + msg->setDateToday(); + QString newDate = msg->headerField( "Date" ); + // make sure the Date: header is valid + if ( origDate.isEmpty() ) + msg->removeHeaderField( "Date" ); + else + msg->setHeaderField( "Date", origDate ); + + // prepend Resent-*: headers (c.f. RFC2822 3.6.6) + msg->setHeaderField( "Resent-Message-ID", generateMessageId( msg->sender() ), + Structured, true); + msg->setHeaderField( "Resent-Date", newDate, Structured, true ); + msg->setHeaderField( "Resent-To", toStr, Address, true ); + msg->setHeaderField( "Resent-From", strFrom, Address, true ); + + msg->setHeaderField( "X-KMail-Redirect-From", strByWayOf ); + msg->setHeaderField( "X-KMail-Recipients", toStr, Address ); + + msg->link(this, KMMsgStatusForwarded); + + return msg; +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::createForwardBody() +{ + QString s; + QCString str; + + if (sHeaderStrategy == HeaderStrategy::all()) { + s = "\n\n---------- " + sForwardStr + " ----------\n\n"; + s += headerAsString(); + str = asQuotedString(s, "", QString::null, false, false).utf8(); + str += "\n-------------------------------------------------------\n"; + } else { + s = "\n\n---------- " + sForwardStr + " ----------\n\n"; + s += "Subject: " + subject() + "\n"; + s += "Date: " + + KMime::DateFormatter::formatDate( KMime::DateFormatter::Localized, + date(), sReplyLanguage, false ) + + "\n"; + s += "From: " + from() + "\n"; + s += "To: " + to() + "\n"; + if (!cc().isEmpty()) s += "Cc: " + cc() + "\n"; + s += "\n"; + str = asQuotedString(s, "", QString::null, false, false).utf8(); + str += "\n-------------------------------------------------------\n"; + } + + return str; +} + +void KMMessage::sanitizeHeaders( const QStringList& whiteList ) +{ + // Strip out all headers apart from the content description and other + // whitelisted ones, because we don't want to inherit them. + DwHeaders& header = mMsg->Headers(); + DwField* field = header.FirstField(); + DwField* nextField; + while (field) + { + nextField = field->Next(); + if ( field->FieldNameStr().find( "ontent" ) == DwString::npos + && !whiteList.contains( QString::fromLatin1( field->FieldNameStr().c_str() ) ) ) + header.RemoveField(field); + field = nextField; + } + mMsg->Assemble(); +} + +//----------------------------------------------------------------------------- +KMMessage* KMMessage::createForward( const QString &tmpl /* = QString::null */ ) +{ + KMMessage* msg = new KMMessage(); + QString id; + + // If this is a multipart mail or if the main part is only the text part, + // Make an identical copy of the mail, minus headers, so attachments are + // preserved + if ( type() == DwMime::kTypeMultipart || + ( type() == DwMime::kTypeText && subtype() == DwMime::kSubtypePlain ) ) { + // ## slow, we could probably use: delete msg->mMsg; msg->mMsg = new DwMessage( this->mMsg ); + msg->fromDwString( this->asDwString() ); + // remember the type and subtype, initFromMessage sets the contents type to + // text/plain, via initHeader, for unclear reasons + const int type = msg->type(); + const int subtype = msg->subtype(); + + msg->sanitizeHeaders(); + + // strip blacklisted parts + QStringList blacklist = GlobalSettings::self()->mimetypesToStripWhenInlineForwarding(); + for ( QStringList::Iterator it = blacklist.begin(); it != blacklist.end(); ++it ) { + QString entry = (*it); + int sep = entry.find( '/' ); + QCString type = entry.left( sep ).latin1(); + QCString subtype = entry.mid( sep+1 ).latin1(); + kdDebug( 5006 ) << "Looking for blacklisted type: " << type << "/" << subtype << endl; + while ( DwBodyPart * part = msg->findDwBodyPart( type, subtype ) ) { + msg->mMsg->Body().RemoveBodyPart( part ); + } + } + msg->mMsg->Assemble(); + + msg->initFromMessage( this ); + //restore type + msg->setType( type ); + msg->setSubtype( subtype ); + } else if( type() == DwMime::kTypeText && subtype() == DwMime::kSubtypeHtml ) { + // This is non-multipart html mail. Let`s make it text/plain and allow + // template parser do the hard job. + msg->initFromMessage( this ); + msg->setType( DwMime::kTypeText ); + msg->setSubtype( DwMime::kSubtypeHtml ); + msg->mNeedsAssembly = true; + msg->cleanupHeader(); + } else { + // This is a non-multipart, non-text mail (e.g. text/calendar). Construct + // a multipart/mixed mail and add the original body as an attachment. + msg->initFromMessage( this ); + msg->removeHeaderField("Content-Type"); + msg->removeHeaderField("Content-Transfer-Encoding"); + // Modify the ContentType directly (replaces setAutomaticFields(true)) + DwHeaders & header = msg->mMsg->Headers(); + header.MimeVersion().FromString("1.0"); + DwMediaType & contentType = msg->dwContentType(); + contentType.SetType( DwMime::kTypeMultipart ); + contentType.SetSubtype( DwMime::kSubtypeMixed ); + contentType.CreateBoundary(0); + contentType.Assemble(); + + // empty text part + KMMessagePart msgPart; + bodyPart( 0, &msgPart ); + msg->addBodyPart(&msgPart); + // the old contents of the mail + KMMessagePart secondPart; + secondPart.setType( type() ); + secondPart.setSubtype( subtype() ); + secondPart.setBody( mMsg->Body().AsString() ); + // use the headers of the original mail + applyHeadersToMessagePart( mMsg->Headers(), &secondPart ); + msg->addBodyPart(&secondPart); + msg->mNeedsAssembly = true; + msg->cleanupHeader(); + } + // QString st = QString::fromUtf8(createForwardBody()); + + msg->setSubject( forwardSubject() ); + + TemplateParser parser( msg, TemplateParser::Forward, + asPlainText( false, false ), + false, false, false, false); + if ( !tmpl.isEmpty() ) { + parser.process( tmpl, this ); + } else { + parser.process( this ); + } + + // QCString encoding = autoDetectCharset(charset(), sPrefCharsets, msg->body()); + // if (encoding.isEmpty()) encoding = "utf-8"; + // msg->setCharset(encoding); + + // force utf-8 + // msg->setCharset( "utf-8" ); + + msg->link(this, KMMsgStatusForwarded); + return msg; +} + +static const struct { + const char * dontAskAgainID; + bool canDeny; + const char * text; +} mdnMessageBoxes[] = { + { "mdnNormalAsk", true, + I18N_NOOP("This message contains a request to return a notification " + "about your reception of the message.\n" + "You can either ignore the request or let KMail send a " + "\"denied\" or normal response.") }, + { "mdnUnknownOption", false, + I18N_NOOP("This message contains a request to send a notification " + "about your reception of the message.\n" + "It contains a processing instruction that is marked as " + "\"required\", but which is unknown to KMail.\n" + "You can either ignore the request or let KMail send a " + "\"failed\" response.") }, + { "mdnMultipleAddressesInReceiptTo", true, + I18N_NOOP("This message contains a request to send a notification " + "about your reception of the message,\n" + "but it is requested to send the notification to more " + "than one address.\n" + "You can either ignore the request or let KMail send a " + "\"denied\" or normal response.") }, + { "mdnReturnPathEmpty", true, + I18N_NOOP("This message contains a request to send a notification " + "about your reception of the message,\n" + "but there is no return-path set.\n" + "You can either ignore the request or let KMail send a " + "\"denied\" or normal response.") }, + { "mdnReturnPathNotInReceiptTo", true, + I18N_NOOP("This message contains a request to send a notification " + "about your reception of the message,\n" + "but the return-path address differs from the address " + "the notification was requested to be sent to.\n" + "You can either ignore the request or let KMail send a " + "\"denied\" or normal response.") }, +}; + +static const int numMdnMessageBoxes + = sizeof mdnMessageBoxes / sizeof *mdnMessageBoxes; + + +static int requestAdviceOnMDN( const char * what ) { + for ( int i = 0 ; i < numMdnMessageBoxes ; ++i ) + if ( !qstrcmp( what, mdnMessageBoxes[i].dontAskAgainID ) ) + if ( mdnMessageBoxes[i].canDeny ) { + const KCursorSaver saver( QCursor::ArrowCursor ); + int answer = QMessageBox::information( 0, + i18n("Message Disposition Notification Request"), + i18n( mdnMessageBoxes[i].text ), + i18n("&Ignore"), i18n("Send \"&denied\""), i18n("&Send") ); + return answer ? answer + 1 : 0 ; // map to "mode" in createMDN + } else { + const KCursorSaver saver( QCursor::ArrowCursor ); + int answer = QMessageBox::information( 0, + i18n("Message Disposition Notification Request"), + i18n( mdnMessageBoxes[i].text ), + i18n("&Ignore"), i18n("&Send") ); + return answer ? answer + 2 : 0 ; // map to "mode" in createMDN + } + kdWarning(5006) << "didn't find data for message box \"" + << what << "\"" << endl; + return 0; +} + +KMMessage* KMMessage::createMDN( MDN::ActionMode a, + MDN::DispositionType d, + bool allowGUI, + QValueList<MDN::DispositionModifier> m ) +{ + // RFC 2298: At most one MDN may be issued on behalf of each + // particular recipient by their user agent. That is, once an MDN + // has been issued on behalf of a recipient, no further MDNs may be + // issued on behalf of that recipient, even if another disposition + // is performed on the message. +//#define MDN_DEBUG 1 +#ifndef MDN_DEBUG + if ( mdnSentState() != KMMsgMDNStateUnknown && + mdnSentState() != KMMsgMDNNone ) + return 0; +#else + char st[2]; st[0] = (char)mdnSentState(); st[1] = 0; + kdDebug(5006) << "mdnSentState() == '" << st << "'" << endl; +#endif + + // RFC 2298: An MDN MUST NOT be generated in response to an MDN. + if ( findDwBodyPart( DwMime::kTypeMessage, + DwMime::kSubtypeDispositionNotification ) ) { + setMDNSentState( KMMsgMDNIgnore ); + return 0; + } + + // extract where to send to: + QString receiptTo = headerField("Disposition-Notification-To"); + if ( receiptTo.stripWhiteSpace().isEmpty() ) return 0; + receiptTo.remove( '\n' ); + + + MDN::SendingMode s = MDN::SentAutomatically; // set to manual if asked user + QString special; // fill in case of error, warning or failure + KConfigGroup mdnConfig( KMKernel::config(), "MDN" ); + + // default: + int mode = mdnConfig.readNumEntry( "default-policy", 0 ); + if ( !mode || mode < 0 || mode > 3 ) { + // early out for ignore: + setMDNSentState( KMMsgMDNIgnore ); + return 0; + } + + // RFC 2298: An importance of "required" indicates that + // interpretation of the parameter is necessary for proper + // generation of an MDN in response to this request. If a UA does + // not understand the meaning of the parameter, it MUST NOT generate + // an MDN with any disposition type other than "failed" in response + // to the request. + QString notificationOptions = headerField("Disposition-Notification-Options"); + if ( notificationOptions.contains( "required", false ) ) { + // ### hacky; should parse... + // There is a required option that we don't understand. We need to + // ask the user what we should do: + if ( !allowGUI ) return 0; // don't setMDNSentState here! + mode = requestAdviceOnMDN( "mdnUnknownOption" ); + s = MDN::SentManually; + + special = i18n("Header \"Disposition-Notification-Options\" contained " + "required, but unknown parameter"); + d = MDN::Failed; + m.clear(); // clear modifiers + } + + // RFC 2298: [ Confirmation from the user SHOULD be obtained (or no + // MDN sent) ] if there is more than one distinct address in the + // Disposition-Notification-To header. + kdDebug(5006) << "KPIM::splitEmailAddrList(receiptTo): " + << KPIM::splitEmailAddrList(receiptTo).join("\n") << endl; + if ( KPIM::splitEmailAddrList(receiptTo).count() > 1 ) { + if ( !allowGUI ) return 0; // don't setMDNSentState here! + mode = requestAdviceOnMDN( "mdnMultipleAddressesInReceiptTo" ); + s = MDN::SentManually; + } + + // RFC 2298: MDNs SHOULD NOT be sent automatically if the address in + // the Disposition-Notification-To header differs from the address + // in the Return-Path header. [...] Confirmation from the user + // SHOULD be obtained (or no MDN sent) if there is no Return-Path + // header in the message [...] + AddrSpecList returnPathList = extractAddrSpecs("Return-Path"); + QString returnPath = returnPathList.isEmpty() ? QString::null + : returnPathList.front().localPart + '@' + returnPathList.front().domain ; + kdDebug(5006) << "clean return path: " << returnPath << endl; + if ( returnPath.isEmpty() || !receiptTo.contains( returnPath, false ) ) { + if ( !allowGUI ) return 0; // don't setMDNSentState here! + mode = requestAdviceOnMDN( returnPath.isEmpty() ? + "mdnReturnPathEmpty" : + "mdnReturnPathNotInReceiptTo" ); + s = MDN::SentManually; + } + + if ( a != KMime::MDN::AutomaticAction ) { + //TODO: only ingore user settings for AutomaticAction if requested + if ( mode == 1 ) { // ask + if ( !allowGUI ) return 0; // don't setMDNSentState here! + mode = requestAdviceOnMDN( "mdnNormalAsk" ); + s = MDN::SentManually; // asked user + } + + switch ( mode ) { + case 0: // ignore: + setMDNSentState( KMMsgMDNIgnore ); + return 0; + default: + case 1: + kdFatal(5006) << "KMMessage::createMDN(): The \"ask\" mode should " + << "never appear here!" << endl; + break; + case 2: // deny + d = MDN::Denied; + m.clear(); + break; + case 3: + break; + } + } + + + // extract where to send from: + QString finalRecipient = kmkernel->identityManager() + ->identityForUoidOrDefault( identityUoid() ).fullEmailAddr(); + + // + // Generate message: + // + + KMMessage * receipt = new KMMessage(); + receipt->initFromMessage( this ); + receipt->removeHeaderField("Content-Type"); + receipt->removeHeaderField("Content-Transfer-Encoding"); + // Modify the ContentType directly (replaces setAutomaticFields(true)) + DwHeaders & header = receipt->mMsg->Headers(); + header.MimeVersion().FromString("1.0"); + DwMediaType & contentType = receipt->dwContentType(); + contentType.SetType( DwMime::kTypeMultipart ); + contentType.SetSubtype( DwMime::kSubtypeReport ); + contentType.CreateBoundary(0); + receipt->mNeedsAssembly = true; + receipt->setContentTypeParam( "report-type", "disposition-notification" ); + + QString description = replaceHeadersInString( MDN::descriptionFor( d, m ) ); + + // text/plain part: + KMMessagePart firstMsgPart; + firstMsgPart.setTypeStr( "text" ); + firstMsgPart.setSubtypeStr( "plain" ); + firstMsgPart.setBodyFromUnicode( description ); + receipt->addBodyPart( &firstMsgPart ); + + // message/disposition-notification part: + KMMessagePart secondMsgPart; + secondMsgPart.setType( DwMime::kTypeMessage ); + secondMsgPart.setSubtype( DwMime::kSubtypeDispositionNotification ); + //secondMsgPart.setCharset( "us-ascii" ); + //secondMsgPart.setCteStr( "7bit" ); + secondMsgPart.setBodyEncoded( MDN::dispositionNotificationBodyContent( + finalRecipient, + rawHeaderField("Original-Recipient"), + id(), /* Message-ID */ + d, a, s, m, special ) ); + receipt->addBodyPart( &secondMsgPart ); + + // message/rfc822 or text/rfc822-headers body part: + int num = mdnConfig.readNumEntry( "quote-message", 0 ); + if ( num < 0 || num > 2 ) num = 0; + MDN::ReturnContent returnContent = static_cast<MDN::ReturnContent>( num ); + + KMMessagePart thirdMsgPart; + switch ( returnContent ) { + case MDN::All: + thirdMsgPart.setTypeStr( "message" ); + thirdMsgPart.setSubtypeStr( "rfc822" ); + thirdMsgPart.setBody( asSendableString() ); + receipt->addBodyPart( &thirdMsgPart ); + break; + case MDN::HeadersOnly: + thirdMsgPart.setTypeStr( "text" ); + thirdMsgPart.setSubtypeStr( "rfc822-headers" ); + thirdMsgPart.setBody( headerAsSendableString() ); + receipt->addBodyPart( &thirdMsgPart ); + break; + case MDN::Nothing: + default: + break; + }; + + receipt->setTo( receiptTo ); + receipt->setSubject( "Message Disposition Notification" ); + receipt->setReplyToId( msgId() ); + receipt->setReferences( getRefStr() ); + + receipt->cleanupHeader(); + + kdDebug(5006) << "final message:\n" + receipt->asString() << endl; + + // + // Set "MDN sent" status: + // + KMMsgMDNSentState state = KMMsgMDNStateUnknown; + switch ( d ) { + case MDN::Displayed: state = KMMsgMDNDisplayed; break; + case MDN::Deleted: state = KMMsgMDNDeleted; break; + case MDN::Dispatched: state = KMMsgMDNDispatched; break; + case MDN::Processed: state = KMMsgMDNProcessed; break; + case MDN::Denied: state = KMMsgMDNDenied; break; + case MDN::Failed: state = KMMsgMDNFailed; break; + }; + setMDNSentState( state ); + + return receipt; +} + +QString KMMessage::replaceHeadersInString( const QString & s ) const { + QString result = s; + QRegExp rx( "\\$\\{([a-z0-9-]+)\\}", false ); + Q_ASSERT( rx.isValid() ); + + QRegExp rxDate( "\\$\\{date\\}" ); + Q_ASSERT( rxDate.isValid() ); + + QString sDate = KMime::DateFormatter::formatDate( + KMime::DateFormatter::Localized, date() ); + + int idx = 0; + if( ( idx = rxDate.search( result, idx ) ) != -1 ) { + result.replace( idx, rxDate.matchedLength(), sDate ); + } + + idx = 0; + while ( ( idx = rx.search( result, idx ) ) != -1 ) { + QString replacement = headerField( rx.cap(1).latin1() ); + result.replace( idx, rx.matchedLength(), replacement ); + idx += replacement.length(); + } + return result; +} + +KMMessage* KMMessage::createDeliveryReceipt() const +{ + QString str, receiptTo; + KMMessage *receipt; + + receiptTo = headerField("Disposition-Notification-To"); + if ( receiptTo.stripWhiteSpace().isEmpty() ) return 0; + receiptTo.remove( '\n' ); + + receipt = new KMMessage; + receipt->initFromMessage(this); + receipt->setTo(receiptTo); + receipt->setSubject(i18n("Receipt: ") + subject()); + + str = "Your message was successfully delivered."; + str += "\n\n---------- Message header follows ----------\n"; + str += headerAsString(); + str += "--------------------------------------------\n"; + // Conversion to latin1 is correct here as Mail headers should contain + // ascii only + receipt->setBody(str.latin1()); + receipt->setAutomaticFields(); + + return receipt; +} + + +void KMMessage::applyIdentity( uint id ) +{ + const KPIM::Identity & ident = + kmkernel->identityManager()->identityForUoidOrDefault( id ); + + if(ident.fullEmailAddr().isEmpty()) + setFrom(""); + else + setFrom(ident.fullEmailAddr()); + + if(ident.replyToAddr().isEmpty()) + setReplyTo(""); + else + setReplyTo(ident.replyToAddr()); + + if(ident.bcc().isEmpty()) + setBcc(""); + else + setBcc(ident.bcc()); + + if (ident.organization().isEmpty()) + removeHeaderField("Organization"); + else + setHeaderField("Organization", ident.organization()); + + if (ident.isDefault()) + removeHeaderField("X-KMail-Identity"); + else + setHeaderField("X-KMail-Identity", QString::number( ident.uoid() )); + + if ( ident.transport().isEmpty() ) + removeHeaderField( "X-KMail-Transport" ); + else + setHeaderField( "X-KMail-Transport", ident.transport() ); + + if ( ident.fcc().isEmpty() ) + setFcc( QString::null ); + else + setFcc( ident.fcc() ); + + if ( ident.drafts().isEmpty() ) + setDrafts( QString::null ); + else + setDrafts( ident.drafts() ); + + if ( ident.templates().isEmpty() ) + setTemplates( QString::null ); + else + setTemplates( ident.templates() ); + +} + +//----------------------------------------------------------------------------- +void KMMessage::initHeader( uint id ) +{ + applyIdentity( id ); + setTo(""); + setSubject(""); + setDateToday(); + + setHeaderField("User-Agent", "KMail/" KMAIL_VERSION ); + // This will allow to change Content-Type: + setHeaderField("Content-Type","text/plain"); +} + +uint KMMessage::identityUoid() const { + QString idString = headerField("X-KMail-Identity").stripWhiteSpace(); + bool ok = false; + int id = idString.toUInt( &ok ); + + if ( !ok || id == 0 ) + id = kmkernel->identityManager()->identityForAddress( to() + ", " + cc() ).uoid(); + if ( id == 0 && parent() ) + id = parent()->identity(); + + return id; +} + + +//----------------------------------------------------------------------------- +void KMMessage::initFromMessage(const KMMessage *msg, bool idHeaders) +{ + uint id = msg->identityUoid(); + + if ( idHeaders ) initHeader(id); + else setHeaderField("X-KMail-Identity", QString::number(id)); + if (!msg->headerField("X-KMail-Transport").isEmpty()) + setHeaderField("X-KMail-Transport", msg->headerField("X-KMail-Transport")); +} + + +//----------------------------------------------------------------------------- +void KMMessage::cleanupHeader() +{ + DwHeaders& header = mMsg->Headers(); + DwField* field = header.FirstField(); + DwField* nextField; + + if (mNeedsAssembly) mMsg->Assemble(); + mNeedsAssembly = false; + + while (field) + { + nextField = field->Next(); + if (field->FieldBody()->AsString().empty()) + { + header.RemoveField(field); + mNeedsAssembly = true; + } + field = nextField; + } +} + + +//----------------------------------------------------------------------------- +void KMMessage::setAutomaticFields(bool aIsMulti) +{ + DwHeaders& header = mMsg->Headers(); + header.MimeVersion().FromString("1.0"); + + if (aIsMulti || numBodyParts() > 1) + { + // Set the type to 'Multipart' and the subtype to 'Mixed' + DwMediaType& contentType = dwContentType(); + contentType.SetType( DwMime::kTypeMultipart); + contentType.SetSubtype(DwMime::kSubtypeMixed ); + + // Create a random printable string and set it as the boundary parameter + contentType.CreateBoundary(0); + } + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +QString KMMessage::dateStr() const +{ + KConfigGroup general( KMKernel::config(), "General" ); + DwHeaders& header = mMsg->Headers(); + time_t unixTime; + + if (!header.HasDate()) return ""; + unixTime = header.Date().AsUnixTime(); + + //kdDebug(5006)<<"#### Date = "<<header.Date().AsString().c_str()<<endl; + + return KMime::DateFormatter::formatDate( + static_cast<KMime::DateFormatter::FormatType>(general.readNumEntry( "dateFormat", KMime::DateFormatter::Fancy )), + unixTime, general.readEntry( "customDateFormat" )); +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::dateShortStr() const +{ + DwHeaders& header = mMsg->Headers(); + time_t unixTime; + + if (!header.HasDate()) return ""; + unixTime = header.Date().AsUnixTime(); + + QCString result = ctime(&unixTime); + int len = result.length(); + if (result[len-1]=='\n') + result.truncate(len-1); + + return result; +} + + +//----------------------------------------------------------------------------- +QString KMMessage::dateIsoStr() const +{ + DwHeaders& header = mMsg->Headers(); + time_t unixTime; + + if (!header.HasDate()) return ""; + unixTime = header.Date().AsUnixTime(); + + char cstr[64]; + strftime(cstr, 63, "%Y-%m-%d %H:%M:%S", localtime(&unixTime)); + return QString(cstr); +} + + +//----------------------------------------------------------------------------- +time_t KMMessage::date() const +{ + time_t res = ( time_t )-1; + DwHeaders& header = mMsg->Headers(); + if (header.HasDate()) + res = header.Date().AsUnixTime(); + return res; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setDateToday() +{ + struct timeval tval; + gettimeofday(&tval, 0); + setDate((time_t)tval.tv_sec); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setDate(time_t aDate) +{ + mDate = aDate; + mMsg->Headers().Date().FromCalendarTime(aDate); + mMsg->Headers().Date().Assemble(); + mNeedsAssembly = true; + mDirty = true; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setDate(const QCString& aStr) +{ + DwHeaders& header = mMsg->Headers(); + + header.Date().FromString(aStr); + header.Date().Parse(); + mNeedsAssembly = true; + mDirty = true; + + if (header.HasDate()) + mDate = header.Date().AsUnixTime(); +} + + +//----------------------------------------------------------------------------- +QString KMMessage::to() const +{ + // handle To same as Cc below, bug 80747 + QValueList<QCString> rawHeaders = rawHeaderFields( "To" ); + QStringList headers; + for ( QValueList<QCString>::Iterator it = rawHeaders.begin(); it != rawHeaders.end(); ++it ) { + headers << *it; + } + return KPIM::normalizeAddressesAndDecodeIDNs( headers.join( ", " ) ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setTo(const QString& aStr) +{ + setHeaderField( "To", aStr, Address ); +} + +//----------------------------------------------------------------------------- +QString KMMessage::toStrip() const +{ + return stripEmailAddr( to() ); +} + +//----------------------------------------------------------------------------- +QString KMMessage::replyTo() const +{ + return KPIM::normalizeAddressesAndDecodeIDNs( rawHeaderField("Reply-To") ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setReplyTo(const QString& aStr) +{ + setHeaderField( "Reply-To", aStr, Address ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setReplyTo(KMMessage* aMsg) +{ + setHeaderField( "Reply-To", aMsg->from(), Address ); +} + + +//----------------------------------------------------------------------------- +QString KMMessage::cc() const +{ + // get the combined contents of all Cc headers (as workaround for invalid + // messages with multiple Cc headers) + QValueList<QCString> rawHeaders = rawHeaderFields( "Cc" ); + QStringList headers; + for ( QValueList<QCString>::Iterator it = rawHeaders.begin(); it != rawHeaders.end(); ++it ) { + headers << *it; + } + return KPIM::normalizeAddressesAndDecodeIDNs( headers.join( ", " ) ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setCc(const QString& aStr) +{ + setHeaderField( "Cc", aStr, Address ); +} + + +//----------------------------------------------------------------------------- +QString KMMessage::ccStrip() const +{ + return stripEmailAddr( cc() ); +} + + +//----------------------------------------------------------------------------- +QString KMMessage::bcc() const +{ + return KPIM::normalizeAddressesAndDecodeIDNs( rawHeaderField("Bcc") ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setBcc(const QString& aStr) +{ + setHeaderField( "Bcc", aStr, Address ); +} + +//----------------------------------------------------------------------------- +QString KMMessage::fcc() const +{ + return headerField( "X-KMail-Fcc" ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setFcc( const QString &aStr ) +{ + setHeaderField( "X-KMail-Fcc", aStr ); +} + +//----------------------------------------------------------------------------- +void KMMessage::setDrafts( const QString &aStr ) +{ + mDrafts = aStr; +} + +//----------------------------------------------------------------------------- +void KMMessage::setTemplates( const QString &aStr ) +{ + mTemplates = aStr; +} + +//----------------------------------------------------------------------------- +QString KMMessage::who() const +{ + if (mParent) + return KPIM::normalizeAddressesAndDecodeIDNs( rawHeaderField(mParent->whoField().utf8()) ); + return from(); +} + + +//----------------------------------------------------------------------------- +QString KMMessage::from() const +{ + return KPIM::normalizeAddressesAndDecodeIDNs( rawHeaderField("From") ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setFrom(const QString& bStr) +{ + QString aStr = bStr; + if (aStr.isNull()) + aStr = ""; + setHeaderField( "From", aStr, Address ); + mDirty = true; +} + + +//----------------------------------------------------------------------------- +QString KMMessage::fromStrip() const +{ + return stripEmailAddr( from() ); +} + +//----------------------------------------------------------------------------- +QString KMMessage::sender() const { + AddrSpecList asl = extractAddrSpecs( "Sender" ); + if ( asl.empty() ) + asl = extractAddrSpecs( "From" ); + if ( asl.empty() ) + return QString::null; + return asl.front().asString(); +} + +//----------------------------------------------------------------------------- +QString KMMessage::subject() const +{ + return headerField("Subject"); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setSubject(const QString& aStr) +{ + setHeaderField("Subject",aStr); + mDirty = true; +} + + +//----------------------------------------------------------------------------- +QString KMMessage::xmark() const +{ + return headerField("X-KMail-Mark"); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setXMark(const QString& aStr) +{ + setHeaderField("X-KMail-Mark", aStr); + mDirty = true; +} + + +//----------------------------------------------------------------------------- +QString KMMessage::replyToId() const +{ + int leftAngle, rightAngle; + QString replyTo, references; + + replyTo = headerField("In-Reply-To"); + // search the end of the (first) message id in the In-Reply-To header + rightAngle = replyTo.find( '>' ); + if (rightAngle != -1) + replyTo.truncate( rightAngle + 1 ); + // now search the start of the message id + leftAngle = replyTo.findRev( '<' ); + if (leftAngle != -1) + replyTo = replyTo.mid( leftAngle ); + + // if we have found a good message id we can return immediately + // We ignore mangled In-Reply-To headers which are created by a + // misconfigured Mutt. They look like this <"from foo"@bar.baz>, i.e. + // they contain double quotes and spaces. We only check for '"'. + if (!replyTo.isEmpty() && (replyTo[0] == '<') && + ( -1 == replyTo.find( '"' ) ) ) + return replyTo; + + references = headerField("References"); + leftAngle = references.findRev( '<' ); + if (leftAngle != -1) + references = references.mid( leftAngle ); + rightAngle = references.find( '>' ); + if (rightAngle != -1) + references.truncate( rightAngle + 1 ); + + // if we found a good message id in the References header return it + if (!references.isEmpty() && references[0] == '<') + return references; + // else return the broken message id we found in the In-Reply-To header + else + return replyTo; +} + + +//----------------------------------------------------------------------------- +QString KMMessage::replyToIdMD5() const { + return base64EncodedMD5( replyToId() ); +} + +//----------------------------------------------------------------------------- +QString KMMessage::references() const +{ + int leftAngle, rightAngle; + QString references = headerField( "References" ); + + // keep the last two entries for threading + leftAngle = references.findRev( '<' ); + leftAngle = references.findRev( '<', leftAngle - 1 ); + if( leftAngle != -1 ) + references = references.mid( leftAngle ); + rightAngle = references.findRev( '>' ); + if( rightAngle != -1 ) + references.truncate( rightAngle + 1 ); + + if( !references.isEmpty() && references[0] == '<' ) + return references; + else + return QString::null; +} + +//----------------------------------------------------------------------------- +QString KMMessage::replyToAuxIdMD5() const +{ + QString result = references(); + // references contains two items, use the first one + // (the second to last reference) + const int rightAngle = result.find( '>' ); + if( rightAngle != -1 ) + result.truncate( rightAngle + 1 ); + + return base64EncodedMD5( result ); +} + +//----------------------------------------------------------------------------- +QString KMMessage::strippedSubjectMD5() const { + return base64EncodedMD5( stripOffPrefixes( subject() ), true /*utf8*/ ); +} + +//----------------------------------------------------------------------------- +QString KMMessage::subjectMD5() const { + return base64EncodedMD5( subject(), true /*utf8*/ ); +} + +//----------------------------------------------------------------------------- +bool KMMessage::subjectIsPrefixed() const { + return subjectMD5() != strippedSubjectMD5(); +} + +//----------------------------------------------------------------------------- +void KMMessage::setReplyToId(const QString& aStr) +{ + setHeaderField("In-Reply-To", aStr); + mDirty = true; +} + + +//----------------------------------------------------------------------------- +QString KMMessage::msgId() const +{ + QString msgId = headerField("Message-Id"); + + // search the end of the message id + const int rightAngle = msgId.find( '>' ); + if (rightAngle != -1) + msgId.truncate( rightAngle + 1 ); + // now search the start of the message id + const int leftAngle = msgId.findRev( '<' ); + if (leftAngle != -1) + msgId = msgId.mid( leftAngle ); + return msgId; +} + + +//----------------------------------------------------------------------------- +QString KMMessage::msgIdMD5() const { + return base64EncodedMD5( msgId() ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setMsgId(const QString& aStr) +{ + setHeaderField("Message-Id", aStr); + mDirty = true; +} + +//----------------------------------------------------------------------------- +size_t KMMessage::msgSizeServer() const { + return headerField( "X-Length" ).toULong(); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setMsgSizeServer(size_t size) +{ + setHeaderField("X-Length", QCString().setNum(size)); + mDirty = true; +} + +//----------------------------------------------------------------------------- +ulong KMMessage::UID() const { + return headerField( "X-UID" ).toULong(); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setUID(ulong uid) +{ + setHeaderField("X-UID", QCString().setNum(uid)); + mDirty = true; +} + +//----------------------------------------------------------------------------- +AddressList KMMessage::splitAddrField( const QCString & str ) +{ + AddressList result; + const char * scursor = str.begin(); + if ( !scursor ) + return AddressList(); + const char * const send = str.begin() + str.length(); + if ( !parseAddressList( scursor, send, result ) ) + kdDebug(5006) << "Error in address splitting: parseAddressList returned false!" + << endl; + return result; +} + +AddressList KMMessage::headerAddrField( const QCString & aName ) const { + return KMMessage::splitAddrField( rawHeaderField( aName ) ); +} + +AddrSpecList KMMessage::extractAddrSpecs( const QCString & header ) const { + AddressList al = headerAddrField( header ); + AddrSpecList result; + for ( AddressList::const_iterator ait = al.begin() ; ait != al.end() ; ++ait ) + for ( MailboxList::const_iterator mit = (*ait).mailboxList.begin() ; mit != (*ait).mailboxList.end() ; ++mit ) + result.push_back( (*mit).addrSpec ); + return result; +} + +QCString KMMessage::rawHeaderField( const QCString & name ) const { + if ( name.isEmpty() ) return QCString(); + + DwHeaders & header = mMsg->Headers(); + DwField * field = header.FindField( name ); + + if ( !field ) return QCString(); + + return header.FieldBody( name.data() ).AsString().c_str(); +} + +QValueList<QCString> KMMessage::rawHeaderFields( const QCString& field ) const +{ + if ( field.isEmpty() || !mMsg->Headers().FindField( field ) ) + return QValueList<QCString>(); + + std::vector<DwFieldBody*> v = mMsg->Headers().AllFieldBodies( field.data() ); + QValueList<QCString> headerFields; + for ( uint i = 0; i < v.size(); ++i ) { + headerFields.append( v[i]->AsString().c_str() ); + } + + return headerFields; +} + +QString KMMessage::headerField(const QCString& aName) const +{ + if ( aName.isEmpty() ) + return QString::null; + + if ( !mMsg->Headers().FindField( aName ) ) + return QString::null; + + return decodeRFC2047String( mMsg->Headers().FieldBody( aName.data() ).AsString().c_str(), + charset() ); + +} + +QStringList KMMessage::headerFields( const QCString& field ) const +{ + if ( field.isEmpty() || !mMsg->Headers().FindField( field ) ) + return QStringList(); + + std::vector<DwFieldBody*> v = mMsg->Headers().AllFieldBodies( field.data() ); + QStringList headerFields; + for ( uint i = 0; i < v.size(); ++i ) { + headerFields.append( decodeRFC2047String( v[i]->AsString().c_str(), charset() ) ); + } + + return headerFields; +} + +//----------------------------------------------------------------------------- +void KMMessage::removeHeaderField(const QCString& aName) +{ + DwHeaders & header = mMsg->Headers(); + DwField * field = header.FindField(aName); + if (!field) return; + + header.RemoveField(field); + mNeedsAssembly = true; +} + +//----------------------------------------------------------------------------- +void KMMessage::removeHeaderFields(const QCString& aName) +{ + DwHeaders & header = mMsg->Headers(); + while ( DwField * field = header.FindField(aName) ) { + header.RemoveField(field); + mNeedsAssembly = true; + } +} + + +//----------------------------------------------------------------------------- +void KMMessage::setHeaderField( const QCString& aName, const QString& bValue, + HeaderFieldType type, bool prepend ) +{ +#if 0 + if ( type != Unstructured ) + kdDebug(5006) << "KMMessage::setHeaderField( \"" << aName << "\", \"" + << bValue << "\", " << type << " )" << endl; +#endif + if (aName.isEmpty()) return; + + DwHeaders& header = mMsg->Headers(); + + DwString str; + DwField* field; + QCString aValue; + if (!bValue.isEmpty()) + { + QString value = bValue; + if ( type == Address ) + value = KPIM::normalizeAddressesAndEncodeIDNs( value ); +#if 0 + if ( type != Unstructured ) + kdDebug(5006) << "value: \"" << value << "\"" << endl; +#endif + QCString encoding = autoDetectCharset( charset(), sPrefCharsets, value ); + if (encoding.isEmpty()) + encoding = "utf-8"; + aValue = encodeRFC2047String( value, encoding ); +#if 0 + if ( type != Unstructured ) + kdDebug(5006) << "aValue: \"" << aValue << "\"" << endl; +#endif + } + str = aName; + if (str[str.length()-1] != ':') str += ": "; + else str += ' '; + if ( !aValue.isEmpty() ) + str += aValue; + if (str[str.length()-1] != '\n') str += '\n'; + + field = new DwField(str, mMsg); + field->Parse(); + + if ( prepend ) + header.AddFieldAt( 1, field ); + else + header.AddOrReplaceField( field ); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::typeStr() const +{ + DwHeaders& header = mMsg->Headers(); + if (header.HasContentType()) return header.ContentType().TypeStr().c_str(); + else return ""; +} + + +//----------------------------------------------------------------------------- +int KMMessage::type() const +{ + DwHeaders& header = mMsg->Headers(); + if (header.HasContentType()) return header.ContentType().Type(); + else return DwMime::kTypeNull; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setTypeStr(const QCString& aStr) +{ + dwContentType().SetTypeStr(DwString(aStr)); + dwContentType().Parse(); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setType(int aType) +{ + dwContentType().SetType(aType); + dwContentType().Assemble(); + mNeedsAssembly = true; +} + + + +//----------------------------------------------------------------------------- +QCString KMMessage::subtypeStr() const +{ + DwHeaders& header = mMsg->Headers(); + if (header.HasContentType()) return header.ContentType().SubtypeStr().c_str(); + else return ""; +} + + +//----------------------------------------------------------------------------- +int KMMessage::subtype() const +{ + DwHeaders& header = mMsg->Headers(); + if (header.HasContentType()) return header.ContentType().Subtype(); + else return DwMime::kSubtypeNull; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setSubtypeStr(const QCString& aStr) +{ + dwContentType().SetSubtypeStr(DwString(aStr)); + dwContentType().Parse(); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setSubtype(int aSubtype) +{ + dwContentType().SetSubtype(aSubtype); + dwContentType().Assemble(); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setDwMediaTypeParam( DwMediaType &mType, + const QCString& attr, + const QCString& val ) +{ + mType.Parse(); + DwParameter *param = mType.FirstParameter(); + while(param) { + if (!kasciistricmp(param->Attribute().c_str(), attr)) + break; + else + param = param->Next(); + } + if (!param){ + param = new DwParameter; + param->SetAttribute(DwString( attr )); + mType.AddParameter( param ); + } + else + mType.SetModified(); + param->SetValue(DwString( val )); + mType.Assemble(); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setContentTypeParam(const QCString& attr, const QCString& val) +{ + if (mNeedsAssembly) mMsg->Assemble(); + mNeedsAssembly = false; + setDwMediaTypeParam( dwContentType(), attr, val ); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::contentTransferEncodingStr() const +{ + DwHeaders& header = mMsg->Headers(); + if (header.HasContentTransferEncoding()) + return header.ContentTransferEncoding().AsString().c_str(); + else return ""; +} + + +//----------------------------------------------------------------------------- +int KMMessage::contentTransferEncoding() const +{ + DwHeaders& header = mMsg->Headers(); + if (header.HasContentTransferEncoding()) + return header.ContentTransferEncoding().AsEnum(); + else return DwMime::kCteNull; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setContentTransferEncodingStr(const QCString& aStr) +{ + mMsg->Headers().ContentTransferEncoding().FromString(aStr); + mMsg->Headers().ContentTransferEncoding().Parse(); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setContentTransferEncoding(int aCte) +{ + mMsg->Headers().ContentTransferEncoding().FromEnum(aCte); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +DwHeaders& KMMessage::headers() const +{ + return mMsg->Headers(); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setNeedsAssembly() +{ + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::body() const +{ + const DwString& body = mMsg->Body().AsString(); + QCString str = KMail::Util::CString( body ); + // Calls length() -> slow + //kdWarning( str.length() != body.length(), 5006 ) + // << "KMMessage::body(): body is binary but used as text!" << endl; + return str; +} + + +//----------------------------------------------------------------------------- +QByteArray KMMessage::bodyDecodedBinary() const +{ + DwString dwstr; + const DwString& dwsrc = mMsg->Body().AsString(); + + switch (cte()) + { + case DwMime::kCteBase64: + DwDecodeBase64(dwsrc, dwstr); + break; + case DwMime::kCteQuotedPrintable: + DwDecodeQuotedPrintable(dwsrc, dwstr); + break; + default: + dwstr = dwsrc; + break; + } + + int len = dwstr.size(); + QByteArray ba(len); + memcpy(ba.data(),dwstr.data(),len); + return ba; +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::bodyDecoded() const +{ + DwString dwstr; + DwString dwsrc = mMsg->Body().AsString(); + + switch (cte()) + { + case DwMime::kCteBase64: + DwDecodeBase64(dwsrc, dwstr); + break; + case DwMime::kCteQuotedPrintable: + DwDecodeQuotedPrintable(dwsrc, dwstr); + break; + default: + dwstr = dwsrc; + break; + } + + return KMail::Util::CString( dwstr ); + + // Calling QCString::length() is slow + //QCString result = KMail::Util::CString( dwstr ); + //kdWarning(result.length() != len, 5006) + // << "KMMessage::bodyDecoded(): body is binary but used as text!" << endl; + //return result; +} + + +//----------------------------------------------------------------------------- +QValueList<int> KMMessage::determineAllowedCtes( const CharFreq& cf, + bool allow8Bit, + bool willBeSigned ) +{ + QValueList<int> allowedCtes; + + switch ( cf.type() ) { + case CharFreq::SevenBitText: + allowedCtes << DwMime::kCte7bit; + case CharFreq::EightBitText: + if ( allow8Bit ) + allowedCtes << DwMime::kCte8bit; + case CharFreq::SevenBitData: + if ( cf.printableRatio() > 5.0/6.0 ) { + // let n the length of data and p the number of printable chars. + // Then base64 \approx 4n/3; qp \approx p + 3(n-p) + // => qp < base64 iff p > 5n/6. + allowedCtes << DwMime::kCteQp; + allowedCtes << DwMime::kCteBase64; + } else { + allowedCtes << DwMime::kCteBase64; + allowedCtes << DwMime::kCteQp; + } + break; + case CharFreq::EightBitData: + allowedCtes << DwMime::kCteBase64; + break; + case CharFreq::None: + default: + // just nothing (avoid compiler warning) + ; + } + + // In the following cases only QP and Base64 are allowed: + // - the buffer will be OpenPGP/MIME signed and it contains trailing + // whitespace (cf. RFC 3156) + // - a line starts with "From " + if ( ( willBeSigned && cf.hasTrailingWhitespace() ) || + cf.hasLeadingFrom() ) { + allowedCtes.remove( DwMime::kCte8bit ); + allowedCtes.remove( DwMime::kCte7bit ); + } + + return allowedCtes; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setBodyAndGuessCte( const QByteArray& aBuf, + QValueList<int> & allowedCte, + bool allow8Bit, + bool willBeSigned ) +{ + CharFreq cf( aBuf ); // it's safe to pass null arrays + + allowedCte = determineAllowedCtes( cf, allow8Bit, willBeSigned ); + +#ifndef NDEBUG + DwString dwCte; + DwCteEnumToStr(allowedCte[0], dwCte); + kdDebug(5006) << "CharFreq returned " << cf.type() << "/" + << cf.printableRatio() << " and I chose " + << dwCte.c_str() << endl; +#endif + + setCte( allowedCte[0] ); // choose best fitting + setBodyEncodedBinary( aBuf ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setBodyAndGuessCte( const QCString& aBuf, + QValueList<int> & allowedCte, + bool allow8Bit, + bool willBeSigned ) +{ + CharFreq cf( aBuf.data(), aBuf.size()-1 ); // it's safe to pass null strings + + allowedCte = determineAllowedCtes( cf, allow8Bit, willBeSigned ); + +#ifndef NDEBUG + DwString dwCte; + DwCteEnumToStr(allowedCte[0], dwCte); + kdDebug(5006) << "CharFreq returned " << cf.type() << "/" + << cf.printableRatio() << " and I chose " + << dwCte.c_str() << endl; +#endif + + setCte( allowedCte[0] ); // choose best fitting + setBodyEncoded( aBuf ); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setBodyEncoded(const QCString& aStr) +{ + DwString dwSrc(aStr.data(), aStr.size()-1 /* not the trailing NUL */); + DwString dwResult; + + switch (cte()) + { + case DwMime::kCteBase64: + DwEncodeBase64(dwSrc, dwResult); + break; + case DwMime::kCteQuotedPrintable: + DwEncodeQuotedPrintable(dwSrc, dwResult); + break; + default: + dwResult = dwSrc; + break; + } + + mMsg->Body().FromString(dwResult); + mNeedsAssembly = true; +} + +//----------------------------------------------------------------------------- +void KMMessage::setBodyEncodedBinary(const QByteArray& aStr) +{ + DwString dwSrc(aStr.data(), aStr.size()); + DwString dwResult; + + switch (cte()) + { + case DwMime::kCteBase64: + DwEncodeBase64(dwSrc, dwResult); + break; + case DwMime::kCteQuotedPrintable: + DwEncodeQuotedPrintable(dwSrc, dwResult); + break; + default: + dwResult = dwSrc; + break; + } + + mMsg->Body().FromString(dwResult); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +void KMMessage::setBody(const QCString& aStr) +{ + mMsg->Body().FromString(KMail::Util::dwString(aStr)); + mNeedsAssembly = true; +} +void KMMessage::setBody(const DwString& aStr) +{ + mMsg->Body().FromString(aStr); + mNeedsAssembly = true; +} +void KMMessage::setBody(const char* aStr) +{ + mMsg->Body().FromString(aStr); + mNeedsAssembly = true; +} + +void KMMessage::setMultiPartBody( const QCString & aStr ) { + setBody( aStr ); + mMsg->Body().Parse(); + mNeedsAssembly = true; +} + + +// Patched by Daniel Moisset <dmoisset@grulic.org.ar> +// modified numbodyparts, bodypart to take nested body parts as +// a linear sequence. +// third revision, Sep 26 2000 + +// this is support structure for traversing tree without recursion + +//----------------------------------------------------------------------------- +int KMMessage::numBodyParts() const +{ + int count = 0; + DwBodyPart* part = getFirstDwBodyPart(); + QPtrList< DwBodyPart > parts; + + while (part) + { + //dive into multipart messages + while ( part + && part->hasHeaders() + && part->Headers().HasContentType() + && part->Body().FirstBodyPart() + && (DwMime::kTypeMultipart == part->Headers().ContentType().Type()) ) + { + parts.append( part ); + part = part->Body().FirstBodyPart(); + } + // this is where currPart->msgPart contains a leaf message part + count++; + // go up in the tree until reaching a node with next + // (or the last top-level node) + while (part && !(part->Next()) && !(parts.isEmpty())) + { + part = parts.getLast(); + parts.removeLast(); + } + + if (part && part->Body().Message() && + part->Body().Message()->Body().FirstBodyPart()) + { + part = part->Body().Message()->Body().FirstBodyPart(); + } else if (part) { + part = part->Next(); + } + } + + return count; +} + + +//----------------------------------------------------------------------------- +DwBodyPart * KMMessage::getFirstDwBodyPart() const +{ + return mMsg->Body().FirstBodyPart(); +} + + +//----------------------------------------------------------------------------- +int KMMessage::partNumber( DwBodyPart * aDwBodyPart ) const +{ + DwBodyPart *curpart; + QPtrList< DwBodyPart > parts; + int curIdx = 0; + int idx = 0; + // Get the DwBodyPart for this index + + curpart = getFirstDwBodyPart(); + + while (curpart && !idx) { + //dive into multipart messages + while( curpart + && curpart->hasHeaders() + && curpart->Headers().HasContentType() + && curpart->Body().FirstBodyPart() + && (DwMime::kTypeMultipart == curpart->Headers().ContentType().Type()) ) + { + parts.append( curpart ); + curpart = curpart->Body().FirstBodyPart(); + } + // this is where currPart->msgPart contains a leaf message part + if (curpart == aDwBodyPart) + idx = curIdx; + curIdx++; + // go up in the tree until reaching a node with next + // (or the last top-level node) + while (curpart && !(curpart->Next()) && !(parts.isEmpty())) + { + curpart = parts.getLast(); + parts.removeLast(); + } ; + if (curpart) + curpart = curpart->Next(); + } + return idx; +} + + +//----------------------------------------------------------------------------- +DwBodyPart * KMMessage::dwBodyPart( int aIdx ) const +{ + DwBodyPart *part, *curpart; + QPtrList< DwBodyPart > parts; + int curIdx = 0; + // Get the DwBodyPart for this index + + curpart = getFirstDwBodyPart(); + part = 0; + + while (curpart && !part) { + //dive into multipart messages + while( curpart + && curpart->hasHeaders() + && curpart->Headers().HasContentType() + && curpart->Body().FirstBodyPart() + && (DwMime::kTypeMultipart == curpart->Headers().ContentType().Type()) ) + { + parts.append( curpart ); + curpart = curpart->Body().FirstBodyPart(); + } + // this is where currPart->msgPart contains a leaf message part + if (curIdx==aIdx) + part = curpart; + curIdx++; + // go up in the tree until reaching a node with next + // (or the last top-level node) + while (curpart && !(curpart->Next()) && !(parts.isEmpty())) + { + curpart = parts.getLast(); + parts.removeLast(); + } + if (curpart) + curpart = curpart->Next(); + } + return part; +} + + +//----------------------------------------------------------------------------- +DwBodyPart * KMMessage::findDwBodyPart( int type, int subtype ) const +{ + DwBodyPart *part, *curpart; + QPtrList< DwBodyPart > parts; + // Get the DwBodyPart for this index + + curpart = getFirstDwBodyPart(); + part = 0; + + while (curpart && !part) { + //dive into multipart messages + while(curpart + && curpart->hasHeaders() + && curpart->Headers().HasContentType() + && curpart->Body().FirstBodyPart() + && (DwMime::kTypeMultipart == curpart->Headers().ContentType().Type()) ) { + parts.append( curpart ); + curpart = curpart->Body().FirstBodyPart(); + } + // this is where curPart->msgPart contains a leaf message part + + // pending(khz): Find out WHY this look does not travel down *into* an + // embedded "Message/RfF822" message containing a "Multipart/Mixed" + if ( curpart && curpart->hasHeaders() && curpart->Headers().HasContentType() ) { + kdDebug(5006) << curpart->Headers().ContentType().TypeStr().c_str() + << " " << curpart->Headers().ContentType().SubtypeStr().c_str() << endl; + } + + if (curpart && + curpart->hasHeaders() && + curpart->Headers().HasContentType() && + curpart->Headers().ContentType().Type() == type && + curpart->Headers().ContentType().Subtype() == subtype) { + part = curpart; + } else { + // go up in the tree until reaching a node with next + // (or the last top-level node) + while (curpart && !(curpart->Next()) && !(parts.isEmpty())) { + curpart = parts.getLast(); + parts.removeLast(); + } ; + if (curpart) + curpart = curpart->Next(); + } + } + return part; +} + +//----------------------------------------------------------------------------- +DwBodyPart * KMMessage::findDwBodyPart( const QCString& type, const QCString& subtype ) const +{ + DwBodyPart *part, *curpart; + QPtrList< DwBodyPart > parts; + // Get the DwBodyPart for this index + + curpart = getFirstDwBodyPart(); + part = 0; + + while (curpart && !part) { + //dive into multipart messages + while(curpart + && curpart->hasHeaders() + && curpart->Headers().HasContentType() + && curpart->Body().FirstBodyPart() + && (DwMime::kTypeMultipart == curpart->Headers().ContentType().Type()) ) { + parts.append( curpart ); + curpart = curpart->Body().FirstBodyPart(); + } + // this is where curPart->msgPart contains a leaf message part + + // pending(khz): Find out WHY this look does not travel down *into* an + // embedded "Message/RfF822" message containing a "Multipart/Mixed" + if (curpart && curpart->hasHeaders() && curpart->Headers().HasContentType() ) { + kdDebug(5006) << curpart->Headers().ContentType().TypeStr().c_str() + << " " << curpart->Headers().ContentType().SubtypeStr().c_str() << endl; + } + + if (curpart && + curpart->hasHeaders() && + curpart->Headers().HasContentType() && + curpart->Headers().ContentType().TypeStr().c_str() == type && + curpart->Headers().ContentType().SubtypeStr().c_str() == subtype) { + part = curpart; + } else { + // go up in the tree until reaching a node with next + // (or the last top-level node) + while (curpart && !(curpart->Next()) && !(parts.isEmpty())) { + curpart = parts.getLast(); + parts.removeLast(); + } ; + if (curpart) + curpart = curpart->Next(); + } + } + return part; +} + + +void applyHeadersToMessagePart( DwHeaders& headers, KMMessagePart* aPart ) +{ + // TODO: Instead of manually implementing RFC2231 header encoding (i.e. + // possibly multiple values given as paramname*0=..; parmaname*1=..;... + // or par as paramname*0*=..; parmaname*1*=..;..., which should be + // concatenated), use a generic method to decode the header, using RFC + // 2047 or 2231, or whatever future RFC might be appropriate! + // Right now, some fields are decoded, while others are not. E.g. + // Content-Disposition is not decoded here, rather only on demand in + // KMMsgPart::fileName; Name however is decoded here and stored as a + // decoded String in KMMsgPart... + // Content-type + QCString additionalCTypeParams; + if (headers.HasContentType()) + { + DwMediaType& ct = headers.ContentType(); + aPart->setOriginalContentTypeStr( ct.AsString().c_str() ); + aPart->setTypeStr(ct.TypeStr().c_str()); + aPart->setSubtypeStr(ct.SubtypeStr().c_str()); + DwParameter *param = ct.FirstParameter(); + while(param) + { + if (!qstricmp(param->Attribute().c_str(), "charset")) + aPart->setCharset(QCString(param->Value().c_str()).lower()); + else if (!qstrnicmp(param->Attribute().c_str(), "name*", 5)) + aPart->setName(KMMsgBase::decodeRFC2231String(KMMsgBase::extractRFC2231HeaderField( param->Value().c_str(), "name" ))); + else { + additionalCTypeParams += ';'; + additionalCTypeParams += param->AsString().c_str(); + } + param=param->Next(); + } + } + else + { + aPart->setTypeStr("text"); // Set to defaults + aPart->setSubtypeStr("plain"); + } + aPart->setAdditionalCTypeParamStr( additionalCTypeParams ); + // Modification by Markus + if (aPart->name().isEmpty()) + { + if (headers.HasContentType() && !headers.ContentType().Name().empty()) { + aPart->setName(KMMsgBase::decodeRFC2047String(headers. + ContentType().Name().c_str()) ); + } else if (headers.HasSubject() && !headers.Subject().AsString().empty()) { + aPart->setName( KMMsgBase::decodeRFC2047String(headers. + Subject().AsString().c_str()) ); + } + } + + // Content-transfer-encoding + if (headers.HasContentTransferEncoding()) + aPart->setCteStr(headers.ContentTransferEncoding().AsString().c_str()); + else + aPart->setCteStr("7bit"); + + // Content-description + if (headers.HasContentDescription()) + aPart->setContentDescription(headers.ContentDescription().AsString().c_str()); + else + aPart->setContentDescription(""); + + // Content-disposition + if (headers.HasContentDisposition()) + aPart->setContentDisposition(headers.ContentDisposition().AsString().c_str()); + else + aPart->setContentDisposition(""); +} + +//----------------------------------------------------------------------------- +void KMMessage::bodyPart(DwBodyPart* aDwBodyPart, KMMessagePart* aPart, + bool withBody) +{ + if ( !aPart ) + return; + + aPart->clear(); + + if( aDwBodyPart && aDwBodyPart->hasHeaders() ) { + // This must not be an empty string, because we'll get a + // spurious empty Subject: line in some of the parts. + //aPart->setName(" "); + // partSpecifier + QString partId( aDwBodyPart->partId() ); + aPart->setPartSpecifier( partId ); + + DwHeaders& headers = aDwBodyPart->Headers(); + applyHeadersToMessagePart( headers, aPart ); + + // Body + if (withBody) + aPart->setBody( aDwBodyPart->Body().AsString() ); + else + aPart->setBody( QCString("") ); + + // Content-id + if ( headers.HasContentId() ) { + const QCString contentId = headers.ContentId().AsString().c_str(); + // ignore leading '<' and trailing '>' + aPart->setContentId( contentId.mid( 1, contentId.length() - 2 ) ); + } + } + // If no valid body part was given, + // set all MultipartBodyPart attributes to empty values. + else + { + aPart->setTypeStr(""); + aPart->setSubtypeStr(""); + aPart->setCteStr(""); + // This must not be an empty string, because we'll get a + // spurious empty Subject: line in some of the parts. + //aPart->setName(" "); + aPart->setContentDescription(""); + aPart->setContentDisposition(""); + aPart->setBody(QCString("")); + aPart->setContentId(""); + } +} + + +//----------------------------------------------------------------------------- +void KMMessage::bodyPart(int aIdx, KMMessagePart* aPart) const +{ + if ( !aPart ) + return; + + // If the DwBodyPart was found get the header fields and body + if ( DwBodyPart *part = dwBodyPart( aIdx ) ) { + KMMessage::bodyPart(part, aPart); + if( aPart->name().isEmpty() ) + aPart->setName( i18n("Attachment: %1").arg( aIdx ) ); + } +} + + +//----------------------------------------------------------------------------- +void KMMessage::deleteBodyParts() +{ + mMsg->Body().DeleteBodyParts(); +} + +//----------------------------------------------------------------------------- +DwBodyPart* KMMessage::createDWBodyPart(const KMMessagePart* aPart) +{ + DwBodyPart* part = DwBodyPart::NewBodyPart(emptyString, 0); + + if ( !aPart ) + return part; + + QCString charset = aPart->charset(); + QCString type = aPart->typeStr(); + QCString subtype = aPart->subtypeStr(); + QCString cte = aPart->cteStr(); + QCString contDesc = aPart->contentDescriptionEncoded(); + QCString contDisp = aPart->contentDisposition(); + QCString encoding = autoDetectCharset(charset, sPrefCharsets, aPart->name()); + if (encoding.isEmpty()) encoding = "utf-8"; + QCString name = KMMsgBase::encodeRFC2231String(aPart->name(), encoding); + bool RFC2231encoded = aPart->name() != QString(name); + QCString paramAttr = aPart->parameterAttribute(); + + DwHeaders& headers = part->Headers(); + + DwMediaType& ct = headers.ContentType(); + if (!type.isEmpty() && !subtype.isEmpty()) + { + ct.SetTypeStr(type.data()); + ct.SetSubtypeStr(subtype.data()); + if (!charset.isEmpty()){ + DwParameter *param; + param=new DwParameter; + param->SetAttribute("charset"); + param->SetValue(charset.data()); + ct.AddParameter(param); + } + } + + QCString additionalParam = aPart->additionalCTypeParamStr(); + if( !additionalParam.isEmpty() ) + { + QCString parAV; + DwString parA, parV; + int iL, i1, i2, iM; + iL = additionalParam.length(); + i1 = 0; + i2 = additionalParam.find(';', i1, false); + while ( i1 < iL ) + { + if( -1 == i2 ) + i2 = iL; + if( i1+1 < i2 ) { + parAV = additionalParam.mid( i1, (i2-i1) ); + iM = parAV.find('='); + if( -1 < iM ) + { + parA = parAV.left( iM ); + parV = parAV.right( parAV.length() - iM - 1 ); + if( ('"' == parV.at(0)) && ('"' == parV.at(parV.length()-1)) ) + { + parV.erase( 0, 1); + parV.erase( parV.length()-1 ); + } + } + else + { + parA = parAV; + parV = ""; + } + DwParameter *param; + param = new DwParameter; + param->SetAttribute( parA ); + param->SetValue( parV ); + ct.AddParameter( param ); + } + i1 = i2+1; + i2 = additionalParam.find(';', i1, false); + } + } + + if ( !name.isEmpty() ) { + if (RFC2231encoded) + { + DwParameter *nameParam; + nameParam = new DwParameter; + nameParam->SetAttribute("name*"); + nameParam->SetValue(name.data(),true); + ct.AddParameter(nameParam); + } else { + ct.SetName(name.data()); + } + } + + if (!paramAttr.isEmpty()) + { + QCString encoding = autoDetectCharset(charset, sPrefCharsets, + aPart->parameterValue()); + if (encoding.isEmpty()) encoding = "utf-8"; + QCString paramValue; + paramValue = KMMsgBase::encodeRFC2231String(aPart->parameterValue(), + encoding); + DwParameter *param = new DwParameter; + if (aPart->parameterValue() != QString(paramValue)) + { + param->SetAttribute((paramAttr + '*').data()); + param->SetValue(paramValue.data(),true); + } else { + param->SetAttribute(paramAttr.data()); + param->SetValue(paramValue.data()); + } + ct.AddParameter(param); + } + + if (!cte.isEmpty()) + headers.Cte().FromString(cte); + + if (!contDesc.isEmpty()) + headers.ContentDescription().FromString(contDesc); + + if (!contDisp.isEmpty()) + headers.ContentDisposition().FromString(contDisp); + + const DwString bodyStr = aPart->dwBody(); + if (!bodyStr.empty()) + part->Body().FromString(bodyStr); + else + part->Body().FromString(""); + + if (!aPart->partSpecifier().isNull()) + part->SetPartId( aPart->partSpecifier().latin1() ); + + if (aPart->decodedSize() > 0) + part->SetBodySize( aPart->decodedSize() ); + + return part; +} + + +//----------------------------------------------------------------------------- +void KMMessage::addDwBodyPart(DwBodyPart * aDwPart) +{ + mMsg->Body().AddBodyPart( aDwPart ); + mNeedsAssembly = true; +} + + +//----------------------------------------------------------------------------- +void KMMessage::addBodyPart(const KMMessagePart* aPart) +{ + DwBodyPart* part = createDWBodyPart( aPart ); + addDwBodyPart( part ); +} + + +//----------------------------------------------------------------------------- +QString KMMessage::generateMessageId( const QString& addr ) +{ + QDateTime datetime = QDateTime::currentDateTime(); + QString msgIdStr; + + msgIdStr = '<' + datetime.toString( "yyyyMMddhhmm.sszzz" ); + + QString msgIdSuffix; + KConfigGroup general( KMKernel::config(), "General" ); + + if( general.readBoolEntry( "useCustomMessageIdSuffix", false ) ) + msgIdSuffix = general.readEntry( "myMessageIdSuffix" ); + + if( !msgIdSuffix.isEmpty() ) + msgIdStr += '@' + msgIdSuffix; + else + msgIdStr += '.' + KPIM::encodeIDN( addr ); + + msgIdStr += '>'; + + return msgIdStr; +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::html2source( const QCString & src ) +{ + QCString result( 1 + 6*(src.size()-1) ); // maximal possible length + + QCString::ConstIterator s = src.begin(); + QCString::Iterator d = result.begin(); + while ( *s ) { + switch ( *s ) { + case '<': { + *d++ = '&'; + *d++ = 'l'; + *d++ = 't'; + *d++ = ';'; + ++s; + } + break; + case '\r': { + ++s; + } + break; + case '\n': { + *d++ = '<'; + *d++ = 'b'; + *d++ = 'r'; + *d++ = '>'; + ++s; + } + break; + case '>': { + *d++ = '&'; + *d++ = 'g'; + *d++ = 't'; + *d++ = ';'; + ++s; + } + break; + case '&': { + *d++ = '&'; + *d++ = 'a'; + *d++ = 'm'; + *d++ = 'p'; + *d++ = ';'; + ++s; + } + break; + case '"': { + *d++ = '&'; + *d++ = 'q'; + *d++ = 'u'; + *d++ = 'o'; + *d++ = 't'; + *d++ = ';'; + ++s; + } + break; + case '\'': { + *d++ = '&'; + *d++ = 'a'; + *d++ = 'p'; + *d++ = 's'; + *d++ = ';'; + ++s; + } + break; + default: + *d++ = *s++; + } + } + result.truncate( d - result.begin() ); // adds trailing NUL + return result; +} + +//----------------------------------------------------------------------------- +QString KMMessage::encodeMailtoUrl( const QString& str ) +{ + QString result; + result = QString::fromLatin1( KMMsgBase::encodeRFC2047String( str, + "utf-8" ) ); + result = KURL::encode_string( result ); + return result; +} + + +//----------------------------------------------------------------------------- +QString KMMessage::decodeMailtoUrl( const QString& url ) +{ + QString result; + result = KURL::decode_string( url ); + result = KMMsgBase::decodeRFC2047String( result.latin1() ); + return result; +} + + +//----------------------------------------------------------------------------- +QCString KMMessage::stripEmailAddr( const QCString& aStr ) +{ + //kdDebug(5006) << "KMMessage::stripEmailAddr( " << aStr << " )" << endl; + + if ( aStr.isEmpty() ) + return QCString(); + + QCString result; + + // The following is a primitive parser for a mailbox-list (cf. RFC 2822). + // The purpose is to extract a displayable string from the mailboxes. + // Comments in the addr-spec are not handled. No error checking is done. + + QCString name; + QCString comment; + QCString angleAddress; + enum { TopLevel, InComment, InAngleAddress } context = TopLevel; + bool inQuotedString = false; + int commentLevel = 0; + + for ( char* p = aStr.data(); *p; ++p ) { + switch ( context ) { + case TopLevel : { + switch ( *p ) { + case '"' : inQuotedString = !inQuotedString; + break; + case '(' : if ( !inQuotedString ) { + context = InComment; + commentLevel = 1; + } + else + name += *p; + break; + case '<' : if ( !inQuotedString ) { + context = InAngleAddress; + } + else + name += *p; + break; + case '\\' : // quoted character + ++p; // skip the '\' + if ( *p ) + name += *p; + break; + case ',' : if ( !inQuotedString ) { + // next email address + if ( !result.isEmpty() ) + result += ", "; + name = name.stripWhiteSpace(); + comment = comment.stripWhiteSpace(); + angleAddress = angleAddress.stripWhiteSpace(); + /* + kdDebug(5006) << "Name : \"" << name + << "\"" << endl; + kdDebug(5006) << "Comment : \"" << comment + << "\"" << endl; + kdDebug(5006) << "Address : \"" << angleAddress + << "\"" << endl; + */ + if ( angleAddress.isEmpty() && !comment.isEmpty() ) { + // handle Outlook-style addresses like + // john.doe@invalid (John Doe) + result += comment; + } + else if ( !name.isEmpty() ) { + result += name; + } + else if ( !comment.isEmpty() ) { + result += comment; + } + else if ( !angleAddress.isEmpty() ) { + result += angleAddress; + } + name = QCString(); + comment = QCString(); + angleAddress = QCString(); + } + else + name += *p; + break; + default : name += *p; + } + break; + } + case InComment : { + switch ( *p ) { + case '(' : ++commentLevel; + comment += *p; + break; + case ')' : --commentLevel; + if ( commentLevel == 0 ) { + context = TopLevel; + comment += ' '; // separate the text of several comments + } + else + comment += *p; + break; + case '\\' : // quoted character + ++p; // skip the '\' + if ( *p ) + comment += *p; + break; + default : comment += *p; + } + break; + } + case InAngleAddress : { + switch ( *p ) { + case '"' : inQuotedString = !inQuotedString; + angleAddress += *p; + break; + case '>' : if ( !inQuotedString ) { + context = TopLevel; + } + else + angleAddress += *p; + break; + case '\\' : // quoted character + ++p; // skip the '\' + if ( *p ) + angleAddress += *p; + break; + default : angleAddress += *p; + } + break; + } + } // switch ( context ) + } + if ( !result.isEmpty() ) + result += ", "; + name = name.stripWhiteSpace(); + comment = comment.stripWhiteSpace(); + angleAddress = angleAddress.stripWhiteSpace(); + /* + kdDebug(5006) << "Name : \"" << name << "\"" << endl; + kdDebug(5006) << "Comment : \"" << comment << "\"" << endl; + kdDebug(5006) << "Address : \"" << angleAddress << "\"" << endl; + */ + if ( angleAddress.isEmpty() && !comment.isEmpty() ) { + // handle Outlook-style addresses like + // john.doe@invalid (John Doe) + result += comment; + } + else if ( !name.isEmpty() ) { + result += name; + } + else if ( !comment.isEmpty() ) { + result += comment; + } + else if ( !angleAddress.isEmpty() ) { + result += angleAddress; + } + + //kdDebug(5006) << "KMMessage::stripEmailAddr(...) returns \"" << result + // << "\"" << endl; + return result; +} + +//----------------------------------------------------------------------------- +QString KMMessage::stripEmailAddr( const QString& aStr ) +{ + //kdDebug(5006) << "KMMessage::stripEmailAddr( " << aStr << " )" << endl; + + if ( aStr.isEmpty() ) + return QString::null; + + QString result; + + // The following is a primitive parser for a mailbox-list (cf. RFC 2822). + // The purpose is to extract a displayable string from the mailboxes. + // Comments in the addr-spec are not handled. No error checking is done. + + QString name; + QString comment; + QString angleAddress; + enum { TopLevel, InComment, InAngleAddress } context = TopLevel; + bool inQuotedString = false; + int commentLevel = 0; + + QChar ch; + unsigned int strLength(aStr.length()); + for ( uint index = 0; index < strLength; ++index ) { + ch = aStr[index]; + switch ( context ) { + case TopLevel : { + switch ( ch.latin1() ) { + case '"' : inQuotedString = !inQuotedString; + break; + case '(' : if ( !inQuotedString ) { + context = InComment; + commentLevel = 1; + } + else + name += ch; + break; + case '<' : if ( !inQuotedString ) { + context = InAngleAddress; + } + else + name += ch; + break; + case '\\' : // quoted character + ++index; // skip the '\' + if ( index < aStr.length() ) + name += aStr[index]; + break; + case ',' : if ( !inQuotedString ) { + // next email address + if ( !result.isEmpty() ) + result += ", "; + name = name.stripWhiteSpace(); + comment = comment.stripWhiteSpace(); + angleAddress = angleAddress.stripWhiteSpace(); + /* + kdDebug(5006) << "Name : \"" << name + << "\"" << endl; + kdDebug(5006) << "Comment : \"" << comment + << "\"" << endl; + kdDebug(5006) << "Address : \"" << angleAddress + << "\"" << endl; + */ + if ( angleAddress.isEmpty() && !comment.isEmpty() ) { + // handle Outlook-style addresses like + // john.doe@invalid (John Doe) + result += comment; + } + else if ( !name.isEmpty() ) { + result += name; + } + else if ( !comment.isEmpty() ) { + result += comment; + } + else if ( !angleAddress.isEmpty() ) { + result += angleAddress; + } + name = QString::null; + comment = QString::null; + angleAddress = QString::null; + } + else + name += ch; + break; + default : name += ch; + } + break; + } + case InComment : { + switch ( ch.latin1() ) { + case '(' : ++commentLevel; + comment += ch; + break; + case ')' : --commentLevel; + if ( commentLevel == 0 ) { + context = TopLevel; + comment += ' '; // separate the text of several comments + } + else + comment += ch; + break; + case '\\' : // quoted character + ++index; // skip the '\' + if ( index < aStr.length() ) + comment += aStr[index]; + break; + default : comment += ch; + } + break; + } + case InAngleAddress : { + switch ( ch.latin1() ) { + case '"' : inQuotedString = !inQuotedString; + angleAddress += ch; + break; + case '>' : if ( !inQuotedString ) { + context = TopLevel; + } + else + angleAddress += ch; + break; + case '\\' : // quoted character + ++index; // skip the '\' + if ( index < aStr.length() ) + angleAddress += aStr[index]; + break; + default : angleAddress += ch; + } + break; + } + } // switch ( context ) + } + if ( !result.isEmpty() ) + result += ", "; + name = name.stripWhiteSpace(); + comment = comment.stripWhiteSpace(); + angleAddress = angleAddress.stripWhiteSpace(); + /* + kdDebug(5006) << "Name : \"" << name << "\"" << endl; + kdDebug(5006) << "Comment : \"" << comment << "\"" << endl; + kdDebug(5006) << "Address : \"" << angleAddress << "\"" << endl; + */ + if ( angleAddress.isEmpty() && !comment.isEmpty() ) { + // handle Outlook-style addresses like + // john.doe@invalid (John Doe) + result += comment; + } + else if ( !name.isEmpty() ) { + result += name; + } + else if ( !comment.isEmpty() ) { + result += comment; + } + else if ( !angleAddress.isEmpty() ) { + result += angleAddress; + } + + //kdDebug(5006) << "KMMessage::stripEmailAddr(...) returns \"" << result + // << "\"" << endl; + return result; +} + +//----------------------------------------------------------------------------- +QString KMMessage::quoteHtmlChars( const QString& str, bool removeLineBreaks ) +{ + QString result; + + unsigned int strLength(str.length()); + result.reserve( 6*strLength ); // maximal possible length + for( unsigned int i = 0; i < strLength; ++i ) + switch ( str[i].latin1() ) { + case '<': + result += "<"; + break; + case '>': + result += ">"; + break; + case '&': + result += "&"; + break; + case '"': + result += """; + break; + case '\n': + if ( !removeLineBreaks ) + result += "<br>"; + break; + case '\r': + // ignore CR + break; + default: + result += str[i]; + } + + result.squeeze(); + return result; +} + +//----------------------------------------------------------------------------- +QString KMMessage::emailAddrAsAnchor(const QString& aEmail, bool stripped, const QString& cssStyle, bool aLink) +{ + if( aEmail.isEmpty() ) + return aEmail; + + QStringList addressList = KPIM::splitEmailAddrList( aEmail ); + + QString result; + + for( QStringList::ConstIterator it = addressList.begin(); + ( it != addressList.end() ); + ++it ) { + if( !(*it).isEmpty() ) { + QString address = *it; + if(aLink) { + result += "<a href=\"mailto:" + + KMMessage::encodeMailtoUrl( address ) + + "\" "+cssStyle+">"; + } + if( stripped ) + address = KMMessage::stripEmailAddr( address ); + result += KMMessage::quoteHtmlChars( address, true ); + if(aLink) + result += "</a>, "; + } + } + // cut of the trailing ", " + if(aLink) + result.truncate( result.length() - 2 ); + + //kdDebug(5006) << "KMMessage::emailAddrAsAnchor('" << aEmail + // << "') returns:\n-->" << result << "<--" << endl; + return result; +} + + +//----------------------------------------------------------------------------- +//static +QStringList KMMessage::stripAddressFromAddressList( const QString& address, + const QStringList& list ) +{ + QStringList addresses( list ); + QString addrSpec( KPIM::getEmailAddress( address ) ); + for ( QStringList::Iterator it = addresses.begin(); + it != addresses.end(); ) { + if ( kasciistricmp( addrSpec.utf8().data(), + KPIM::getEmailAddress( *it ).utf8().data() ) == 0 ) { + kdDebug(5006) << "Removing " << *it << " from the address list" + << endl; + it = addresses.remove( it ); + } + else + ++it; + } + return addresses; +} + + +//----------------------------------------------------------------------------- +//static +QStringList KMMessage::stripMyAddressesFromAddressList( const QStringList& list ) +{ + QStringList addresses = list; + for( QStringList::Iterator it = addresses.begin(); + it != addresses.end(); ) { + kdDebug(5006) << "Check whether " << *it << " is one of my addresses" + << endl; + if( kmkernel->identityManager()->thatIsMe( KPIM::getEmailAddress( *it ) ) ) { + kdDebug(5006) << "Removing " << *it << " from the address list" + << endl; + it = addresses.remove( it ); + } + else + ++it; + } + return addresses; +} + + +//----------------------------------------------------------------------------- +//static +bool KMMessage::addressIsInAddressList( const QString& address, + const QStringList& addresses ) +{ + QString addrSpec = KPIM::getEmailAddress( address ); + for( QStringList::ConstIterator it = addresses.begin(); + it != addresses.end(); ++it ) { + if ( kasciistricmp( addrSpec.utf8().data(), + KPIM::getEmailAddress( *it ).utf8().data() ) == 0 ) + return true; + } + return false; +} + + +//----------------------------------------------------------------------------- +//static +QString KMMessage::expandAliases( const QString& recipients ) +{ + if ( recipients.isEmpty() ) + return QString(); + + QStringList recipientList = KPIM::splitEmailAddrList( recipients ); + + QString expandedRecipients; + for ( QStringList::Iterator it = recipientList.begin(); + it != recipientList.end(); ++it ) { + if ( !expandedRecipients.isEmpty() ) + expandedRecipients += ", "; + QString receiver = (*it).stripWhiteSpace(); + + // try to expand distribution list + QString expandedList = KAddrBookExternal::expandDistributionList( receiver ); + if ( !expandedList.isEmpty() ) { + expandedRecipients += expandedList; + continue; + } + + // try to expand nick name + QString expandedNickName = KabcBridge::expandNickName( receiver ); + if ( !expandedNickName.isEmpty() ) { + expandedRecipients += expandedNickName; + continue; + } + + // check whether the address is missing the domain part + // FIXME: looking for '@' might be wrong + if ( receiver.find('@') == -1 ) { + KConfigGroup general( KMKernel::config(), "General" ); + QString defaultdomain = general.readEntry( "Default domain" ); + if( !defaultdomain.isEmpty() ) { + expandedRecipients += receiver + "@" + defaultdomain; + } + else { + expandedRecipients += guessEmailAddressFromLoginName( receiver ); + } + } + else + expandedRecipients += receiver; + } + + return expandedRecipients; +} + + +//----------------------------------------------------------------------------- +//static +QString KMMessage::guessEmailAddressFromLoginName( const QString& loginName ) +{ + if ( loginName.isEmpty() ) + return QString(); + + char hostnameC[256]; + // null terminate this C string + hostnameC[255] = '\0'; + // set the string to 0 length if gethostname fails + if ( gethostname( hostnameC, 255 ) ) + hostnameC[0] = '\0'; + QString address = loginName; + address += '@'; + address += QString::fromLocal8Bit( hostnameC ); + + // try to determine the real name + const KUser user( loginName ); + if ( user.isValid() ) { + QString fullName = user.fullName(); + if ( fullName.find( QRegExp( "[^ 0-9A-Za-z\\x0080-\\xFFFF]" ) ) != -1 ) + address = '"' + fullName.replace( '\\', "\\" ).replace( '"', "\\" ) + + "\" <" + address + '>'; + else + address = fullName + " <" + address + '>'; + } + + return address; +} + +//----------------------------------------------------------------------------- +void KMMessage::readConfig() +{ + KMMsgBase::readConfig(); + + KConfig *config=KMKernel::config(); + KConfigGroupSaver saver(config, "General"); + + config->setGroup("General"); + + int languageNr = config->readNumEntry("reply-current-language",0); + + { // area for config group "KMMessage #n" + KConfigGroupSaver saver(config, QString("KMMessage #%1").arg(languageNr)); + sReplyLanguage = config->readEntry("language",KGlobal::locale()->language()); + sReplyStr = config->readEntry("phrase-reply", + i18n("On %D, you wrote:")); + sReplyAllStr = config->readEntry("phrase-reply-all", + i18n("On %D, %F wrote:")); + sForwardStr = config->readEntry("phrase-forward", + i18n("Forwarded Message")); + sIndentPrefixStr = config->readEntry("indent-prefix",">%_"); + } + + { // area for config group "Composer" + KConfigGroupSaver saver(config, "Composer"); + sSmartQuote = GlobalSettings::self()->smartQuote(); + sWordWrap = GlobalSettings::self()->wordWrap(); + sWrapCol = GlobalSettings::self()->lineWrapWidth(); + if ((sWrapCol == 0) || (sWrapCol > 78)) + sWrapCol = 78; + if (sWrapCol < 30) + sWrapCol = 30; + + sPrefCharsets = config->readListEntry("pref-charsets"); + } + + { // area for config group "Reader" + KConfigGroupSaver saver(config, "Reader"); + sHeaderStrategy = HeaderStrategy::create( config->readEntry( "header-set-displayed", "rich" ) ); + } +} + +QCString KMMessage::defaultCharset() +{ + QCString retval; + + if (!sPrefCharsets.isEmpty()) + retval = sPrefCharsets[0].latin1(); + + if (retval.isEmpty() || (retval == "locale")) { + retval = QCString(kmkernel->networkCodec()->mimeName()); + KPIM::kAsciiToLower( retval.data() ); + } + + if (retval == "jisx0208.1983-0") retval = "iso-2022-jp"; + else if (retval == "ksc5601.1987-0") retval = "euc-kr"; + return retval; +} + +const QStringList &KMMessage::preferredCharsets() +{ + return sPrefCharsets; +} + +//----------------------------------------------------------------------------- +QCString KMMessage::charset() const +{ + if ( mMsg->Headers().HasContentType() ) { + DwMediaType &mType=mMsg->Headers().ContentType(); + mType.Parse(); + DwParameter *param=mType.FirstParameter(); + while(param){ + if (!kasciistricmp(param->Attribute().c_str(), "charset")) + return param->Value().c_str(); + else param=param->Next(); + } + } + return ""; // us-ascii, but we don't have to specify it +} + +//----------------------------------------------------------------------------- +void KMMessage::setCharset(const QCString& bStr) +{ + kdWarning( type() != DwMime::kTypeText ) + << "KMMessage::setCharset(): trying to set a charset for a non-textual mimetype." << endl + << "Fix this caller:" << endl + << "====================================================================" << endl + << kdBacktrace( 5 ) << endl + << "====================================================================" << endl; + QCString aStr = bStr; + KPIM::kAsciiToLower( aStr.data() ); + DwMediaType &mType = dwContentType(); + mType.Parse(); + DwParameter *param=mType.FirstParameter(); + while(param) + // FIXME use the mimelib functions here for comparison. + if (!kasciistricmp(param->Attribute().c_str(), "charset")) break; + else param=param->Next(); + if (!param){ + param=new DwParameter; + param->SetAttribute("charset"); + mType.AddParameter(param); + } + else + mType.SetModified(); + param->SetValue(DwString(aStr)); + mType.Assemble(); +} + + +//----------------------------------------------------------------------------- +void KMMessage::setStatus(const KMMsgStatus aStatus, int idx) +{ + if (mStatus == aStatus) + return; + KMMsgBase::setStatus(aStatus, idx); +} + +void KMMessage::setEncryptionState(const KMMsgEncryptionState s, int idx) +{ + if( mEncryptionState == s ) + return; + mEncryptionState = s; + mDirty = true; + KMMsgBase::setEncryptionState(s, idx); +} + +void KMMessage::setSignatureState(KMMsgSignatureState s, int idx) +{ + if( mSignatureState == s ) + return; + mSignatureState = s; + mDirty = true; + KMMsgBase::setSignatureState(s, idx); +} + +void KMMessage::setMDNSentState( KMMsgMDNSentState status, int idx ) { + if ( mMDNSentState == status ) + return; + if ( status == 0 ) + status = KMMsgMDNStateUnknown; + mMDNSentState = status; + mDirty = true; + KMMsgBase::setMDNSentState( status, idx ); +} + +//----------------------------------------------------------------------------- +void KMMessage::link( const KMMessage *aMsg, KMMsgStatus aStatus ) +{ + Q_ASSERT( aStatus == KMMsgStatusReplied + || aStatus == KMMsgStatusForwarded + || aStatus == KMMsgStatusDeleted ); + + QString message = headerField( "X-KMail-Link-Message" ); + if ( !message.isEmpty() ) + message += ','; + QString type = headerField( "X-KMail-Link-Type" ); + if ( !type.isEmpty() ) + type += ','; + + message += QString::number( aMsg->getMsgSerNum() ); + if ( aStatus == KMMsgStatusReplied ) + type += "reply"; + else if ( aStatus == KMMsgStatusForwarded ) + type += "forward"; + else if ( aStatus == KMMsgStatusDeleted ) + type += "deleted"; + + setHeaderField( "X-KMail-Link-Message", message ); + setHeaderField( "X-KMail-Link-Type", type ); +} + +//----------------------------------------------------------------------------- +void KMMessage::getLink(int n, ulong *retMsgSerNum, KMMsgStatus *retStatus) const +{ + *retMsgSerNum = 0; + *retStatus = KMMsgStatusUnknown; + + QString message = headerField("X-KMail-Link-Message"); + QString type = headerField("X-KMail-Link-Type"); + message = message.section(',', n, n); + type = type.section(',', n, n); + + if ( !message.isEmpty() && !type.isEmpty() ) { + *retMsgSerNum = message.toULong(); + if ( type == "reply" ) + *retStatus = KMMsgStatusReplied; + else if ( type == "forward" ) + *retStatus = KMMsgStatusForwarded; + else if ( type == "deleted" ) + *retStatus = KMMsgStatusDeleted; + } +} + +//----------------------------------------------------------------------------- +DwBodyPart* KMMessage::findDwBodyPart( DwBodyPart* part, const QString & partSpecifier ) +{ + if ( !part ) return 0; + DwBodyPart* current; + + if ( part->partId() == partSpecifier ) + return part; + + // multipart + if ( part->hasHeaders() && + part->Headers().HasContentType() && + part->Body().FirstBodyPart() && + (DwMime::kTypeMultipart == part->Headers().ContentType().Type() ) && + (current = findDwBodyPart( part->Body().FirstBodyPart(), partSpecifier )) ) + { + return current; + } + + // encapsulated message + if ( part->Body().Message() && + part->Body().Message()->Body().FirstBodyPart() && + (current = findDwBodyPart( part->Body().Message()->Body().FirstBodyPart(), + partSpecifier )) ) + { + return current; + } + + // next part + return findDwBodyPart( part->Next(), partSpecifier ); +} + +//----------------------------------------------------------------------------- +void KMMessage::updateBodyPart(const QString partSpecifier, const QByteArray & data) +{ + if ( !data.data() || !data.size() ) + return; + + DwString content( data.data(), data.size() ); + if ( numBodyParts() > 0 && + partSpecifier != "0" && + partSpecifier != "TEXT" ) + { + QString specifier = partSpecifier; + if ( partSpecifier.endsWith(".HEADER") || + partSpecifier.endsWith(".MIME") ) { + // get the parent bodypart + specifier = partSpecifier.section( '.', 0, -2 ); + } + + // search for the bodypart + mLastUpdated = findDwBodyPart( getFirstDwBodyPart(), specifier ); + kdDebug(5006) << "KMMessage::updateBodyPart " << specifier << endl; + if (!mLastUpdated) + { + kdWarning(5006) << "KMMessage::updateBodyPart - can not find part " + << specifier << endl; + return; + } + if ( partSpecifier.endsWith(".MIME") ) + { + // update headers + // get rid of EOL + content.resize( QMAX( content.length(), 2 ) - 2 ); + // we have to delete the fields first as they might have been created by + // an earlier call to DwHeaders::FieldBody + mLastUpdated->Headers().DeleteAllFields(); + mLastUpdated->Headers().FromString( content ); + mLastUpdated->Headers().Parse(); + } else if ( partSpecifier.endsWith(".HEADER") ) + { + // update header of embedded message + mLastUpdated->Body().Message()->Headers().FromString( content ); + mLastUpdated->Body().Message()->Headers().Parse(); + } else { + // update body + mLastUpdated->Body().FromString( content ); + QString parentSpec = partSpecifier.section( '.', 0, -2 ); + if ( !parentSpec.isEmpty() ) + { + DwBodyPart* parent = findDwBodyPart( getFirstDwBodyPart(), parentSpec ); + if ( parent && parent->hasHeaders() && parent->Headers().HasContentType() ) + { + const DwMediaType& contentType = parent->Headers().ContentType(); + if ( contentType.Type() == DwMime::kTypeMessage && + contentType.Subtype() == DwMime::kSubtypeRfc822 ) + { + // an embedded message that is not multipart + // update this directly + parent->Body().Message()->Body().FromString( content ); + } + } + } + } + + } else + { + // update text-only messages + if ( partSpecifier == "TEXT" ) + deleteBodyParts(); // delete empty parts first + mMsg->Body().FromString( content ); + mMsg->Body().Parse(); + } + mNeedsAssembly = true; + if (! partSpecifier.endsWith(".HEADER") ) + { + // notify observers + notify(); + } +} + +//----------------------------------------------------------------------------- +void KMMessage::updateAttachmentState( DwBodyPart* part ) +{ + if ( !part ) + part = getFirstDwBodyPart(); + + if ( !part ) + { + // kdDebug(5006) << "updateAttachmentState - no part!" << endl; + setStatus( KMMsgStatusHasNoAttach ); + return; + } + + bool filenameEmpty = true; + if ( part->hasHeaders() ) { + if ( part->Headers().HasContentDisposition() ) { + DwDispositionType cd = part->Headers().ContentDisposition(); + filenameEmpty = cd.Filename().empty(); + if ( filenameEmpty ) { + // let's try if it is rfc 2231 encoded which mimelib can't handle + filenameEmpty = KMMsgBase::decodeRFC2231String( KMMsgBase::extractRFC2231HeaderField( cd.AsString().c_str(), "filename" ) ).isEmpty(); + } + } + } + + if ( part->hasHeaders() && + ( ( part->Headers().HasContentDisposition() && + !part->Headers().ContentDisposition().Filename().empty() ) || + ( part->Headers().HasContentType() && + !filenameEmpty ) ) ) + { + // now blacklist certain ContentTypes + if ( !part->Headers().HasContentType() || + ( part->Headers().HasContentType() && + part->Headers().ContentType().Subtype() != DwMime::kSubtypePgpSignature && + part->Headers().ContentType().Subtype() != DwMime::kSubtypePkcs7Signature ) ) + { + setStatus( KMMsgStatusHasAttach ); + } + return; + } + + // multipart + if ( part->hasHeaders() && + part->Headers().HasContentType() && + part->Body().FirstBodyPart() && + (DwMime::kTypeMultipart == part->Headers().ContentType().Type() ) ) + { + updateAttachmentState( part->Body().FirstBodyPart() ); + } + + // encapsulated message + if ( part->Body().Message() && + part->Body().Message()->Body().FirstBodyPart() ) + { + updateAttachmentState( part->Body().Message()->Body().FirstBodyPart() ); + } + + // next part + if ( part->Next() ) + updateAttachmentState( part->Next() ); + else if ( attachmentState() == KMMsgAttachmentUnknown ) + setStatus( KMMsgStatusHasNoAttach ); +} + +void KMMessage::setBodyFromUnicode( const QString & str ) { + QCString encoding = KMMsgBase::autoDetectCharset( charset(), KMMessage::preferredCharsets(), str ); + if ( encoding.isEmpty() ) + encoding = "utf-8"; + const QTextCodec * codec = KMMsgBase::codecForName( encoding ); + assert( codec ); + QValueList<int> dummy; + setCharset( encoding ); + setBodyAndGuessCte( codec->fromUnicode( str ), dummy, false /* no 8bit */ ); +} + +const QTextCodec * KMMessage::codec() const { + const QTextCodec * c = mOverrideCodec; + if ( !c ) + // no override-codec set for this message, try the CT charset parameter: + c = KMMsgBase::codecForName( charset() ); + if ( !c ) { + // Ok, no override and nothing in the message, let's use the fallback + // the user configured + c = KMMsgBase::codecForName( GlobalSettings::self()->fallbackCharacterEncoding().latin1() ); + } + if ( !c ) + // no charset means us-ascii (RFC 2045), so using local encoding should + // be okay + c = kmkernel->networkCodec(); + assert( c ); + return c; +} + +QString KMMessage::bodyToUnicode(const QTextCodec* codec) const { + if ( !codec ) + // No codec was given, so try the charset in the mail + codec = this->codec(); + assert( codec ); + + return codec->toUnicode( bodyDecoded() ); +} + +//----------------------------------------------------------------------------- +QCString KMMessage::mboxMessageSeparator() +{ + QCString str( KPIM::getFirstEmailAddress( rawHeaderField("From") ) ); + if ( str.isEmpty() ) + str = "unknown@unknown.invalid"; + QCString dateStr( dateShortStr() ); + if ( dateStr.isEmpty() ) { + time_t t = ::time( 0 ); + dateStr = ctime( &t ); + const int len = dateStr.length(); + if ( dateStr[len-1] == '\n' ) + dateStr.truncate( len - 1 ); + } + return "From " + str + " " + dateStr + "\n"; +} + +void KMMessage::deleteWhenUnused() +{ + sPendingDeletes << this; +} |