writemime.h

#ifndef _WRITEMIME_H_
#define _WRITEMIME_H_
/* @(#$Id: writemime.h,v 1.27 2007-01-16 09:37:28 dockes Exp $  (C) 2002 Jean-Francois Dockes */

#include <list>
#include <string>

#ifndef NO_NAMESPACES
using std::list;
using std::string;
#endif // NO_NAMESPACES

namespace WriteMime 
{

// Header field parameter (ie: ';filename="toto"')
class HeaderFieldParam {
  char *m_name;
  char *m_value;
  int   m_size;
  void reset() {
        if (m_name) {free(m_name); m_name = 0;}
        if (m_value) {free(m_value); m_value = 0;}
        m_size = 0;
  }
  void buildFromFriend(const HeaderFieldParam& rh);

 public:
  HeaderFieldParam(const char *nm, const char *value)
        : m_name(strdup(nm)), m_value(strdup(value)), m_size(0) {}
  HeaderFieldParam(const HeaderFieldParam& rh) {buildFromFriend(rh);}
  ~HeaderFieldParam() {reset();}
  HeaderFieldParam& operator=(const HeaderFieldParam& l);
  // returns the size -without any terminating 0- Print() WILL overshoot
  // size by 1
  int size();
  // Format text into buffer, which should be size() + 1 bytes
  int print(char *d);
};

// Header field, like 'Content-Disposition: attachment; filename="toto"'
class HeaderField {
  char *m_name;
  char *m_value;
  int   m_size;
  list<HeaderFieldParam> m_params;

  void reset() {
        if (m_name) {free(m_name); m_name = 0;}
        if (m_value) {free(m_value); m_value = 0;}
        m_size = 0;
  }
  void buildFromFriend(const HeaderField &rh);
 public:
  HeaderField(const char *nm, const char *value) 
        : m_name(strdup(nm)), m_value(strdup(value)), m_size(0) {}
  HeaderField(const HeaderField &rh) {buildFromFriend(rh);}
  ~HeaderField() {reset();}
  HeaderField &operator=(const HeaderField &rh);
  int addparam(const char *pnm, const char *pval);
  // Return size, -without any terminating 0- print() WILL overshoot size by 1
  int size();
  // Format text into buffer, which should be size() + 1 bytes
  int print(char *d);
};



class Entity {
 public:
  enum type {TEXT,IMAGE,AUDIO,VIDEO,APPLICATION,MULTIPART,MESSAGE};
  enum disposition {DISP_ATTACHMENT, DISP_INLINE};
  enum encoding {ENC_7BIT, ENC_8BIT, ENC_BINARY, ENC_QP, ENC_BASE64};

 private:
  char                *m_subtype;
  char                *m_error;

 protected:
  type                 m_type;
  encoding             m_encoding;
  list<HeaderField>    m_hf;
  int                  m_size;
  char                *m_fmt;  // Formatted buffer

 public:
  Entity() : m_subtype(strdup("plain")), m_error(0), 
        m_type(TEXT),  m_encoding(ENC_BINARY), m_size(0), m_fmt(0) {}
  virtual ~Entity() {
        if (m_subtype) {free(m_subtype); m_subtype = 0;}
        if (m_error) {free(m_error); m_error = 0;}
        if (m_fmt) {free(m_fmt); m_fmt = 0;}
  }

  virtual void seterror(const char *s);
  virtual const char *geterror() {return m_error;}
  virtual encoding getencoding() {return m_encoding;}

  virtual void addHeaderField(const HeaderField &f);
  virtual int size() = 0;
  virtual const char *format() = 0;
  virtual int format(char *buf) = 0;

 protected:
  virtual int addCteHeader();
  virtual int allocFmt();
  virtual int formatHeaders(char *buf);
  virtual int formatHeaders();
  virtual void settype(type tp) {m_type = tp;}
  virtual int setsubtype(const char *stp);
  virtual const char *getsubtype() {return m_subtype;}
};

class DiscreteEntity : public virtual Entity {
  char          *m_body;
  int            m_blen;
  encoding       m_textencodepref;
  string    m_charset;

  int addCtpHeader();

 public:
  DiscreteEntity() : m_body(0), m_blen(0), m_charset("") {}
  virtual ~DiscreteEntity() {if (m_body) {free(m_body); m_body = 0;}}

  virtual void setTextEncodePref(encoding ec);
  
  virtual void setCharSet(const char *cs) {m_charset = cs;}

  virtual int setBody(const char *bp, int blen, type tp = TEXT, 
                  const char *stp = "plain");

  virtual int setBodyAttach(const char *filename, type tp = APPLICATION,
                                        const char *stp = "octet-stream");
  virtual int size();
  virtual const char *format();
  virtual int         format(char *buf);
};

class CompositeEntity : public virtual Entity {
  list<Entity *>   m_parts;
  int              m_size;
  string           m_boundary;
 public:
  CompositeEntity(type tp, const char *stp);
  virtual ~CompositeEntity();
  virtual int addPart(Entity *part);
  virtual int size();
  virtual const char *format();
  virtual int  format(char *buf);
};

extern char *readFile(const char *fname, int *outlen);

extern char *base64Encode(const char *from, int fromlen , int *tolen, 
                                                  int ll = 54);

extern char *base64EncodeFile(const char *fname, int *outlen);

extern char *qpEncode(const char *from, int fromlen, int *tolen);


// Recipient address storage
class Recipient {
  string official;
  string nickname;
 public:
  Recipient(const char *off, const char *nick) 
        : official(off), nickname(nick?nick:"") 
        {}
  friend class Message;
  friend class SimpleMessage;
  friend class CompositeMessage;
};

class Message : public virtual Entity {
 protected:
  list<Recipient> to;
  list<Recipient> cc;
  list<Recipient> bcc;
  static const char *recpth[3];
  list<Recipient> *recptlists[3];

  void setRecipientHeaders();

 public:
  enum recpt_type {TO = 0, CC = 1, BCC = 2};

  Message();
  virtual ~Message() {}

  virtual const char *format() = 0;

  virtual int addRecipient(const char *official, const char *nick = 0, 
                           recpt_type tp = TO);

  virtual int parseAddRecipients(const char *in, recpt_type tp = TO);

  virtual const char **getRecipients();

  virtual int setSubject(const char *subject);
  virtual int setFrom(const Recipient &from);
};

class SimpleMessage : public Message, public DiscreteEntity {
 public:
  SimpleMessage();
  virtual const char *format();
};

class CompositeMessage : public Message, public CompositeEntity {
 public:
  CompositeMessage(type tp, const char *stp);
  virtual const char *format();
};

#ifdef WITH_SENDMAIL
extern int sendmail(Message *msg);
#endif /* WITH_SENDMAIL */

} // End namespace WriteMime

#endif /* _WRITEMIME_H_ */

---