Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 636 insertions, 0 deletions

diff --git a/libkpimidentities/identity.cpp b/libkpimidentities/identity.cpp
new file mode 100644
index 000000000..204e997e7
--- /dev/null
+++ b/libkpimidentities/identity.cpp
@@ -0,0 +1,636 @@
+// -*- mode: C++; c-file-style: "gnu" -*-
+// kmidentity.cpp
+// License: GPL
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "identity.h"
+
+#include <libkdepim/kfileio.h>
+#include <libkdepim/collectingprocess.h>
+
+#include <kdebug.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kconfig.h>
+#include <kurl.h>
+
+#include <qfileinfo.h>
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+
+using namespace KPIM;
+
+
+Signature::Signature()
+  : mType( Disabled )
+{
+
+}
+
+Signature::Signature( const QString & text )
+  : mText( text ),
+    mType( Inlined )
+{
+
+}
+
+Signature::Signature( const QString & url, bool isExecutable )
+  : mUrl( url ),
+    mType( isExecutable ? FromCommand : FromFile )
+{
+}
+
+bool Signature::operator==( const Signature & other ) const {
+  if ( mType != other.mType ) return false;
+  switch ( mType ) {
+  case Inlined: return mText == other.mText;
+  case FromFile:
+  case FromCommand: return mUrl == other.mUrl;
+  default:
+  case Disabled: return true;
+  }
+}
+
+QString Signature::rawText( bool * ok ) const
+{
+  switch ( mType ) {
+  case Disabled:
+    if ( ok ) *ok = true;
+    return QString::null;
+  case Inlined:
+    if ( ok ) *ok = true;
+    return mText;
+  case FromFile:
+    return textFromFile( ok );
+  case FromCommand:
+    return textFromCommand( ok );
+  };
+  kdFatal( 5006 ) << "Signature::type() returned unknown value!" << endl;
+  return QString::null; // make compiler happy
+}
+
+QString Signature::textFromCommand( bool * ok ) const
+{
+  assert( mType == FromCommand );
+
+  // handle pathological cases:
+  if ( mUrl.isEmpty() ) {
+    if ( ok ) *ok = true;
+    return QString::null;
+  }
+
+  // create a shell process:
+  CollectingProcess proc;
+  proc.setUseShell(true);
+  proc << mUrl;
+
+  // run the process:
+  int rc = 0;
+  if ( !proc.start( KProcess::Block, KProcess::Stdout ) )
+    rc = -1;
+  else
+    rc = ( proc.normalExit() ) ? proc.exitStatus() : -1 ;
+
+  // handle errors, if any:
+  if ( rc != 0 ) {
+    if ( ok ) *ok = false;
+    QString wmsg = i18n("<qt>Failed to execute signature script<br><b>%1</b>:<br>%2</qt>")
+      .arg( mUrl ).arg( strerror(rc) );
+    KMessageBox::error(0, wmsg);
+    return QString::null;
+  }
+
+  // no errors:
+  if ( ok ) *ok = true;
+
+  // get output:
+  QByteArray output = proc.collectedStdout();
+
+  // ### hmm, should we allow other encodings, too?
+  return QString::fromLocal8Bit( output.data(), output.size() );
+}
+
+QString Signature::textFromFile( bool * ok ) const
+{
+  assert( mType == FromFile );
+
+  // ### FIXME: Use KIO::NetAccess to download non-local files!
+  if ( !KURL(mUrl).isLocalFile() && !(QFileInfo(mUrl).isRelative()
+                                      && QFileInfo(mUrl).exists()) ) {
+    kdDebug( 5006 ) << "Signature::textFromFile: non-local URLs are unsupported" << endl;
+    if ( ok ) *ok = false;
+    return QString::null;
+  }
+  if ( ok ) *ok = true;
+  // ### hmm, should we allow other encodings, too?
+  return QString::fromLocal8Bit( kFileToString( mUrl, false ) );
+}
+
+QString Signature::withSeparator( bool * ok ) const
+{
+  bool internalOK = false;
+  QString signature = rawText( &internalOK );
+  if ( !internalOK ) {
+    if ( ok ) *ok = false;
+    return QString::null;
+  }
+  if ( ok ) *ok = true;
+  if ( signature.isEmpty() ) return signature; // don't add a separator in this case
+  if ( signature.startsWith( QString::fromLatin1("-- \n") ) )
+    // already have signature separator at start of sig:
+    return QString::fromLatin1("\n") += signature;
+  else if ( signature.find( QString::fromLatin1("\n-- \n") ) != -1 )
+    // already have signature separator inside sig; don't prepend '\n'
+    // to improve abusing signatures as templates:
+    return signature;
+  else
+    // need to prepend one:
+    return QString::fromLatin1("\n-- \n") + signature;
+}
+
+
+void Signature::setUrl( const QString & url, bool isExecutable )
+{
+  mUrl = url;
+  mType = isExecutable ? FromCommand : FromFile ;
+}
+
+// config keys and values:
+static const char sigTypeKey[] = "Signature Type";
+static const char sigTypeInlineValue[] = "inline";
+static const char sigTypeFileValue[] = "file";
+static const char sigTypeCommandValue[] = "command";
+static const char sigTypeDisabledValue[] = "disabled";
+static const char sigTextKey[] = "Inline Signature";
+static const char sigFileKey[] = "Signature File";
+static const char sigCommandKey[] = "Signature Command";
+
+void Signature::readConfig( const KConfigBase * config )
+{
+  QString sigType = config->readEntry( sigTypeKey );
+  if ( sigType == sigTypeInlineValue ) {
+    mType = Inlined;
+  } else if ( sigType == sigTypeFileValue ) {
+    mType = FromFile;
+    mUrl = config->readPathEntry( sigFileKey );
+  } else if ( sigType == sigTypeCommandValue ) {
+    mType = FromCommand;
+    mUrl = config->readPathEntry( sigCommandKey );
+  } else {
+    mType = Disabled;
+  }
+  mText = config->readEntry( sigTextKey );
+}
+
+void Signature::writeConfig( KConfigBase * config ) const
+{
+  switch ( mType ) {
+  case Inlined:
+    config->writeEntry( sigTypeKey, sigTypeInlineValue );
+    break;
+  case FromFile:
+    config->writeEntry( sigTypeKey, sigTypeFileValue );
+    config->writePathEntry( sigFileKey, mUrl );
+    break;
+  case FromCommand:
+    config->writeEntry( sigTypeKey, sigTypeCommandValue );
+    config->writePathEntry( sigCommandKey, mUrl );
+    break;
+  case Disabled:
+    config->writeEntry( sigTypeKey, sigTypeDisabledValue );
+  default: ;
+  }
+  config->writeEntry( sigTextKey, mText );
+}
+
+QDataStream & KPIM::operator<<( QDataStream & stream, const KPIM::Signature & sig ) {
+  return stream << static_cast<Q_UINT8>(sig.mType)
+		<< sig.mUrl
+		<< sig.mText;
+}
+
+QDataStream & KPIM::operator>>( QDataStream & stream, KPIM::Signature & sig ) {
+    Q_UINT8 s;
+    stream >> s
+           >> sig.mUrl
+           >> sig.mText;
+    sig.mType = static_cast<Signature::Type>(s);
+    return stream;
+}
+
+// ### should use a kstaticdeleter?
+static Identity* identityNull = 0;
+const Identity& Identity::null()
+{
+    if ( !identityNull )
+        identityNull = new Identity;
+    return *identityNull;
+}
+
+bool Identity::isNull() const {
+  return mIdentity.isEmpty() && mFullName.isEmpty() && mEmailAddr.isEmpty() &&
+    mOrganization.isEmpty() && mReplyToAddr.isEmpty() && mBcc.isEmpty() &&
+    mVCardFile.isEmpty() &&
+    mFcc.isEmpty() && mDrafts.isEmpty() && mTemplates.isEmpty() &&
+    mPGPEncryptionKey.isEmpty() && mPGPSigningKey.isEmpty() &&
+    mSMIMEEncryptionKey.isEmpty() && mSMIMESigningKey.isEmpty() &&
+    mTransport.isEmpty() && mDictionary.isEmpty() &&
+    mPreferredCryptoMessageFormat == Kleo::AutoFormat &&
+    mSignature.type() == Signature::Disabled &&
+    mXFace.isEmpty();
+}
+
+bool Identity::operator==( const Identity & other ) const {
+  bool same = mUoid == other.mUoid &&
+      mIdentity == other.mIdentity && mFullName == other.mFullName &&
+      mEmailAddr == other.mEmailAddr && mOrganization == other.mOrganization &&
+      mReplyToAddr == other.mReplyToAddr && mBcc == other.mBcc &&
+      mVCardFile == other.mVCardFile &&
+      mFcc == other.mFcc &&
+      mPGPEncryptionKey == other.mPGPEncryptionKey &&
+      mPGPSigningKey == other.mPGPSigningKey &&
+      mSMIMEEncryptionKey == other.mSMIMEEncryptionKey &&
+      mSMIMESigningKey == other.mSMIMESigningKey &&
+      mPreferredCryptoMessageFormat == other.mPreferredCryptoMessageFormat &&
+      mDrafts == other.mDrafts && mTemplates == other.mTemplates &&
+      mTransport == other.mTransport &&
+      mDictionary == other.mDictionary && mSignature == other.mSignature &&
+      mXFace == other.mXFace && mXFaceEnabled == other.mXFaceEnabled;
+
+#if 0
+  if ( same )
+    return true;
+  if ( mUoid != other.mUoid ) kdDebug() << "mUoid differs : " << mUoid << " != " << other.mUoid << endl;
+  if ( mIdentity != other.mIdentity ) kdDebug() << "mIdentity differs : " << mIdentity << " != " << other.mIdentity << endl;
+  if ( mFullName != other.mFullName ) kdDebug() << "mFullName differs : " << mFullName << " != " << other.mFullName << endl;
+  if ( mEmailAddr != other.mEmailAddr ) kdDebug() << "mEmailAddr differs : " << mEmailAddr << " != " << other.mEmailAddr << endl;
+  if ( mOrganization != other.mOrganization ) kdDebug() << "mOrganization differs : " << mOrganization << " != " << other.mOrganization << endl;
+  if ( mReplyToAddr != other.mReplyToAddr ) kdDebug() << "mReplyToAddr differs : " << mReplyToAddr << " != " << other.mReplyToAddr << endl;
+  if ( mBcc != other.mBcc ) kdDebug() << "mBcc differs : " << mBcc << " != " << other.mBcc << endl;
+  if ( mVCardFile != other.mVCardFile ) kdDebug() << "mVCardFile differs : " << mVCardFile << " != " << other.mVCardFile << endl;
+  if ( mFcc != other.mFcc ) kdDebug() << "mFcc differs : " << mFcc << " != " << other.mFcc << endl;
+  if ( mPGPEncryptionKey != other.mPGPEncryptionKey ) kdDebug() << "mPGPEncryptionKey differs : " << mPGPEncryptionKey << " != " << other.mPGPEncryptionKey << endl;
+  if ( mPGPSigningKey != other.mPGPSigningKey ) kdDebug() << "mPGPSigningKey differs : " << mPGPSigningKey << " != " << other.mPGPSigningKey << endl;
+  if ( mSMIMEEncryptionKey != other.mSMIMEEncryptionKey ) kdDebug() << "mSMIMEEncryptionKey differs : '" << mSMIMEEncryptionKey << "' != '" << other.mSMIMEEncryptionKey << "'" << endl;
+  if ( mSMIMESigningKey != other.mSMIMESigningKey ) kdDebug() << "mSMIMESigningKey differs : " << mSMIMESigningKey << " != " << other.mSMIMESigningKey << endl;
+  if ( mPreferredCryptoMessageFormat != other.mPreferredCryptoMessageFormat ) kdDebug() << "mPreferredCryptoMessageFormat differs : " << mPreferredCryptoMessageFormat << " != " << other.mPreferredCryptoMessageFormat << endl;
+  if ( mDrafts != other.mDrafts ) kdDebug() << "mDrafts differs : " << mDrafts << " != " << other.mDrafts << endl;
+  if ( mTemplates != other.mTemplates ) kdDebug() << "mTemplates differs : " << mTemplates << " != " << other.mTemplates << endl;
+  if ( mTransport != other.mTransport ) kdDebug() << "mTransport differs : " << mTransport << " != " << other.mTransport << endl;
+  if ( mDictionary != other.mDictionary ) kdDebug() << "mDictionary differs : " << mDictionary << " != " << other.mDictionary << endl;
+  if ( ! ( mSignature == other.mSignature ) ) kdDebug() << "mSignature differs" << endl;
+#endif
+  return same;
+}
+
+Identity::Identity( const QString & id, const QString & fullName,
+			const QString & emailAddr, const QString & organization,
+			const QString & replyToAddr )
+  : mUoid( 0 ), mIdentity( id ), mFullName( fullName ),
+    mEmailAddr( emailAddr ), mOrganization( organization ),
+    mReplyToAddr( replyToAddr ),
+    // Using "" instead of null to make operator==() not fail
+    // (readConfig returns "")
+    mBcc( "" ), mVCardFile( "" ), mPGPEncryptionKey( "" ), mPGPSigningKey( "" ),
+    mSMIMEEncryptionKey( "" ), mSMIMESigningKey( "" ), mFcc( "" ),
+    mDrafts( "" ), mTemplates( "" ), mTransport( "" ),
+    mDictionary( "" ),
+    mXFace( "" ), mXFaceEnabled( false ),
+    mIsDefault( false ),
+    mPreferredCryptoMessageFormat( Kleo::AutoFormat )
+{
+}
+
+Identity::~Identity()
+{
+}
+
+
+void Identity::readConfig( const KConfigBase * config )
+{
+  mUoid = config->readUnsignedNumEntry("uoid",0);
+
+  mIdentity = config->readEntry("Identity");
+  mFullName = config->readEntry("Name");
+  mEmailAddr = config->readEntry("Email Address");
+  mVCardFile = config->readPathEntry("VCardFile");
+  mOrganization = config->readEntry("Organization");
+  mPGPSigningKey = config->readEntry("PGP Signing Key").latin1();
+  mPGPEncryptionKey = config->readEntry("PGP Encryption Key").latin1();
+  mSMIMESigningKey = config->readEntry("SMIME Signing Key").latin1();
+  mSMIMEEncryptionKey = config->readEntry("SMIME Encryption Key").latin1();
+  mPreferredCryptoMessageFormat = Kleo::stringToCryptoMessageFormat( config->readEntry("Preferred Crypto Message Format", "none" ) );
+  mReplyToAddr = config->readEntry( "Reply-To Address" );
+  mBcc = config->readEntry( "Bcc" );
+  mFcc = config->readEntry( "Fcc", "sent-mail" );
+  if( mFcc.isEmpty() )
+    mFcc = "sent-mail";
+  mDrafts = config->readEntry( "Drafts", "drafts" );
+  if( mDrafts.isEmpty() )
+    mDrafts = "drafts";
+  mTemplates = config->readEntry( "Templates", "templates" );
+  if( mTemplates.isEmpty() )
+    mTemplates = "templates";
+  mTransport = config->readEntry( "Transport" );
+  mDictionary = config->readEntry( "Dictionary" );
+  mXFace = config->readEntry( "X-Face" );
+  mXFaceEnabled = config->readBoolEntry( "X-FaceEnabled", false );
+
+  mSignature.readConfig( config );
+  kdDebug(5006) << "Identity::readConfig(): UOID = " << mUoid
+	    << " for identity named \"" << mIdentity << "\"" << endl;
+}
+
+
+void Identity::writeConfig( KConfigBase * config ) const
+{
+  config->writeEntry("uoid", mUoid);
+
+  config->writeEntry("Identity", mIdentity);
+  config->writeEntry("Name", mFullName);
+  config->writeEntry("Organization", mOrganization);
+  config->writeEntry("PGP Signing Key", mPGPSigningKey.data());
+  config->writeEntry("PGP Encryption Key", mPGPEncryptionKey.data());
+  config->writeEntry("SMIME Signing Key", mSMIMESigningKey.data());
+  config->writeEntry("SMIME Encryption Key", mSMIMEEncryptionKey.data());
+  config->writeEntry("Preferred Crypto Message Format", Kleo::cryptoMessageFormatToString( mPreferredCryptoMessageFormat ) );
+  config->writeEntry("Email Address", mEmailAddr);
+  config->writeEntry("Reply-To Address", mReplyToAddr);
+  config->writeEntry("Bcc", mBcc);
+  config->writePathEntry("VCardFile", mVCardFile);
+  config->writeEntry("Transport", mTransport);
+  config->writeEntry("Fcc", mFcc);
+  config->writeEntry("Drafts", mDrafts);
+  config->writeEntry("Templates", mTemplates);
+  config->writeEntry( "Dictionary", mDictionary );
+  config->writeEntry( "X-Face", mXFace );
+  config->writeEntry( "X-FaceEnabled", mXFaceEnabled );
+
+  mSignature.writeConfig( config );
+}
+
+QDataStream & KPIM::operator<<( QDataStream & stream, const KPIM::Identity & i ) {
+  return stream << static_cast<Q_UINT32>(i.uoid())
+		<< i.identityName()
+		<< i.fullName()
+		<< i.organization()
+		<< i.pgpSigningKey()
+		<< i.pgpEncryptionKey()
+		<< i.smimeSigningKey()
+		<< i.smimeEncryptionKey()
+		<< i.emailAddr()
+		<< i.replyToAddr()
+		<< i.bcc()
+		<< i.vCardFile()
+		<< i.transport()
+		<< i.fcc()
+		<< i.drafts()
+                << i.templates()
+		<< i.mSignature
+                << i.dictionary()
+                << i.xface()
+		<< QString( Kleo::cryptoMessageFormatToString( i.mPreferredCryptoMessageFormat ) );
+}
+
+QDataStream & KPIM::operator>>( QDataStream & stream, KPIM::Identity & i ) {
+  Q_UINT32 uoid;
+  QString format;
+  stream        >> uoid
+		>> i.mIdentity
+		>> i.mFullName
+		>> i.mOrganization
+		>> i.mPGPSigningKey
+		>> i.mPGPEncryptionKey
+		>> i.mSMIMESigningKey
+		>> i.mSMIMEEncryptionKey
+		>> i.mEmailAddr
+		>> i.mReplyToAddr
+		>> i.mBcc
+		>> i.mVCardFile
+		>> i.mTransport
+		>> i.mFcc
+		>> i.mDrafts
+                >> i.mTemplates
+		>> i.mSignature
+                >> i.mDictionary
+                >> i.mXFace
+		>> format;
+  i.mUoid = uoid;
+  i.mPreferredCryptoMessageFormat = Kleo::stringToCryptoMessageFormat( format.latin1() );
+
+  return stream;
+}
+
+//-----------------------------------------------------------------------------
+bool Identity::mailingAllowed() const
+{
+  return !mEmailAddr.isEmpty();
+}
+
+
+void Identity::setIsDefault( bool flag ) {
+  mIsDefault = flag;
+}
+
+void Identity::setIdentityName( const QString & name ) {
+  mIdentity = name;
+}
+
+void Identity::setFullName(const QString &str)
+{
+  mFullName = str;
+}
+
+
+//-----------------------------------------------------------------------------
+void Identity::setOrganization(const QString &str)
+{
+  mOrganization = str;
+}
+
+void Identity::setPGPSigningKey(const QCString &str)
+{
+  mPGPSigningKey = str;
+  if ( mPGPSigningKey.isNull() )
+    mPGPSigningKey = "";
+}
+
+void Identity::setPGPEncryptionKey(const QCString &str)
+{
+  mPGPEncryptionKey = str;
+  if ( mPGPEncryptionKey.isNull() )
+    mPGPEncryptionKey = "";
+}
+
+void Identity::setSMIMESigningKey(const QCString &str)
+{
+  mSMIMESigningKey = str;
+  if ( mSMIMESigningKey.isNull() )
+    mSMIMESigningKey = "";
+}
+
+void Identity::setSMIMEEncryptionKey(const QCString &str)
+{
+  mSMIMEEncryptionKey = str;
+  if ( mSMIMEEncryptionKey.isNull() )
+    mSMIMEEncryptionKey = "";
+}
+
+//-----------------------------------------------------------------------------
+void Identity::setEmailAddr(const QString &str)
+{
+  mEmailAddr = str;
+}
+
+
+//-----------------------------------------------------------------------------
+void Identity::setVCardFile(const QString &str)
+{
+  mVCardFile = str;
+}
+
+
+//-----------------------------------------------------------------------------
+QString Identity::fullEmailAddr(void) const
+{
+  if (mFullName.isEmpty()) return mEmailAddr;
+
+  const QString specials("()<>@,.;:[]");
+
+  QString result;
+
+  // add DQUOTE's if necessary:
+  bool needsQuotes=false;
+  for (unsigned int i=0; i < mFullName.length(); i++) {
+    if ( specials.contains( mFullName[i] ) )
+      needsQuotes = true;
+    else if ( mFullName[i] == '\\' || mFullName[i] == '"' ) {
+      needsQuotes = true;
+      result += '\\';
+    }
+    result += mFullName[i];
+  }
+
+  if (needsQuotes) {
+    result.insert(0,'"');
+    result += '"';
+  }
+
+  result += " <" + mEmailAddr + '>';
+
+  return result;
+}
+
+//-----------------------------------------------------------------------------
+void Identity::setReplyToAddr(const QString& str)
+{
+  mReplyToAddr = str;
+}
+
+
+//-----------------------------------------------------------------------------
+void Identity::setSignatureFile(const QString &str)
+{
+  mSignature.setUrl( str, signatureIsCommand() );
+}
+
+
+//-----------------------------------------------------------------------------
+void Identity::setSignatureInlineText(const QString &str )
+{
+  mSignature.setText( str );
+}
+
+
+//-----------------------------------------------------------------------------
+void Identity::setTransport( const QString &str )
+{
+  mTransport = str;
+  if ( mTransport.isNull() )
+    mTransport = "";
+}
+
+//-----------------------------------------------------------------------------
+void Identity::setFcc( const QString &str )
+{
+  mFcc = str;
+  if ( mFcc.isNull() )
+    mFcc = "";
+}
+
+//-----------------------------------------------------------------------------
+void Identity::setDrafts( const QString &str )
+{
+  mDrafts = str;
+  if ( mDrafts.isNull() )
+    mDrafts = "";
+}
+
+//-----------------------------------------------------------------------------
+void Identity::setTemplates( const QString &str )
+{
+  mTemplates = str;
+  if ( mTemplates.isNull() )
+    mTemplates = "";
+}
+
+//-----------------------------------------------------------------------------
+void Identity::setDictionary( const QString &str )
+{
+  mDictionary = str;
+  if ( mDictionary.isNull() )
+    mDictionary = "";
+}
+
+
+//-----------------------------------------------------------------------------
+void Identity::setXFace( const QString &str )
+{
+  mXFace = str;
+  mXFace.remove( " " );
+  mXFace.remove( "\n" );
+  mXFace.remove( "\r" );
+}
+
+
+//-----------------------------------------------------------------------------
+void Identity::setXFaceEnabled( const bool on )
+{
+  mXFaceEnabled = on;
+}
+
+
+//-----------------------------------------------------------------------------
+QString Identity::signatureText( bool * ok ) const
+{
+  bool internalOK = false;
+  QString signatureText = mSignature.withSeparator( &internalOK );
+  if ( internalOK ) {
+    if ( ok ) *ok=true;
+    return signatureText;
+  }
+
+  // OK, here comes the funny part. The call to
+  // Signature::withSeparator() failed, so we should probably fix the
+  // cause:
+  if ( ok ) *ok = false;
+  return QString::null;
+
+#if 0 // ### FIXME: error handling
+  if (mSignatureFile.endsWith("|"))
+  {
+  }
+  else
+  {
+  }
+#endif
+
+  return QString::null;
+}