messagecore/mailinglist.cpp

   1 // -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
   2
   3 #include "mailinglist.h"
   4
   5 #include <kconfig.h>
   6 #include <kconfiggroup.h>
   7 #include <kurl.h>
   8 #include <kdebug.h>
   9
  10 #include <QtCore/QSharedData>
  11 #include <QtCore/QStringList>
  12
  13 #include <boost/shared_ptr.hpp>
  14
  15 using namespace MessageCore;
  16
  17 typedef QString (*MagicDetectorFunc)( const KMime::Message::Ptr&, QByteArray&, QString& );
  18
  19 /* Sender: (owner-([^@]+)|([^@+]-owner)@ */
  20 static QString check_sender( const KMime::Message::Ptr &message,
  21                              QByteArray &headerName,
  22                              QString &headerValue )
  23 {
  24   QString header = message->sender()->asUnicodeString();
  25
  26   if ( header.isEmpty() )
  27     return QString();
  28
  29   if ( header.left( 6 ) == "owner-" ) {
  30     headerName = "Sender";
  31     headerValue = header;
  32     header = header.mid( 6, header.indexOf( '@' ) - 6 );
  33   } else {
  34     const int index = header.indexOf( "-owner@ " );
  35     if ( index == -1 )
  36       return QString();
  37
  38     header.truncate( index );
  39     headerName = "Sender";
  40     headerValue = header;
  41   }
  42
  43   return header;
  44 }
  45
  46 /* X-BeenThere: ([^@]+) */
  47 static QString check_x_beenthere( const KMime::Message::Ptr &message,
  48                                   QByteArray &headerName,
  49                                   QString &headerValue )
  50 {
  51   QString header = message->headerByType( "X-BeenThere" ) ? message->headerByType( "X-BeenThere" )->asUnicodeString() : "";
  52   if ( header.isNull() || header.indexOf( '@' ) == -1 )
  53     return QString();
  54
  55   headerName = "X-BeenThere";
  56   headerValue = header;
  57   header.truncate( header.indexOf( '@' ) );
  58
  59   return header;
  60 }
  61
  62 /* Delivered-To:: <([^@]+) */
  63 static QString check_delivered_to( const KMime::Message::Ptr &message,
  64                                    QByteArray &headerName,
  65                                    QString &headerValue )
  66 {
  67   QString header = message->headerByType( "Delivered-To" ) ? message->headerByType( "Delivered-To" )->asUnicodeString() : "";
  68   if ( header.isNull() || header.left( 13 ) != "mailing list"
  69        || header.indexOf( '@' ) == -1 )
  70     return QString();
  71
  72   headerName = "Delivered-To";
  73   headerValue = header;
  74
  75   return header.mid( 13, header.indexOf( '@' ) - 13 );
  76 }
  77
  78 /* X-Mailing-List: <?([^@]+) */
  79 static QString check_x_mailing_list( const KMime::Message::Ptr &message,
  80                                      QByteArray &headerName,
  81                                      QString &headerValue )
  82 {
  83   QString header = message->headerByType( "X-Mailing-List" ) ? message->headerByType( "X-Mailing-List" )->asUnicodeString() : "";
  84   if ( header.isEmpty() )
  85     return QString();
  86
  87   if ( header.indexOf( '@' ) < 1 )
  88     return QString();
  89
  90   headerName = "X-Mailing-List";
  91   headerValue = header;
  92   if ( header[0] == '<' )
  93     header = header.mid( 1,  header.indexOf( '@' ) - 1 );
  94   else
  95     header.truncate( header.indexOf( '@' ) );
  96
  97   return header;
  98 }
  99
 100 /* List-Id: [^<]* <([^.]+) */
 101 static QString check_list_id( const KMime::Message::Ptr &message,
 102                               QByteArray &headerName,
 103                               QString &headerValue )
 104 {
 105   QString header = message->headerByType( "List-Id" ) ? message->headerByType( "List-Id" )->asUnicodeString() : "";
 106   if ( header.isEmpty() )
 107     return QString();
 108
 109   const int leftAnglePos = header.indexOf( '<' );
 110   if ( leftAnglePos < 0 )
 111     return QString();
 112
 113   const int firstDotPos = header.indexOf( '.', leftAnglePos );
 114   if ( firstDotPos < 0 )
 115     return QString();
 116
 117   headerName = "List-Id";
 118   headerValue = header.mid( leftAnglePos );
 119   header = header.mid( leftAnglePos + 1, firstDotPos - leftAnglePos - 1 );
 120
 121   return header;
 122 }
 123
 124
 125 /* List-Post: <mailto:[^< ]*>) */
 126 static QString check_list_post( const KMime::Message::Ptr &message,
 127                                 QByteArray &headerName,
 128                                 QString &headerValue )
 129 {
 130   QString header = message->headerByType( "List-Post" ) ? message->headerByType( "List-Post" )->asUnicodeString() : "";
 131   if ( header.isEmpty() )
 132     return QString();
 133
 134   int leftAnglePos = header.indexOf( "<mailto:" );
 135   if ( leftAnglePos < 0 )
 136     return QString();
 137
 138   headerName = "List-Post";
 139   headerValue = header;
 140   header = header.mid( leftAnglePos + 8, header.length() );
 141   header.truncate( header.indexOf( '@' ) );
 142
 143   return header;
 144 }
 145
 146 /* Mailing-List: list ([^@]+) */
 147 static QString check_mailing_list( const KMime::Message::Ptr &message,
 148                                    QByteArray &headerName,
 149                                    QString &headerValue )
 150 {
 151   QString header = message->headerByType( "Mailing-List" ) ? message->headerByType( "Mailing-List" )->asUnicodeString() : "";
 152   if ( header.isEmpty() )
 153     return QString();
 154
 155   if ( header.left( 5 ) != "list " || header.indexOf( '@' ) < 5 )
 156     return QString();
 157
 158   headerName = "Mailing-List";
 159   headerValue = header;
 160   header = header.mid( 5,  header.indexOf( '@' ) - 5 );
 161
 162   return header;
 163 }
 164
 165
 166 /* X-Loop: ([^@]+) */
 167 static QString check_x_loop( const KMime::Message::Ptr &message,
 168                              QByteArray &headerName,
 169                              QString &headerValue )
 170 {
 171   QString header = message->headerByType( "X-Loop" ) ? message->headerByType( "X-Loop" )->asUnicodeString() : "";
 172   if ( header.isEmpty() )
 173     return QString();
 174
 175   if (header.indexOf( '@' ) < 2 )
 176     return QString();
 177
 178   headerName = "X-Loop";
 179   headerValue = header;
 180   header.truncate( header.indexOf( '@' ) );
 181
 182   return header;
 183 }
 184
 185 /* X-ML-Name: (.+) */
 186 static QString check_x_ml_name( const KMime::Message::Ptr &message,
 187                                 QByteArray &headerName,
 188                                 QString &headerValue )
 189 {
 190   QString header = message->headerByType( "X-ML-Name" ) ? message->headerByType( "X-ML-Name" )->asUnicodeString() : "";
 191   if ( header.isEmpty() )
 192     return QString();
 193
 194   headerName = "X-ML-Name";
 195   headerValue = header;
 196   header.truncate( header.indexOf( '@' ) );
 197
 198   return header;
 199 }
 200
 201 MagicDetectorFunc magic_detector[] =
 202 {
 203   check_list_id,
 204   check_list_post,
 205   check_sender,
 206   check_x_mailing_list,
 207   check_mailing_list,
 208   check_delivered_to,
 209   check_x_beenthere,
 210   check_x_loop,
 211   check_x_ml_name
 212 };
 213
 214 static const int num_detectors = sizeof( magic_detector ) / sizeof( magic_detector[0] );
 215
 216 static QStringList headerToAddress( const QString &header )
 217 {
 218   QStringList addresses;
 219   int start = 0;
 220   int end = 0;
 221
 222   if ( header.isEmpty() )
 223     return addresses;
 224
 225   while ( (start = header.indexOf( "<", start )) != -1 ) {
 226     if ( (end = header.indexOf( ">", ++start ) ) == -1 ) {
 227       kWarning() << "Serious mailing list header parsing error!";
 228       return addresses;
 229     }
 230
 231     addresses.append( header.mid( start, end - start ) );
 232   }
 233
 234   return  addresses;
 235 }
 236
 237 class MessageCore::MailingList::Private : public QSharedData
 238 {
 239   public:
 240     Private()
 241       : mFeatures( None ),
 242         mHandler( KMail )
 243     {
 244     }
 245
 246     Private( const Private &other )
 247       : QSharedData( other )
 248     {
 249       mFeatures = other.mFeatures;
 250       mHandler = other.mHandler;
 251       mPostUrls = other.mPostUrls;
 252       mSubscribeUrls = other.mSubscribeUrls;
 253       mUnsubscribeUrls = other.mUnsubscribeUrls;
 254       mHelpUrls = other.mHelpUrls;
 255       mArchiveUrls = other.mArchiveUrls;
 256       mOwnerUrls = other.mOwnerUrls;
 257       mArchivedAtUrl = other.mArchivedAtUrl;
 258       mId = other.mId;
 259     }
 260
 261     Features mFeatures;
 262     Handler mHandler;
 263     KUrl::List mPostUrls;
 264     KUrl::List mSubscribeUrls;
 265     KUrl::List mUnsubscribeUrls;
 266     KUrl::List mHelpUrls;
 267     KUrl::List mArchiveUrls;
 268     KUrl::List mOwnerUrls;
 269     KUrl mArchivedAtUrl;
 270     QString mId;
 271 };
 272
 273 MailingList MailingList::detect( const KMime::Message::Ptr &message )
 274 {
 275   MailingList mailingList;
 276
 277   if ( message->headerByType( "List-Post" ) )
 278     mailingList.setPostUrls( headerToAddress( message->headerByType( "List-Post" )->asUnicodeString() ) );
 279
 280   if ( message->headerByType( "List-Help" ) )
 281     mailingList.setHelpUrls( headerToAddress( message->headerByType( "List-Help" )->asUnicodeString() ) );
 282
 283   if ( message->headerByType( "List-Subscribe" ) )
 284     mailingList.setSubscribeUrls( headerToAddress( message->headerByType( "List-Subscribe" )->asUnicodeString() ) );
 285
 286   if ( message->headerByType( "List-Unsubscribe" ) )
 287     mailingList.setUnsubscribeUrls( headerToAddress( message->headerByType( "List-Unsubscribe" )->asUnicodeString() ) );
 288
 289   if ( message->headerByType( "List-Archive" ) )
 290     mailingList.setArchiveUrls( headerToAddress( message->headerByType( "List-Archive" )->asUnicodeString() ) );
 291
 292   if ( message->headerByType( "List-Owner" ) )
 293     mailingList.setOwnerUrls( headerToAddress( message->headerByType( "List-Owner" )->asUnicodeString() ) );
 294
 295   if ( message->headerByType( "Archived-At" ) )
 296     mailingList.setArchivedAtUrl( KUrl( message->headerByType( "Archived-At" )->asUnicodeString() ) );
 297
 298   if ( message->headerByType( "List-Id" ) )
 299     mailingList.setId( message->headerByType( "List-Id" )->asUnicodeString() );
 300
 301   return mailingList;
 302 }
 303
 304 QString MailingList::name( const KMime::Message::Ptr &message,
 305                            QByteArray &headerName, QString &headerValue )
 306 {
 307   QString mailingList;
 308   headerName = QByteArray();
 309   headerValue.clear();
 310
 311   if ( !message )
 312     return QString();
 313
 314   for ( int i = 0; i < num_detectors; i++ ) {
 315     mailingList = magic_detector[i]( message, headerName, headerValue );
 316     if ( !mailingList.isNull() )
 317       return mailingList;
 318   }
 319
 320   return QString();
 321 }
 322
 323 MailingList::MailingList()
 324   : d( new Private )
 325 {
 326 }
 327
 328 MailingList::MailingList( const MailingList &other )
 329   : d( other.d )
 330 {
 331 }
 332
 333 MailingList& MailingList::operator=( const MailingList &other )
 334 {
 335   if ( this != &other )
 336     d = other.d;
 337
 338   return *this;
 339 }
 340
 341 MailingList::~MailingList()
 342 {
 343 }
 344
 345 MailingList::Features MailingList::features() const
 346 {
 347   return d->mFeatures;
 348 }
 349
 350 void MailingList::setHandler( MailingList::Handler handler )
 351 {
 352   d->mHandler = handler;
 353 }
 354
 355 MailingList::Handler MailingList::handler() const
 356 {
 357   return d->mHandler;
 358 }
 359
 360 void MailingList::setPostUrls( const KUrl::List &urls )
 361 {
 362   d->mFeatures |= Post;
 363
 364   if ( urls.empty() ) {
 365     d->mFeatures ^= Post;
 366   }
 367
 368   d->mPostUrls = urls;
 369 }
 370
 371 KUrl::List MailingList::postUrls() const
 372 {
 373   return d->mPostUrls;
 374 }
 375
 376 void MailingList::setSubscribeUrls( const KUrl::List &urls )
 377 {
 378   d->mFeatures |= Subscribe;
 379
 380   if ( urls.empty() ) {
 381     d->mFeatures ^= Subscribe;
 382   }
 383
 384   d->mSubscribeUrls = urls;
 385 }
 386
 387 KUrl::List MailingList::subscribeUrls() const
 388 {
 389   return d->mSubscribeUrls;
 390 }
 391
 392 void MailingList::setUnsubscribeUrls( const KUrl::List &urls )
 393 {
 394   d->mFeatures |= Unsubscribe;
 395
 396   if ( urls.empty() ) {
 397     d->mFeatures ^= Unsubscribe;
 398   }
 399
 400   d->mUnsubscribeUrls = urls;
 401 }
 402
 403 KUrl::List MailingList::unsubscribeUrls() const
 404 {
 405   return d->mUnsubscribeUrls;
 406 }
 407
 408 void MailingList::setHelpUrls( const KUrl::List &urls )
 409 {
 410   d->mFeatures |= Help;
 411
 412   if ( urls.empty() ) {
 413     d->mFeatures ^= Help;
 414   }
 415
 416   d->mHelpUrls = urls;
 417 }
 418
 419 KUrl::List MailingList::helpUrls() const
 420 {
 421   return d->mHelpUrls;
 422 }
 423
 424 void MailingList::setArchiveUrls( const KUrl::List &urls )
 425 {
 426   d->mFeatures |= Archive;
 427
 428   if ( urls.empty() ) {
 429     d->mFeatures ^= Archive;
 430   }
 431
 432   d->mArchiveUrls = urls;
 433 }
 434
 435 KUrl::List MailingList::archiveUrls() const
 436 {
 437   return d->mArchiveUrls;
 438 }
 439
 440 void MailingList::setOwnerUrls( const KUrl::List &urls )
 441 {
 442   d->mFeatures |= Owner;
 443
 444   if ( urls.empty() ) {
 445     d->mFeatures ^= Owner;
 446   }
 447
 448   d->mOwnerUrls = urls;
 449 }
 450
 451 KUrl::List MailingList::ownerUrls() const
 452 {
 453   return d->mOwnerUrls;
 454 }
 455
 456 void MailingList::setArchivedAtUrl( const KUrl &url )
 457 {
 458   d->mFeatures |= ArchivedAt;
 459
 460   if ( !url.isValid() ) {
 461     d->mFeatures ^= ArchivedAt;
 462   }
 463
 464   d->mArchivedAtUrl = url;
 465 }
 466
 467 KUrl MailingList::archivedAtUrl() const
 468 {
 469   return d->mArchivedAtUrl;
 470 }
 471
 472 void MailingList::setId( const QString &id )
 473 {
 474   d->mFeatures |= Id;
 475
 476   if ( id.isEmpty() ) {
 477     d->mFeatures ^= Id;
 478   }
 479
 480   d->mId = id;
 481 }
 482
 483 QString MailingList::id() const
 484 {
 485   return d->mId;
 486 }
 487
 488 void MailingList::writeConfig( KConfigGroup &group ) const
 489 {
 490   group.writeEntry( "MailingListFeatures", static_cast<int>( d->mFeatures ) );
 491   group.writeEntry( "MailingListHandler", static_cast<int>( d->mHandler ) );
 492   group.writeEntry( "MailingListId", d->mId );
 493   group.writeEntry( "MailingListPostingAddress", d->mPostUrls.toStringList() );
 494   group.writeEntry( "MailingListSubscribeAddress", d->mSubscribeUrls.toStringList() );
 495   group.writeEntry( "MailingListUnsubscribeAddress", d->mUnsubscribeUrls.toStringList() );
 496   group.writeEntry( "MailingListArchiveAddress", d->mArchiveUrls.toStringList() );
 497   group.writeEntry( "MailingListOwnerAddress", d->mOwnerUrls.toStringList() );
 498   group.writeEntry( "MailingListHelpAddress", d->mHelpUrls.toStringList() );
 499   /* Note: mArchivedAtUrl deliberately not saved here as it refers to a single
 500    * instance of a message rather than an element of a general mailing list.
 501    * http://reviewboard.kde.org/r/1768/#review2783
 502    */
 503 }
 504
 505 void MailingList::readConfig( const KConfigGroup &group )
 506 {
 507   d->mFeatures = static_cast<MailingList::Features>( group.readEntry( "MailingListFeatures", 0 ) );
 508   d->mHandler = static_cast<MailingList::Handler>( group.readEntry( "MailingListHandler",
 509                                                                     static_cast<int>( MailingList::KMail ) ) );
 510   d->mId = group.readEntry("MailingListId");
 511   d->mPostUrls = group.readEntry( "MailingListPostingAddress", QStringList() );
 512   d->mSubscribeUrls = group.readEntry( "MailingListSubscribeAddress", QStringList() );
 513   d->mUnsubscribeUrls = group.readEntry( "MailingListUnsubscribeAddress", QStringList() );
 514   d->mArchiveUrls = group.readEntry( "MailingListArchiveAddress", QStringList() );
 515   d->mOwnerUrls = group.readEntry( "MailingListOwnerddress", QStringList() );
 516   d->mHelpUrls = group.readEntry( "MailingListHelpAddress", QStringList() );
 517 }