kmime_headers.h

/*
    kmime_headers.h
 
    KMime, the KDE internet mail/usenet news message library.
    Copyright (c) 2001-2002 the KMime authors.
    See file AUTHORS for details
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 2.0 as
    published by the Free Software Foundation.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, US
*/
#ifndef __KMIME_HEADERS_H__
#define __KMIME_HEADERS_H__
 
// Content:
//
// - header's base class defining the common interface
// - generic base classes for different types of fields
// - incompatible, GStructured-based field classes
// - compatible, GUnstructured-based field classes
 
#include "kmime_header_parsing.h"
 
#include <tqstring.h>
#include <tqstrlist.h>
#include <tqstringlist.h>
#include <tqregexp.h>
#include <tqdatetime.h>
#include <tqasciidict.h>
#include <tqmap.h>
#include <tqptrlist.h>
 
#include <time.h>
 
#include <tdemacros.h>
 
namespace KMime {
 
//forward declaration
class Content;
 
namespace Headers {
 
 
enum contentCategory    { CCsingle,
                          CCcontainer,
                          CCmixedPart,
                          CCalternativePart };
 
enum contentEncoding    { CE7Bit,
                          CE8Bit,
                          CEquPr,
                          CEbase64,
                          CEuuenc,
                          CEbinary };
 
enum contentDisposition { CDinline,
                          CDattachment,
                          CDparallel };
 
//often used charset
static const TQCString Latin1("ISO-8859-1");
 
#define mk_trivial_subclass_with_name( subclass, subclassName, baseclass ) \
class subclass : public Generics::baseclass { \
public: \
  subclass() : Generics::baseclass() {} \
  subclass( Content * p ) : Generics::baseclass( p ) {} \
  subclass( Content * p, const TQCString & s ) \
    : Generics::baseclass( p ) { from7BitString( s ); } \
  subclass( Content * p, const TQString & s, const TQCString & cs ) \
    : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
  ~subclass() {} \
  \
  const char * type() const { return #subclassName; } \
}
 
#define mk_trivial_subclass( subclass, baseclass ) \
mk_trivial_subclass_with_name( subclass, subclass, baseclass )
 
#define mk_parsing_subclass_with_name( subclass, subclassName, baseclass ) \
class subclass : public Generics::baseclass { \
public: \
  subclass() : Generics::baseclass() {} \
  subclass( Content * p ) : Generics::baseclass( p ) {} \
  subclass( Content * p, const TQCString & s ) \
    : Generics::baseclass( p ) { from7BitString( s ); } \
  subclass( Content * p, const TQString & s, const TQCString & cs ) \
    : Generics::baseclass( p ) { fromUnicodeString( s, cs ); } \
  ~subclass() {} \
  \
  const char * type() const { return #subclassName; } \
protected: \
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false ); \
}
 
#define mk_parsing_subclass( subclass, baseclass ) \
mk_parsing_subclass_with_name( subclass, subclass, baseclass )
 
//
//
// HEADER'S BASE CLASS. DEFINES THE COMMON INTERFACE
//
//
 
class TDE_EXPORT Base {
 
  public:
    typedef TQPtrList<Base> List;
 
    Base() : e_ncCS(0), p_arent(0) {}
 
    Base(KMime::Content *parent) : e_ncCS(0), p_arent(parent) {}
 
    virtual ~Base()  {}
 
    KMime::Content* parent()  { return p_arent; }
 
    void setParent(KMime::Content *p)  { p_arent=p; }
 
    virtual void from7BitString(const TQCString&)  {}
 
    virtual TQCString as7BitString(bool=true)  { return TQCString(); }
 
    TQCString rfc2047Charset();
 
    void setRFC2047Charset(const TQCString &cs);
 
    TQCString defaultCS();
 
    bool forceCS();
 
    virtual void fromUnicodeString(const TQString&, const TQCString&)  {}
 
    virtual TQString asUnicodeString()  { return TQString(); }
 
    virtual void clear()  {}
 
    virtual bool isEmpty()  { return false; }
 
    virtual const char* type()  { return ""; }
 
    bool is(const char* t)  { return (strcasecmp(t, type())==0); }
 
    bool isMimeHeader()  { return (strncasecmp(type(), "Content-", 8)==0); }
 
    bool isXHeader()  { return (strncmp(type(), "X-", 2)==0); }
 
  protected:
    TQCString typeIntro()  { return (TQCString(type())+": "); }
 
    const char *e_ncCS;
    Content *p_arent;
 
};
 
 
//
//
// GENERIC BASE CLASSES FOR DIFFERENT TYPES OF FIELDS
//
//
 
namespace Generics {
 
  // known issues:
  // - uses old decodeRFC2047String function, instead of our own...
 
class TDE_EXPORT GUnstructured : public Base {
 
public:
  GUnstructured() : Base()  {}
  GUnstructured( Content * p ) : Base( p ) {}
  GUnstructured( Content * p, const TQCString & s )
    : Base( p ) { from7BitString(s); }
  GUnstructured( Content * p, const TQString & s, const TQCString & cs )
    : Base( p )  { fromUnicodeString( s, cs ); }
  ~GUnstructured()  {}
 
  virtual void from7BitString( const TQCString& str );
  virtual TQCString as7BitString( bool withHeaderType=true );
 
  virtual void fromUnicodeString( const TQString & str,
                  const TQCString & suggestedCharset);
  virtual TQString asUnicodeString();
 
  virtual void clear()            { d_ecoded.truncate(0); }
  virtual bool isEmpty()          { return (d_ecoded.isEmpty()); }
 
private:
  TQString d_ecoded;
};
 
class TDE_EXPORT GStructured : public Base {
public:
  GStructured() : Base()  {}
  GStructured( Content * p ) : Base( p ) {}
  GStructured( Content * p, const TQCString & s )
    : Base( p ) { from7BitString(s); }
  GStructured( Content * p, const TQString & s, const TQCString & cs )
    : Base( p )  { fromUnicodeString( s, cs ); }
  ~GStructured()  {}
 
  
protected:
#if 0
  // the assembly squad:
 
  bool writeAtom( char* & dcursor, const char * const dend, const TQString & input );
  bool writeAtom( char* & dcursor, const char * const dend,
          const TQPair<const char*,int> & input );
  bool writeToken( char* & dcursor, const char * const dend, const TQString & input );
  bool writeToken( char* & dcursor, const char * const dend,
           const TQPair<const char*int> & input );
 
  bool writeGenericQuotedString( char* & dcursor, const char * const dend,
                 const TQString & input, bool withCRLF=false );
  bool writeComment( char* & dcursor, const char * const dend,
             const TQString & input, bool withCRLF=false );
  bool writePhrase( char* & dcursor, const char * const dend,
            const TQString & input, bool withCRLF=false );
  bool writeDotAtom( char* & dcursor, const char * const dend,
             const TQString & input, bool withCRLF=false );
#endif
};
 
 
class TDE_EXPORT GAddress : public GStructured {
public:
  GAddress() : GStructured()  {}
  GAddress( Content * p ) : GStructured( p ) {}
  GAddress( Content * p, const TQCString & s )
    : GStructured( p ) { from7BitString(s); }
  GAddress( Content * p, const TQString & s, const TQCString & cs )
    : GStructured( p )  { fromUnicodeString( s, cs ); }
  ~GAddress()  {}
 
protected:
};
 
 
class TDE_EXPORT MailboxList : public GAddress {
public:
  MailboxList() : GAddress()  {}
  MailboxList( Content * p ) : GAddress( p ) {}
  MailboxList( Content * p, const TQCString & s )
    : GAddress( p ) { from7BitString(s); }
  MailboxList( Content * p, const TQString & s, const TQCString & cs )
    : GAddress( p )  { fromUnicodeString( s, cs ); }
  ~MailboxList()  {}
 
protected:
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 
  TQValueList<Types::Mailbox> mMailboxList;
};
 
 
mk_parsing_subclass(SingleMailbox,MailboxList);
 
class TDE_EXPORT AddressList : public GAddress {
public:
  AddressList() : GAddress()  {}
  AddressList( Content * p ) : GAddress( p ) {}
  AddressList( Content * p, const TQCString & s )
    : GAddress( p ) { from7BitString(s); }
  AddressList( Content * p, const TQString & s, const TQCString & cs )
    : GAddress( p )  { fromUnicodeString( s, cs ); }
  ~AddressList()  {}
 
protected:
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 
  TQValueList<Types::Address> mAddressList;
};
 
class TDE_EXPORT GIdent : public GAddress {
public:
  GIdent() : GAddress()  {}
  GIdent( Content * p ) : GAddress( p ) {}
  GIdent( Content * p, const TQCString & s )
    : GAddress( p ) { from7BitString(s); }
  GIdent( Content * p, const TQString & s, const TQCString & cs )
    : GAddress( p )  { fromUnicodeString( s, cs ); }
  ~GIdent()  {}
 
protected:
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 
  TQValueList<Types::AddrSpec> mMsgIdList;
};
 
mk_parsing_subclass(GSingleIdent,GIdent);
 
class TDE_EXPORT GToken : public GStructured {
public:
  GToken() : GStructured()  {}
  GToken( Content * p ) : GStructured( p ) {}
  GToken( Content * p, const TQCString & s )
    : GStructured( p ) { from7BitString(s); }
  GToken( Content * p, const TQString & s, const TQCString & cs )
    : GStructured( p )  { fromUnicodeString( s, cs ); }
  ~GToken()  {}
 
protected:
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 
  TQCString mToken;
};
 
 
class TDE_EXPORT GPhraseList : public GStructured {
public:
  GPhraseList() : GStructured()  {}
  GPhraseList( Content * p ) : GStructured( p ) {}
  GPhraseList( Content * p, const TQCString & s )
    : GStructured( p ) { from7BitString(s); }
  GPhraseList( Content * p, const TQString & s, const TQCString & cs )
    : GStructured( p )  { fromUnicodeString( s, cs ); }
  ~GPhraseList()  {}
 
protected:
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 
  TQStringList mPhraseList;
};
 
class TDE_EXPORT GDotAtom : public GStructured {
public:
  GDotAtom() : GStructured()  {}
  GDotAtom( Content * p ) : GStructured( p ) {}
  GDotAtom( Content * p, const TQCString & s )
    : GStructured( p ) { from7BitString(s); }
  GDotAtom( Content * p, const TQString & s, const TQCString & cs )
    : GStructured( p )  { fromUnicodeString( s, cs ); }
  ~GDotAtom()  {}
 
protected:
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 
  TQString mDotAtom;
};
 
class TDE_EXPORT GParametrized : public GStructured {
public:
  GParametrized() : GStructured()  {}
  GParametrized( Content * p ) : GStructured( p ) {}
  GParametrized( Content * p, const TQCString & s )
    : GStructured( p ) { from7BitString(s); }
  GParametrized( Content * p, const TQString & s, const TQCString & cs )
    : GStructured( p )  { fromUnicodeString( s, cs ); }
  ~GParametrized()  {}
 
protected:
  TQMap<TQString,TQString> mParameterHash;
 
private:
};
 
class TDE_EXPORT GContentType : public GParametrized {
public:
  GContentType() : GParametrized()  {}
  GContentType( Content * p ) : GParametrized( p ) {}
  GContentType( Content * p, const TQCString & s )
    : GParametrized( p ) { from7BitString(s); }
  GContentType( Content * p, const TQString & s, const TQCString & cs )
    : GParametrized( p )  { fromUnicodeString( s, cs ); }
  ~GContentType()  {}
 
protected:
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 
  TQCString mMimeType;
  TQCString mMimeSubType;
};
 
 
class TDE_EXPORT GCISTokenWithParameterList : public GParametrized {
public:
  GCISTokenWithParameterList() : GParametrized()  {}
  GCISTokenWithParameterList( Content * p ) : GParametrized( p ) {}
  GCISTokenWithParameterList( Content * p, const TQCString & s )
    : GParametrized( p ) { from7BitString(s); }
  GCISTokenWithParameterList( Content * p, const TQString & s, const TQCString & cs )
    : GParametrized( p )  { fromUnicodeString( s, cs ); }
  ~GCISTokenWithParameterList()  {}
 
protected:
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
 
  TQCString mToken;
};
 
 
} // namespace Generics
 
//
//
// INCOMPATIBLE, GSTRUCTURED-BASED FIELDS:
//
//
 
 
class TDE_EXPORT ReturnPath : public Generics::GAddress {
public:
  ReturnPath() : Generics::GAddress()  {}
  ReturnPath( Content * p ) : Generics::GAddress( p ) {}
  ReturnPath( Content * p, const TQCString & s )
    : Generics::GAddress( p ) { from7BitString(s); }
  ReturnPath( Content * p, const TQString & s, const TQCString & cs )
    : Generics::GAddress( p )  { fromUnicodeString( s, cs ); }
  ~ReturnPath()  {}
 
  const char * type() const { return "Return-Path"; }
 
protected:
  bool parse( const char* & scursor, const char * const send, bool isCRLF=false );
};
 
#if defined(KMIME_NEW_STYLE_CLASSTREE)
// classes whose names collide with earlier ones:
 
// GAddress et al.:
 
// rfc(2)822 headers:
mk_trivial_subclass(From,MailboxList);
mk_trivial_subclass(Sender,SingleMailbox);
mk_trivial_subclass_with_name(ReplyTo,Reply-To,AddressList);
mk_trivial_subclass(Cc,AddressList);
mk_trivial_subclass(Bcc,AddressList);
// usefor headers:
mk_trivial_subclass_with_name(MailCopiesTo,Mail-Copies-To,AddressList);
 
// GToken:
 
mk_trivial_subclass_with_name(ContentTransferEncoding,
                  Content-Transfer-Encoding,GToken);
 
// GPhraseList:
 
mk_trivial_subclass(Keywords,GPhraseList);
 
// GDotAtom:
 
mk_trivial_subclass_with_name(MIMEVersion,MIME-Version,GDotAtom);
 
// GIdent:
 
mk_trivial_subclass_with_name(MessageID,Message-ID,GSingleIdent);
mk_trivial_subclass_with_name(ContentID,Content-ID,GSingleIdent);
mk_trivial_subclass(Supersedes,GSingleIdent);
mk_trivial_subclass_with_name(InReplyTo,In-Reply-To,GIdent);
mk_trivial_subclass(References,GIdent);
 
// GContentType:
 
mk_trivial_subclass_with_name(ContentType,ContentType,GContentType);
 
// GCISTokenWithParameterList:
 
mk_trivial_subclass_with_name(ContentDisposition,Content-Disposition,
                  GCISTokenWithParameterList);
 
 
#endif
 
 
//
//
// COMPATIBLE GUNSTRUCTURED-BASED FIELDS:
//
//
 
 
class TDE_EXPORT Generic : public Generics::GUnstructured {
 
  public:
    Generic() : Generics::GUnstructured(), t_ype(0) {}
    Generic(const char *t)
      : Generics::GUnstructured(), t_ype(0) { setType(t); }
    Generic(const char *t, Content *p)
      : Generics::GUnstructured( p ), t_ype(0) { setType(t); }
    Generic(const char *t, Content *p, const TQCString &s)
      : Generics::GUnstructured( p, s ), t_ype(0) { setType(t); }
    Generic(const char *t, Content *p, const TQString &s, const TQCString &cs)
      : Generics::GUnstructured( p, s, cs ), t_ype(0) { setType(t); }
    ~Generic() { delete[] t_ype; }
 
    virtual void clear()            { delete[] t_ype; GUnstructured::clear(); }
    virtual bool isEmpty()          { return (t_ype==0 || GUnstructured::isEmpty()); }
    virtual const char* type()      { return t_ype; }
    void setType(const char *type);
 
  protected:
    char *t_ype;
 
};
 
 
class TDE_EXPORT Subject : public Generics::GUnstructured {
 
  public:
    Subject() : Generics::GUnstructured()  {}
    Subject( Content * p ) : Generics::GUnstructured( p )  {}
    Subject( Content * p, const TQCString & s )
      : Generics::GUnstructured( p, s ) {}
    Subject( Content * p, const TQString & s, const TQCString & cs )
      : Generics::GUnstructured( p, s, cs ) {}
    ~Subject()  {}
 
    virtual const char* type() { return "Subject"; }
 
    bool isReply() {
      return ( asUnicodeString().find( TQString("Re:"), 0, false ) == 0 );
    }
};
 
class TDE_EXPORT Organization : public Generics::GUnstructured {
 
  public:
    Organization() : Generics::GUnstructured() {}
    Organization( Content * p ) : Generics::GUnstructured( p ) {}
    Organization( Content * p, const TQCString & s )
      : Generics::GUnstructured( p, s ) {};
    Organization( Content * p, const TQString & s, const TQCString & cs)
      : Generics::GUnstructured( p, s, cs ) {}
    ~Organization()  {}
 
    virtual const char* type()      { return "Organization"; }
 
};
 
//
//
// NOT YET CONVERTED STUFF BELOW:
//
//
 
 
 
class TDE_EXPORT Control : public Base {
 
  public:
    Control() : Base()  {}
    Control(Content *p) : Base(p)  {}
    Control(Content *p, const TQCString &s) : Base(p) { from7BitString(s); }
    Control(Content *p, const TQString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
    ~Control()  {}
 
    virtual void from7BitString(const TQCString &s);
    virtual TQCString as7BitString(bool incType=true);
    virtual void fromUnicodeString(const TQString &s, const TQCString&);
    virtual TQString asUnicodeString();
    virtual void clear()            { c_trlMsg.truncate(0); }
    virtual bool isEmpty()          { return (c_trlMsg.isEmpty()); }
    virtual const char* type()      { return "Control"; }
 
    bool isCancel()                 { return (c_trlMsg.find("cancel", 0, false)!=-1); }
 
  protected:
    TQCString c_trlMsg;
 
};
 
class TDE_EXPORT Date : public Base {
 
  public:
    Date() : Base(), t_ime(0)  {}
    Date(Content *p) : Base(p), t_ime(0)  {}
    Date(Content *p, time_t t) : Base(p), t_ime(t)  {}
    Date(Content *p, const TQCString &s) : Base(p)  { from7BitString(s); }
    Date(Content *p, const TQString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
    ~Date()  {}
 
    virtual void from7BitString(const TQCString &s);
    virtual TQCString as7BitString(bool incType=true);
    virtual void fromUnicodeString(const TQString &s, const TQCString&);
    virtual TQString asUnicodeString();
    virtual void clear()            { t_ime=0; }
    virtual bool isEmpty()          { return (t_ime==0); }
    virtual const char* type()      { return "Date"; }
 
    time_t unixTime()               { return t_ime; }
    void setUnixTime(time_t t)      { t_ime=t; }
    void setUnixTime()              { t_ime=time(0); }
    TQDateTime qdt();
    int ageInDays();
    
  protected:
    time_t t_ime;
 
};
 
 
class TDE_EXPORT Newsgroups : public Base {
 
  public:
    Newsgroups() : Base()  {}
    Newsgroups(Content *p) : Base(p)  {}
    Newsgroups(Content *p, const TQCString &s) : Base(p)  { from7BitString(s); }
    Newsgroups(Content *p, const TQString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
    ~Newsgroups()  {}
 
    virtual void from7BitString(const TQCString &s);
    virtual TQCString as7BitString(bool incType=true);
    virtual void fromUnicodeString(const TQString &s, const TQCString&);
    virtual TQString asUnicodeString();
    virtual void clear()            { g_roups.resize(0); }
    virtual bool isEmpty()          { return g_roups.isEmpty(); }
    virtual const char* type()      { return "Newsgroups"; }
 
    TQCString firstGroup();
    bool isCrossposted()            { return ( g_roups.find(',')>-1 ); }
    TQStringList getGroups();
 
  protected:
    TQCString g_roups;
 
};
 
 
class TDE_EXPORT FollowUpTo : public Newsgroups {
 
  public:
    FollowUpTo() : Newsgroups()  {}
    FollowUpTo(Content *p) : Newsgroups(p)  {}
    FollowUpTo(Content *p, const TQCString &s) : Newsgroups(p,s)  {}
    FollowUpTo(Content *p, const TQString &s) : Newsgroups(p,s)  {}
    ~FollowUpTo()  {}
 
    virtual const char* type()        { return "Followup-To"; }
 
};
 
 
class TDE_EXPORT Lines : public Base {
 
  public:
    Lines() : Base(),l_ines(-1)  {}
    Lines(Content *p) : Base(p),l_ines(-1)  {}
    Lines(Content *p, unsigned int i) : Base(p),l_ines(i)  {}
    Lines(Content *p, const TQCString &s) : Base(p)  { from7BitString(s); }
    Lines(Content *p, const TQString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
    ~Lines()                 {}
 
    virtual void from7BitString(const TQCString &s);
    virtual TQCString as7BitString(bool incType=true);
    virtual void fromUnicodeString(const TQString &s, const TQCString&);
    virtual TQString asUnicodeString();
    virtual void clear()            { l_ines=-1; }
    virtual bool isEmpty()          { return (l_ines==-1); }
    virtual const char* type()      { return "Lines"; }
 
    int numberOfLines()             { return l_ines; }
    void setNumberOfLines(int i)    { l_ines=i; }
 
  protected:
    int l_ines;
 
};
 
 
 
class TDE_EXPORT UserAgent : public Base {
 
  public:
    UserAgent() : Base()  {}
    UserAgent(Content *p) : Base(p)  {}
    UserAgent(Content *p, const TQCString &s) : Base(p)  { from7BitString(s); }
    UserAgent(Content *p, const TQString &s) : Base(p)  { fromUnicodeString(s, Latin1); }
    ~UserAgent()  {}
 
    virtual void from7BitString(const TQCString &s);
    virtual TQCString as7BitString(bool incType=true);
    virtual void fromUnicodeString(const TQString &s, const TQCString&);
    virtual TQString asUnicodeString();
    virtual void clear()            { u_agent.resize(0); }
    virtual bool isEmpty()          { return (u_agent.isEmpty()); }
    virtual const char* type()      { return "User-Agent"; }
 
  protected:
    TQCString u_agent;
 
};
 
 
#if !defined(KMIME_NEW_STYLE_CLASSTREE)
#include "kmime_headers_obs.h"
#endif
}  //namespace Headers
 
#if 0
typedef Headers::Base* (*headerCreator)(void);
 
class HeaderFactory : public TQAsciiDict<headerCreator>
{
private:
  HeaderFactory();
  ~HeaderFactory() {}
  static TQAsciiDict
 
public:
  static Headers::Base* create( const char* aType )
  {
    if (!s_elf)
      s_elf = new HeaderFactory;
    headerCreator * hc = (*s_elf)[aType];
    if ( !hc )
      return 0;
    else
      return (*hc)();
  }
 
  static Headers::Base* create( const TQCString& aType )
  {
    return create( aType.data() );
  }
 
  static Headers::Base* upgrade( Headers::Generic* aType ) { (void)aType; return new Headers::Base; }
 
};
 
#endif
 
}  //namespace KMime
 
 
#endif // __KMIME_HEADERS_H__