libEtPan! API
Prev | Chapter 3. Internet Message Format | Next

# Data types

## mailimf_mailbox - mailbox

#include <libetpan/libetpan.h> struct mailimf_mailbox { char * mb_display_name; /* can be NULL */ char * mb_addr_spec; /* != NULL */ }; struct mailimf_mailbox * mailimf_mailbox_new(char * mb_display_name, char * mb_addr_spec); void mailimf_mailbox_free(struct mailimf_mailbox * mailbox);

This is an email mailbox with a display name.

Example 3-1. example of mailbox

    DINH Viet Hoa <hoa@users.sourceforge.net>

mailimf_mailbox_new creates and initializes a data structure with a value. Strings given as argument are referenced by the created object and will be freed if the object is released.

mailimf_mailbox_free frees memory used by the structure and substructures will also be released.

Example 3-2. mailbox creation and display

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_mailbox * mb;
      char * display_name;
      char * address;

      display_name = strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?=");
      address = strdup("dinh.viet.hoa@free.fr");
      mb = mailimf_mailbox_new(str, address);
      /* do the things */
      mailimf_mailbox_free(mb);

      return 0;
    }

    /* display mailbox information */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_mailbox(struct mailimf_mailbox * mb)
    {
      if (mb->mb_display_name != NULL)
        printf("display name: %s\n", mb->mb_display_name);
      printf("address specifier : %s\n", mb->mb_addr_spec);
    }

## mailimf_address - address

    #include <libetpan/libetpan.h>

    struct mailimf_address {
      int ad_type;
      union {
        struct mailimf_mailbox * ad_mailbox; /* can be NULL */
        struct mailimf_group * ad_group;     /* can be NULL */
      } ad_data;
    };

    struct mailimf_address *
    mailimf_address_new(int ad_type, struct mailimf_mailbox * ad_mailbox,
    		    struct mailimf_group * ad_group);

    void mailimf_address_free(struct mailimf_address * address);

This is a mailbox or a group of mailbox.

- ad_type can be MAILIMF_ADDRESS_MAILBOX or MAILIMF_ADDRESS_GROUP.

- ad_data.ad_mailbox is a mailbox if ad_type is MAILIMF_ADDRESS_MAILBOX see the Section called mailimf_mailbox - mailbox)

- ad_data.group is a group if type is MAILIMF_ADDRESS_GROUP. see the Section called mailimf_group - named group of mailboxes)

mailimf_address_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_address_free frees memory used by the structure and substructures will also be released.

Example 3-3. address creation and display

    /* creates an address of type mailbox */

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_address * a_mb;
      struct mailimf_mailbox * mb;
      char * display_name;
      char * address;

      display_name = strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?=");
      address = strdup("dinh.viet.hoa@free.fr");
      mb = mailimf_mailbox_new(str, address);

      a_mb = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      /* do the things */
      mailimf_address_free(a_mb);
    }

    /* creates an address of type group */

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_address * a_g;
      struct mailimf_group * g;
      char * display_name;

      display_name = strdup("undisclosed-recipient");
      g = mailimf_group_new(display_name, NULL);

      a_g = mailimf_address_new(MAILIMF_ADDRESS_GROUP, NULL, g);
      /* do the things */
      mailimf_address_free(a_g);

      return 0;
    }

    /* display the content of an address */

    #include <libetpan/libetpan.h>

    void display_address(struct mailimf_address * a)
    {
      clistiter * cur;

      switch (a->ad_type) {
        case MAILIMF_ADDRESS_GROUP:
          display_mailimf_group(a->ad_data.ad_group);
          break;

        case MAILIMF_ADDRESS_MAILBOX:
          display_mailimf_mailbox(a->ad_data.ad_mailbox);
          break;
      }
    }

## mailimf_mailbox_list - list of mailboxes

    #include <libetpan/libetpan.h>

    struct mailimf_mailbox_list {
      clist * mb_list; /* list of (struct mailimf_mailbox *), != NULL */
    };

    struct mailimf_mailbox_list *
    mailimf_mailbox_list_new(clist * mb_list);

    void mailimf_mailbox_list_free(struct mailimf_mailbox_list * mb_list);

This is a list of mailboxes.

mb_list is a list of mailboxes. This is a clist which elements are of type mailimf_mailbox (see the Section called mailimf_mailbox - mailbox).

mailimf_mailbox_list_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_mailbox_list_free() frees memory used by the structure and substructures will also be released.

Example 3-4. Creation and display of mailimf_mailbox_list

    /* creates a list of mailboxes with two mailboxes */

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_group * g;
      char * display_name;
      struct mailimf_mailbox_list * mb_list;
      clist * list;

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      list = clist_append(mb);
      mb = mailimf_mailbox_new(strdup("Christophe GIAUME"),
        strdup("christophe@giaume.com"));
      list = clist_append(mb);

      mb_list = mailimf_mailbox_list_new(list);
      /* do the things */
      mailimf_mailbox_list_free(mb_list);

      return 0;
    }

    /* display a list of mailboxes */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_mailbox_list(struct mailimf_mailbox_list * mb_list)
    {
      clistiter * cur;

      for(cur = clist_begin(mb_list->mb_list) ; cur != NULL ;
        cur = clist_next(cur)) {
        struct mailimf_mailbox * mb;

        mb = clist_content(cur);

        display_mailbox(mb);
        printf("\n");
      }
    }

## mailimf_address_list - list of addresses

    #include <libetpan/libetpan.h>

    struct mailimf_address_list {
      clist * ad_list; /* list of (struct mailimf_address *), != NULL */
    };

    struct mailimf_address_list *
    mailimf_address_list_new(clist * ad_list);

    void mailimf_address_list_free(struct mailimf_address_list * addr_list);

This is a list of addresses.

ad_list is a list of addresses. This is a clist which elements are of type mailimf_address (see the Section called mailimf_address - address).

mailimf_address_list_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_address_list_free() frees memory used by the structure and substructures will also be released.

Example 3-5. creation and display of list of addresses

    /* creates a list of addresses with two addresses */

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_address_list * addr_list;
      clist * list;
      struct mailimf_mailbox * mb;
      struct mailimf_address * addr;

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      list = clist_append(addr);

      mb = mailimf_mailbox_new(strdup("Christophe GIAUME"),
        strdup("christophe@giaume.com"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      list = clist_append(addr);

      addr_list = mailimf_address_list_new(list);
      /* do the things */
      mailimf_address_list_free(mb_list);

      return 0;
    }

    /* display a list of addresses */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_address_list(struct mailimf_address_list * addr_list)
    {
      clistiter * cur;

      for(cur = clist_begin(addr_list->ad_list) ; cur != NULL ;
        cur = clist_next(cur)) {
        struct mailimf_address * addr;

        addr = clist_content(cur);

        display_address(addr);
        printf("\n");
      }
    }

## mailimf_group - named group of mailboxes

    #include <libetpan/libetpan.h>

    struct mailimf_group {
      char * grp_display_name; /* != NULL */
      struct mailimf_mailbox_list * grp_mb_list; /* can be NULL */
    };

    struct mailimf_group *
    mailimf_group_new(char * grp_display_name,
        struct mailimf_mailbox_list * grp_mb_list);

    void mailimf_group_free(struct mailimf_group * group);

This is a list of mailboxes tagged with a name.

Example 3-6. example of group

                they play music: <steve@morse.foo>, <neal@morse.foo>,
                <yngwie@malmsteen.bar>, <michael@romeo.bar>;

grp_display_name is the name that will be displayed for this group, for example 'group_name' in 'group_name: address1@domain1, address2@domain2;'. This must be allocated with malloc(). grp_mb_list is a list of mailboxes (see the Section called mailimf_mailbox_list - list of mailboxes).

mailimf_group_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_group_free() frees memory used by the structure and substructures will also be released.

Example 3-7. creation and display of a group

    /* creates an empty group */

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_group * g;
      char * display_name;

      display_name = strdup("undisclosed-recipient");
      g = mailimf_group_new(display_name, NULL);
      /* do the things */
      mailimf_group_free(g);
    }

    /* creates a group with two mailboxes */

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_group * g;
      char * display_name;
      struct mailimf_mailbox_list * mb_list;
      struct mailimf_mailbox * mb;
      clist * list;

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      list = clist_append(mb);
      mb = mailimf_mailbox_new(strdup("Christophe GIAUME"),
        strdup("christophe@giaume.com"));
      list = clist_append(mb);

      mb_list = mailimf_mailbox_list_new(list);

      display_name = strdup("my_group");
      g = mailimf_group_new(display_name, mb_list);
      /* do the things */
      mailimf_group_free(g);

      return 0;
    }

    /* display content of group */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_group(struct mailimf_group * group)
    {
      printf("name of the group: %s\n", a->group->display_name);
      for(cur = clist_begin(a->group->mb_list->list) ; cur != NULL ;
        cur = clist_next(cur)) {
        struct mailimf_mailbox * mb;

        mb = clist_content(cur);
        display_mailbox(mb);
        printf("\n");
      }
    }

## mailimf_date_time - date of a message

#include <libetpan/libetpan.h> struct mailimf_date_time { int dt_day; int dt_month; int dt_year; int dt_hour; int dt_min; int dt_sec; int dt_zone; }; struct mailimf_date_time * mailimf_date_time_new(int dt_day, int dt_month, int dt_year, int dt_hour, int dt_min, int dt_sec, int dt_zone); void mailimf_date_time_free(struct mailimf_date_time * date_time);

This is the date and time of a message. For example :

Example 3-8. example of date

    Thu, 11 Dec 2003 00:15:02 +0100.

- dt_day is the day of month (1 to 31)

- dt_month (1 to 12)

- dt_year (4 digits)

- dt_hour (0 to 23)

- dt_min (0 to 59)

- dt_sec (0 to 59)

- dt_zone (this is the decimal value that we can read, for example: for '-0200', the value is -200).

mailimf_date_time_new() creates and initializes a date structure with a value.

mailimf_date_time_free() frees memory used by the structure.

Example 3-9. creation and display of date

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_date_time * d;

      d = mailimf_date_time_new(9, 5, 2003, 3, 01, 40, -0200);
      /* do the things */
      mailimf_date_time_free(d);

      return 0;
    }

    /* display the date */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_date(struct mailimf_date_time * d)
    {
      printf("%02i/%02i/%i %02i:%02i:%02i %+04i\n",
        d->dt_day, d->dt_month, d->dt_year,
        d->dt_hour, d->dt_min, d->dt_sec, d->dt_zone);
    }

## mailimf_orig_date - parsed content of date header

    #include <libetpan/libetpan.h>

    struct mailimf_orig_date {
      struct mailimf_date_time * dt_date_time; /* != NULL */
    };

    struct mailimf_orig_date * mailimf_orig_date_new(struct mailimf_date_time *
        dt_date_time);

    void mailimf_orig_date_free(struct mailimf_orig_date * orig_date);

This is the content of a header Date or Resent-Date. It encapsulates a mailimf_date_time

dt_date_time is the parsed date (see the Section called mailimf_date_time - date of a message).

mailimf_orig_date_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_orig_date_free() frees memory used by the structure and substructures will also be released.

Example 3-10. creation and display of Date field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_date_time * d;
      struct mailimf_orig_date * date;

      d = mailimf_date_time_new(9, 5, 2003, 3, 01, 40, -0200);
      date = mailimf_orig_date_new(d);
      /* do the things */
      mailimf_orig_date_free(date);

      return 0;
    }

    /* display date header */

    #include <libetpan/libetpan.h>

    void display_orig_date(struct mailimf_orig_date * orig_date)
    {
      display_date_time(d->dt_date_time);
    }

## mailimf_from - parsed content of From header

    #include <libetpan/libetpan.h>

    struct mailimf_from {
      struct mailimf_mailbox_list * frm_mb_list; /* != NULL */
    };

    struct mailimf_from *
    mailimf_from_new(struct mailimf_mailbox_list * frm_mb_list);

    void mailimf_from_free(struct mailimf_from * from);

This is the content of a header From or Resent-From.

frm_mb_list is the parsed mailbox list (see the Section called mailimf_mailbox_list - list of mailboxes).

mailimf_from_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_from_free() frees memory used by the structure and substructures will also be released.

Example 3-11. creation and display of a From header

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      clist * list;
      struct mailimf_mailbox * mb;
      struct mailimf_mailbox_list * mb_list;
      struct mailimf_from * from;

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      clist_append(list, mb);
      mb_list = mailimf_mailbox_list_new(list);

      from = mailimf_from_new(mb_list);
      /* do the things */
      mailimf_from_free(from);

      return 0;
    }

    /* display content of from header */

    #include <libetpan/libetpan.h>

    void display_from(struct mailimf_from * from)
    {
      display_mailbox_list(from->frm_mb_list);
    }

## mailimf_sender - parsed content of Sender header

    #include <libetpan/libetpan.h>

    struct mailimf_sender {
      struct mailimf_mailbox * snd_mb; /* != NULL */
    };

    struct mailimf_sender * mailimf_sender_new(struct mailimf_mailbox * snd_mb);

    void mailimf_sender_free(struct mailimf_sender * sender);

This is the content of a header Sender or Resent-Sender.

snd_mb is the parsed mailbox (see the Section called mailimf_mailbox - mailbox).

mailimf_sender_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_sender_free() This function frees memory used by the structure and substructures will also be released.

Example 3-12. creation and display of Sender field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_mailbox * mb;
      struct mailimf_sender * sender;

      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));

      sender = mailimf_sender_new(mb);
      /* do the things */
      mailimf_sender_free(sender);

      return 0;
    }

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_sender(struct mailimf_sender * sender)
    {
      display_mailbox(sender->snd_mb);
    }

## mailimf_reply_to - parsed content of Reply-To header

    #include <libetpan/libetpan.h>

    struct mailimf_reply_to {
      struct mailimf_address_list * rt_addr_list; /* != NULL */
    };

    struct mailimf_reply_to *
    mailimf_reply_to_new(struct mailimf_address_list * rt_addr_list);

    void mailimf_reply_to_free(struct mailimf_reply_to * reply_to);

This is the content of a header Reply-To.

addr_list is the parsed address list (see the Section called mailimf_address_list - list of addresses).

mailimf_reply_to_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_reply_to_free() frees memory used by the structure and substructures will also be released.

Example 3-13. creation and display of Reply-To field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      clist * list;
      struct mailimf_mailbox * mb;
      struct mailimf_address * addr;
      struct mailimf_address_list * addr_list;
      struct mailimf_reply_to * reply_to;

      list = clist_new();

      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);

      mb = mailimf_mailbox_new(strdup("Christophe GIAUME"),
        strdup("christophe@giaume.com"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);

      addr_list = mailimf_address_list_new(list);

      reply_to = mailimf_reply_to_new(addr_list);
      /* do the things */
      mailimf_reply_to_free(reply_to);

      return 0;
    }

    /* display Reply-To header */

    #include <libetpan/libetpan.h>

    void display_reply_to(struct mailimf_reply_to * reply_to)
    {
      display_address_list(reply_to->addr_list);
    }

## mailimf_to - parsed content of To header

            struct mailimf_to {
      struct mailimf_address_list * to_addr_list; /* != NULL */
    };

    struct mailimf_to * mailimf_to_new(struct mailimf_address_list * to_addr_list);

    void mailimf_to_free(struct mailimf_to * to);

This is the content of a header To or Resent-To.

to_addr_list is the parsed address list (see the Section called mailimf_address_list - list of addresses).

mailimf_to_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_to_free() frees memory used by the structure and substructures will also be released.

Example 3-14. creation and display of To field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      clist * list;
      struct mailimf_mailbox * mb;
      struct mailimf_address * addr;
      struct mailimf_address_list * addr_list;
      struct mailimf_to * to;

      list = clist_new();

      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);

      mb = mailimf_mailbox_new(strdup("Christophe GIAUME"),
        strdup("christophe@giaume.com"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);

      addr_list = mailimf_address_list_new(list);

      to = mailimf_to_new(addr_list);
      /* do the things */
      mailimf_to_free(to);

      return 0;
    }

    /* display To header */

    #include <libetpan/libetpan.h>

    void display_to(struct mailimf_to * to)
    {
      display_address_list(to->to_addr_list);
    }

## mailimf_cc - parsed content of Cc

    #include <libetpan/libetpan.h>

    struct mailimf_cc {
      struct mailimf_address_list * cc_addr_list; /* != NULL */
    };

    struct mailimf_cc *
    mailimf_cc_new(struct mailimf_address_list * cc_addr_list);

    void mailimf_cc_free(struct mailimf_cc * cc);

This is the content of a header Cc or Resent-Cc.

cc_addr_list is the parsed address list (see the Section called mailimf_address_list - list of addresses).

mailimf_cc_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_cc_free() This function frees memory used by the structure and substructures will also be released.

Example 3-15. creation and display of Cc field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      clist * list;
      struct mailimf_mailbox * mb;
      struct mailimf_address * addr;
      struct mailimf_address_list * addr_list;
      struct mailimf_cc * cc;

      list = clist_new();

      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);

      mb = mailimf_mailbox_new(strdup("Christophe GIAUME"),
        strdup("christophe@giaume.com"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);

      addr_list = mailimf_address_list_new(list);

      cc = mailimf_cc_new(addr_list);
      /* do the things */
      mailimf_cc_free(cc);

      return 0;
    }

    /* display content of Cc field */

    #include <libetpan/libetpan.h>

    void display_cc(struct mailimf_cc * cc)
    {
      display_address_list(cc->cc_addr_list);
    }

## mailimf_bcc - parsed content of Bcc field

    #include <libetpan/libetpan.h>

    struct mailimf_bcc {
      struct mailimf_address_list * bcc_addr_list; /* can be NULL */
    };

    struct mailimf_bcc *
    mailimf_bcc_new(struct mailimf_address_list * bcc_addr_list);

    void mailimf_bcc_free(struct mailimf_bcc * bcc);

This is the content of a header Bcc or Resent-Bcc.

bcc_addr_list is the parsed address list (see the Section called mailimf_address_list - list of addresses).

mailimf_bcc_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_bcc_free() frees memory used by the structure and substructures will also be released.

Example 3-16. creation and display of Bcc field

    /* create visible Bcc */

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      clist * list;
      struct mailimf_mailbox * mb;
      struct mailimf_address * addr;
      struct mailimf_address_list * addr_list;
      struct mailimf_bcc * bcc;

      list = clist_new();

      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);

      mb = mailimf_mailbox_new(strdup("Christophe GIAUME"),
        strdup("christophe@giaume.com"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);

      addr_list = mailimf_address_list_new(list);

      bcc = mailimf_bcc_new(addr_list);
      /* do the things */
      mailimf_bcc_free(bcc);

      return 0;
    }

    /* create unvisible Bcc */

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_bcc * bcc;

      bcc = mailimf_bcc_new(NULL);
      /* do the things */
      mailimf_bcc_free(bcc);

      return 0;
    }

    /* display content of Bcc field */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_bcc(struct mailimf_bcc * bcc)
    {
      if (bcc->addr_list == NULL) {
        printf("hidden Bcc\n");
      }
      else {
        display_address_list(bcc->bcc_addr_list);
      }
    }

## mailimf_message_id - parsed content of Message-ID header

    #include <libetpan/libetpan.h>

    struct mailimf_message_id {
      char * mid_value; /* != NULL */
    };

    struct mailimf_message_id * mailimf_message_id_new(char * mid_value);

    void mailimf_message_id_free(struct mailimf_message_id * message_id);

This is the content of a header Message-ID or Resent-Message-ID. For example :

Example 3-17. example of Message-ID

    Message-ID: <200312100009.43592@c01n-c01n.plop.P4N>>

mid_value is the message identifier. It is not enclosed by angle bracket.

mailimf_message_id_new() This function creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

The given string is allocated with malloc() and is not enclosed by angle bracket.

mailimf_message_id_free() frees memory used by the structure and substructures will also be released.

Example 3-18. creation and display of Message-ID field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_message_id * msg_id;
      char * id;

      id = strdup("1037197913.3dd26259752fa@imp.free.fr");
      msg_id = mailimf_message_id_new(id);
      /* do the things */
      mailimf_message_id_free(msg_id);

      return 0;
    }

    /* display message id */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_message_id(struct mailimf_message_id * msg_id)
    {
      printf("%s\n", msg_id->mid_value);
    }

## mailimf_in_reply_to - parsed content of In-Reply-To field

    #include <libetpan/libetpan.h>

    struct mailimf_in_reply_to {
      clist * mid_list; /* list of (char *), != NULL */
    };

    struct mailimf_in_reply_to * mailimf_in_reply_to_new(clist * mid_list);

    void mailimf_in_reply_to_free(struct mailimf_in_reply_to * in_reply_to);

content of a header In-Reply-To. For example :

    In-Reply-To: <etPan.3fd5fa29.4c3901c1.6b39@homer>

mid_list is a clist in which elements are message identifiers. their types are (char *) and they are allocated with malloc().

mailimf_in_reply_to_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_in_reply_to_free() frees memory used by the structure and substructures will also be released.

Example 3-19. creation and display of In-Reply-To field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_in_reply_to * in_reply_to;
      clist * msg_id_list;

      msg_id_list = clist_new();
      clist_append(msg_id_list,
        strdup("etPan.3ebbcc18.4014197f.bc1@homer.invalid"));

      in_reply_to = mailimf_in_reply_to_new(msg_id_list);
      /* do the things */
      mailimf_in_reply_to_free(in_reply_to);

      return 0;
    }

    /* display the content of mailimf_in_reply_to */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_in_reply_to(struct mailimf_in_reply_to * in_reply_to)
    {
      clistiter * cur;

      for(cur = clist_begin(in_reply_to->mid_list) ; cur != NULL ;
        cur = clist_next(cur)) {
        char * str;

        str = clist_content(cur);

        printf("%s\n", str);
      }
    }

## mailimf_references - parsed content of References field

    #include <libetpan/libetpan.h>

    struct mailimf_references {
      clist * mid_list; /* list of (char *) */
           /* != NULL */
    };

    struct mailimf_references * mailimf_references_new(clist * mid_list);

    void mailimf_references_free(struct mailimf_references * references);

This is the content of a header References. For example :

    In-Reply-To: <etPan.3fd5fa29.4c3901c1.6b39@homer>
      <3FD5FA78.A1D98E7@oleane.net>
      <etPan.3fd5fc69.2b349482.730e@homer>

mid_list is a clist in which elements are message identifiers. their types are (char *) and they are allocated with malloc().

mailimf_references_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_references_free() frees memory used by the structure and substructures will also be released.

Example 3-20. creation and display of References field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_references * ref;
      clist * msg_id_list;

      msg_id_list = clist_new();
      clist_append(msg_id_list,
        strdup("200304280144.23633.wim.delvaux@adaptiveplanet.com"));
      clist_append(msg_id_list,
        strdup("200304301153.19688.wim.delvaux@adaptiveplanet.com"));
      clist_append(msg_id_list,
        strdup("etPan.3eb29de4.5fc4d652.3f83@homer"));

      ref = mailimf_references_new(msg_id_list);
      /* do the things */
      mailimf_in_reply_to_free(ref);

      return 0;
    }

    /* display references */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_references(struct mailimf_references * ref)
    {
      clistiter * cur;

      for(cur = clist_begin(ref->mid_list) ; cur != NULL ;
        cur = clist_next(cur)) {
        char * msg_id;

        msg_id = clist_content(cur);

        printf("%s\n", msg_id);
      }
    }

## mailimf_subject - parsed content of Subject field

    #include <libetpan/libetpan.h>

    struct mailimf_subject {
      char * sbj_value; /* != NULL */
    };

    struct mailimf_subject * mailimf_subject_new(char * sbj_value);

    void mailimf_subject_free(struct mailimf_subject * subject);

This is the content of a header Subject.

sbj_value is the value of the field.

mailimf_subject_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_subject_free frees memory used by the structure and substructures will also be released.

Example 3-21. creation and display of Subject field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_subject * subject;

      subject = mailimf_subject_new(strdup("example of subject"));
      /* do the things */
      mailimf_subject_free(subject);

      return 0;
    }

    /* display subject header */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_subject(struct mailimf_subject * subject)
    {
      printf("%s\n", subject->value);
    }

## mailimf_comments - parsed content of Comments field

    #include <libetpan/libetpan.h>

    struct mailimf_comments {
      char * cm_value; /* != NULL */
    };

    struct mailimf_comments * mailimf_comments_new(char * cm_value);

    void mailimf_comments_free(struct mailimf_comments * comments);

This is the content of a header Comments.

cm_value is the value of the field.

mailimf_comments_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_comments_free() frees memory used by the structure and substructures will also be released.

Example 3-22. creation and display of Comment field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_comments * comments;

      comments = mailimf_comments_new(strdup("example of comment"));
      /* do the things */
      mailimf_comments_free(comments);

      return 0;
    }

    /* display the content of a comments */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_comments(struct mailimf_comments * comments)
    {
      printf("%s\n", comments->cm_value);
    }

## mailimf_keywords - parsed content of Keywords field

    #include <libetpan/libetpan.h>

    struct mailimf_keywords {
      clist * kw_list; /* list of (char *), != NULL */
    };

    struct mailimf_keywords * mailimf_keywords_new(clist * kw_list);

    void mailimf_keywords_free(struct mailimf_keywords * keywords);

This is the content of a header Keywords.

kw_list is the list of keywords. This is a list of (char *) allocated with malloc().

mailimf_keywords_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_keywords_free() frees memory used by the structure and substructures will also be released.

Example 3-23. creation and display of Keywords field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_keywords * keywords;
      clist * list;

      list = clist_new();
      clist_append(list, strdup("sauerkraut"));
      clist_append(list, strdup("potatoes"));
      clist_append(list, strdup("cooking"));

      keywords = mailimf_keywords_new(list);
      /* do the things */
      mailimf_keywords_free(keywords);

      return 0;
    }

    /* display the content of mailimf_in_reply_to */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_keywords(struct mailimf_keywords * kw)
    {
      clistiter * cur;

      for(cur = clist_begin(kw->kw_list) ; cur != NULL ;
        cur = clist_next(cur)) {
        char * str;

        str = clist_content(cur);

        printf("%s\n", str);
      }
    }

## mailimf_return - parsed content of Return-Path field

    #include <libetpan/libetpan.h>

    struct mailimf_return {
      struct mailimf_path * ret_path; /* != NULL */
    };

    struct mailimf_return *
    mailimf_return_new(struct mailimf_path * ret_path);

    void mailimf_return_free(struct mailimf_return * return_path);

This is the content of a header Return-Path.

ret_path is the parsed value of Return-Path (see the Section called mailimf_path - address in Return-Path field).

mailimf_return_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_return_free() frees memory used by the structure and substructures will also be released.

Example 3-24. creation and display of Return-Path field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_path * path;
      struct mailimf_return * r;

      path = mailimf_path_new(strdup("dinh.viet.hoa@free.fr"));
      r = mailimf_return_new(path);
      /* do the things */
      mailimf_return_free(r);

      return 0;
    }

    /* display return path */

    #include <libetpan/libetpan.h>

    void display_return(struct mailimf_return * r)
    {
      display_path(r->ret_path);
    }

## mailimf_path - address in Return-Path field

    #include <libetpan/libetpan.h>

    struct mailimf_path {
      char * pt_addr_spec; /* can be NULL */
    };

    struct mailimf_path * mailimf_path_new(char * pt_addr_spec);

    void mailimf_path_free(struct mailimf_path * path);

This is the encapsulation of address specifier for Return-Path content.

pt_addr_spec is a mailbox destination.

mailimf_path_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

The given string is allocated with malloc(). This is a address specifier.

mailimf_path_free() frees memory used by the structure and substructures will also be released.

Example 3-25. Creation and display of return path

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_path * path;

      path = mailimf_path_new(strdup("dinh.viet.hoa@free.fr"));
      /* do the things */
      mailimf_path_free(r);

      return 0;
    }

    /* display return path */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_path(struct mailimf_path * path)
    {
      printf("%s\n", path->pt_addr_spec);
    }

## mailimf_optional_field - non-standard header

    #include <libetpan/libetpan.h>

    struct mailimf_optional_field {
      char * fld_name;  /* != NULL */
      char * fld_value; /* != NULL */
    };

    struct mailimf_optional_field *
    mailimf_optional_field_new(char * fld_name, char * fld_value);

    void mailimf_optional_field_free(struct mailimf_optional_field * opt_field);

This is a non-standard header or unparsed header.

- fld_name is the name of the header field.

- fld_value is the value of the header field.

mailimf_optional_field_new() This function creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

field name and field value have to be allocated with malloc().

mailimf_optional_field_free() This function frees memory used by the structure and substructures will also be released.

Example 3-26. creation and display of non-standard fields

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_optional_field * opt;

      opt = mailimf_optional_field_new(strdup("X-My-Field"), strdup("my value"));
      /* do the things */
      mailimf_optional_field_free(opt);

      return 0;
    }

    /* display the optional field */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_optional_field(struct mailimf_optional_field * opt)
    {
      printf("%s: %s\n", opt->fld_name, opt->fld_value);
    }

## mailimf_field - header field

    #include <libetpan/libetpan.h>

    enum {
      MAILIMF_FIELD_NONE,           /* on parse error */
      MAILIMF_FIELD_RETURN_PATH,    /* Return-Path */
      MAILIMF_FIELD_RESENT_DATE,    /* Resent-Date */
      MAILIMF_FIELD_RESENT_FROM,    /* Resent-From */
      MAILIMF_FIELD_RESENT_SENDER,  /* Resent-Sender */
      MAILIMF_FIELD_RESENT_TO,      /* Resent-To */
      MAILIMF_FIELD_RESENT_CC,      /* Resent-Cc */
      MAILIMF_FIELD_RESENT_BCC,     /* Resent-Bcc */
      MAILIMF_FIELD_RESENT_MSG_ID,  /* Resent-Message-ID */
      MAILIMF_FIELD_ORIG_DATE,      /* Date */
      MAILIMF_FIELD_FROM,           /* From */
      MAILIMF_FIELD_SENDER,         /* Sender */
      MAILIMF_FIELD_REPLY_TO,       /* Reply-To */
      MAILIMF_FIELD_TO,             /* To */
      MAILIMF_FIELD_CC,             /* Cc */
      MAILIMF_FIELD_BCC,            /* Bcc */
      MAILIMF_FIELD_MESSAGE_ID,     /* Message-ID */
      MAILIMF_FIELD_IN_REPLY_TO,    /* In-Reply-To */
      MAILIMF_FIELD_REFERENCES,     /* References */
      MAILIMF_FIELD_SUBJECT,        /* Subject */
      MAILIMF_FIELD_COMMENTS,       /* Comments */
      MAILIMF_FIELD_KEYWORDS,       /* Keywords */
      MAILIMF_FIELD_OPTIONAL_FIELD, /* other field */
    };

    struct mailimf_field {
      int fld_type;
      union {
        struct mailimf_return * fld_return_path;              /* can be NULL */
        struct mailimf_orig_date * fld_resent_date;    /* can be NULL */
        struct mailimf_from * fld_resent_from;         /* can be NULL */
        struct mailimf_sender * fld_resent_sender;     /* can be NULL */
        struct mailimf_to * fld_resent_to;             /* can be NULL */
        struct mailimf_cc * fld_resent_cc;             /* can be NULL */
        struct mailimf_bcc * fld_resent_bcc;           /* can be NULL */
        struct mailimf_message_id * fld_resent_msg_id; /* can be NULL */
        struct mailimf_orig_date * fld_orig_date;             /* can be NULL */
        struct mailimf_from * fld_from;                       /* can be NULL */
        struct mailimf_sender * fld_sender;                   /* can be NULL */
        struct mailimf_reply_to * fld_reply_to;               /* can be NULL */
        struct mailimf_to * fld_to;                           /* can be NULL */
        struct mailimf_cc * fld_cc;                           /* can be NULL */
        struct mailimf_bcc * fld_bcc;                         /* can be NULL */
        struct mailimf_message_id * fld_message_id;           /* can be NULL */
        struct mailimf_in_reply_to * fld_in_reply_to;         /* can be NULL */
        struct mailimf_references * fld_references;           /* can be NULL */
        struct mailimf_subject * fld_subject;                 /* can be NULL */
        struct mailimf_comments * fld_comments;               /* can be NULL */
        struct mailimf_keywords * fld_keywords;               /* can be NULL */
        struct mailimf_optional_field * fld_optional_field;   /* can be NULL */
      } fld_data;
    };

    struct mailimf_field *
    mailimf_field_new(int fld_type,
        struct mailimf_return * fld_return_path,
        struct mailimf_orig_date * fld_resent_date,
        struct mailimf_from * fld_resent_from,
        struct mailimf_sender * fld_resent_sender,
        struct mailimf_to * fld_resent_to,
        struct mailimf_cc * fld_resent_cc,
        struct mailimf_bcc * fld_resent_bcc,
        struct mailimf_message_id * fld_resent_msg_id,
        struct mailimf_orig_date * fld_orig_date,
        struct mailimf_from * fld_from,
        struct mailimf_sender * fld_sender,
        struct mailimf_reply_to * fld_reply_to,
        struct mailimf_to * fld_to,
        struct mailimf_cc * fld_cc,
        struct mailimf_bcc * fld_bcc,
        struct mailimf_message_id * fld_message_id,
        struct mailimf_in_reply_to * fld_in_reply_to,
        struct mailimf_references * fld_references,
        struct mailimf_subject * fld_subject,
        struct mailimf_comments * fld_comments,
        struct mailimf_keywords * fld_keywords,
        struct mailimf_optional_field * fld_optional_field);

    void mailimf_field_free(struct mailimf_field * field);

This is one header field of a message.

- type is the type of the field. This define the type of the field. Only the corresponding field should be, then, filled. The value of this field can be one of : MAILIMF_FIELD_RETURN_PATH, MAILIMF_FIELD_RESENT_DATE, MAILIMF_FIELD_RESENT_FROM, MAILIMF_FIELD_RESENT_SENDER, MAILIMF_FIELD_RESENT_TO, MAILIMF_FIELD_RESENT_CC, MAILIMF_FIELD_RESENT_BCC, MAILIMF_FIELD_RESENT_MSG_ID, MAILIMF_FIELD_ORIG_DATE, MAILIMF_FIELD_FROM, MAILIMF_FIELD_SENDER, MAILIMF_FIELD_REPLY_TO, MAILIMF_FIELD_TO, MAILIMF_FIELD_CC, MAILIMF_FIELD_BCC, MAILIMF_FIELD_MESSAGE_ID, MAILIMF_FIELD_IN_REPLY_TO, MAILIMF_FIELD_REFERENCES, MAILIMF_FIELD_SUBJECT, MAILIMF_FIELD_COMMENTS, MAILIMF_FIELD_KEYWORDS, MAILIMF_FIELD_OPTIONAL_FIELD.

- fld_data.fld_return_path is the parsed content of the Return-Path field if type is MAILIMF_FIELD_RETURN_PATH (see the Section called mailimf_return - parsed content of Return-Path field).

- fld_data.fld_resent_date is the parsed content of the Resent-Date field if type is MAILIMF_FIELD_RESENT_DATE (see the Section called mailimf_orig_date - parsed content of date header).

- fld_data.fld_resent_from is the parsed content of the Resent-From field if type is MAILIMF_FIELD_RESENT_FROM (see the Section called mailimf_from - parsed content of From header).

- fld_data.fld_resent_sender is the parsed content of the Resent-Sender field if type is MAILIMF_FIELD_RESENT_SENDER (see the Section called mailimf_sender - parsed content of Sender header).

- fld_data.fld_resent_to is the parsed content of the Resent-To field if type is MAILIMF_FIELD_RESENT_TO (see the Section called mailimf_to - parsed content of To header).

- fld_data.fld_resent_cc is the parsed content of the Resent-Cc field if type is MAILIMF_FIELD_CC (see the Section called mailimf_cc - parsed content of Cc).

- fld_data.fld_resent_bcc is the parsed content of the Resent-Bcc field if type is MAILIMF_FIELD_BCC (see the Section called mailimf_bcc - parsed content of Bcc field).

- fld_data.fld_resent_msg_id is the parsed content of the Resent-Message-ID field if type is MAILIMF_FIELD_RESENT_MSG_ID (see the Section called mailimf_message_id - parsed content of Message-ID header).

- fld_data.fld_orig_date is the parsed content of the Date field if type is MAILIMF_FIELD_ORIG_DATE (see the Section called mailimf_orig_date - parsed content of date header).

- fld_data.fld_from is the parsed content of the From field if type is MAILIMF_FIELD_FROM (see the Section called mailimf_from - parsed content of From header).

- fld_data.fld_sender is the parsed content of the Sender field if type is MAILIMF_FIELD_SENDER (see the Section called mailimf_sender - parsed content of Sender header).

- fld_data.fld_reply_to is the parsed content of the Reply-To field if type is MAILIMF_FIELD_REPLY_TO (see the Section called mailimf_reply_to - parsed content of Reply-To header).

- fld_data.fld_to is the parsed content of the To field if type is MAILIMF_FIELD_TO (see the Section called mailimf_to - parsed content of To header).

- fld_data.fld_cc is the parsed content of the Cc field if type is MAILIMF_FIELD_CC (see the Section called mailimf_cc - parsed content of Cc).

- fld_data.fld_bcc is the parsed content of the Bcc field if type is MAILIMF_FIELD_BCC (see the Section called mailimf_bcc - parsed content of Bcc field).

- fld_data.fld_message_id is the parsed content of the Message-ID field if type is MAILIMF_FIELD_MESSAGE_ID (see the Section called mailimf_message_id - parsed content of Message-ID header).

- fld_data.fld_in_reply_to is the parsed content of the In-Reply-To field if type is MAILIMF_FIELD_IN_REPLY_TO (see the Section called mailimf_in_reply_to - parsed content of In-Reply-To field).

- fld_data.fld_references is the parsed content of the References field if type is MAILIMF_FIELD_REFERENCES (see the Section called mailimf_references - parsed content of References field).

- fld_data.fld_subject is the content of the Subject field if type is MAILIMF_FIELD_SUBJECT (see the Section called mailimf_subject - parsed content of Subject field).

- fld_data.fld_comments is the content of the Comments field if type is MAILIMF_FIELD_COMMENTS (see the Section called mailimf_comments - parsed content of Comments field).

- fld_data.fld_keywords is the parsed content of the Keywords field if type is MAILIMF_FIELD_KEYWORDS (see the Section called mailimf_keywords - parsed content of Keywords field).

- fld_data.fld_optional_field is an other field and is not parsed if type is MAILIMF_FIELD_OPTIONAL_FIELD (see the Section called mailimf_optional_field - non-standard header).

mailimf_field_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_field_free() frees memory used by the structure and substructures will also be released.

Example 3-27. creation and display of field

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_field * f;
      struct mailimf_mailbox * mb;
      struct mailimf_mailbox_list * mb_list;
      struct mailimf_from * from;

      /* build header 'From' */

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      clist_append(list, mb);
      mb_list = mailimf_mailbox_list_new(list);

      from = mailimf_from_new(mb_list);

      f = mailimf_field_new(MAILIMF_FIELD_FROM,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        from, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, NULL);
      /* do the things */
      mailimf_field_free(f);

      return 0;
    }

    /* display content of the header */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_field(struct mailimf_field * field)
    {
      switch (field->type) {
      case MAILIMF_FIELD_RETURN_PATH:
        printf("Return-Path:\n");
        display_return(field->fld_data.fld_return_path);
        break;
      case MAILIMF_FIELD_RESENT_DATE:
        printf("Resent-Date:\n");
        display_orig_date(field->fld_data.fld_orig_date);
        break;
      case MAILIMF_FIELD_RESENT_FROM:
        printf("Resent-From:\n");
        display_from(field->fld_data.fld_orig_date);
        break;
      case MAILIMF_FIELD_RESENT_SENDER:
        printf("Resent-Sender:\n");
        display_sender(field->fld_data.fld_resent_sender);
        break;
      case MAILIMF_FIELD_RESENT_TO:
        printf("Resent-To:\n");
        display_to(field->fld_data.fld_resent_to);
        break;
      case MAILIMF_FIELD_RESENT_CC:
        printf("Resent-Cc:\n");
        display_from(field->fld_data.fld_resent_cc);
        break;
      case MAILIMF_FIELD_RESENT_BCC:
        printf("Resent-Bcc:\n");
        display_from(field->fld_data.fld_resent_bcc);
        break;
      case MAILIMF_FIELD_RESENT_MSG_ID:
        printf("Resent-Message-ID:\n");
        display_message_id(field->fld_data.fld_resent_msg_id);
        break;
      case MAILIMF_FIELD_ORIG_DATE:
        printf("Date:\n");
        display_orig_date(field->fld_data.fld_orig_date);
        break;
      case MAILIMF_FIELD_FROM:
        printf("From:\n");
        display_from(field->fld_data.fld_from);
        break;
      case MAILIMF_FIELD_SENDER:
        printf("Sender:\n");
         display_sender(field->fld_data.fld_sender);
        break;
      case MAILIMF_FIELD_REPLY_TO:
        printf("Reply-To:\n");
        display_reply_to(field->fld_data.fld_reply_to);
        break;
      case MAILIMF_FIELD_TO:
        printf("To:\n");
        display_to(field->fld_data.fld_to);
        break;
      case MAILIMF_FIELD_CC:
        printf("Cc:\n");
        display_cc(field->fld_data.fld_cc);
        break;
      case MAILIMF_FIELD_BCC:
        printf("Bcc:\n");
        display_bcc(field->fld_data.fld_bcc);
        break;
      case MAILIMF_FIELD_MESSAGE_ID:
        printf("Message-ID:\n");
        display_message_id(field->fld_data.fld_message_id);
        break;
      case MAILIMF_FIELD_IN_REPLY_TO:
        printf("In-Reply-To:\n");
        display_in_reply_to(field->fld_data.fld_in_reply_to);
        break;
      case MAILIMF_FIELD_REFERENCES:
        printf("References:\n");
        display_references(field->fld_data.fld_references_to);
        break;
      case MAILIMF_FIELD_SUBJECT:
        printf("Subject:\n");
        display_subject(field->fld_data.fld_subject);
        break;
      case MAILIMF_FIELD_COMMENTS:
        printf("Comments:\n");
        display_comments(field->fld_data.fld_comments);
        break;
      case MAILIMF_FIELD_KEYWORDS:
        printf("Keywords:\n");
        display_keywords(field->fld_data.fld_keywords);
        break;
      case MAILIMF_FIELD_OPTIONAL_FIELD:
        printf("[optional field]:\n");
        display_optional_field(field->fld_data.fld_optional_field);
        break;
      }
    }

## mailimf_fields - list of header fields

    #include <libetpan/libetpan.h>

    struct mailimf_fields {
      clist * fld_list; /* list of (struct mailimf_field *), != NULL */
    };

    struct mailimf_fields * mailimf_fields_new(clist * fld_list);

    void mailimf_fields_free(struct mailimf_fields * fields);

This is the list of header fields of a message.

fld_list is a list of header fields. This is a clist which elements are of type mailimf_field (see the Section called mailimf_field - header field).

mailimf_fields_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_fields_free() frees memory used by the structure and substructures will also be released.

Example 3-28. creation and display of header fields

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_fields * fields;
      struct mailimf_field * f;
      clist * list;
      struct mailimf_from * from;
      struct mailimf_to * to
      struct mailimf_mailbox * mb;
      struct mailimf_address * addr;
      struct mailimf_mailbox_list * mb_list;
      struct mailimf_address_list * addr_list;
      clist * fields_list;

      /* build headers */

      fields_list = clist_new();

      /* build header 'From' */

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      clist_append(list, mb);
      mb_list = mailimf_mailbox_list_new(list);

      from = mailimf_from_new(mb_list);

      f = mailimf_field_new(MAILIMF_FIELD_FROM,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        from, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, NULL);

      clist_append(fields_list, f);

      /* build header To */

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);
      addr_list = mailimf_address_list_new(list);

      to = mailimf_to_new(addr_list);

      f = mailimf_field_new(MAILIMF_FIELD_TO,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, to, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, NULL);

      clist_append(fields_list, f);

      fields = mailimf_fields_new(fields_list);
      /* do the things */
      mailimf_fields_free(fields);

      return 0;
    }

    /* display list of headers */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_fields(struct mailimf_fields * fields)
    {
      clistiter * cur;

      for(cur = clist_begin(field->fld_list) ; cur != NULL ;
        cur = clist_next(cur)) {
        struct mailimf_field * f;

        f = clist_content(cur);

        display_field(f);
        printf("\n");
      }
    }

## mailimf_body - message body without headers

    #include <libetpan/libetpan.h>

    struct mailimf_body {
      const char * bd_text; /* != NULL */
      size_t bd_size;
    };

    struct mailimf_body * mailimf_body_new(const char * bd_text, size_t bd_size);

    void mailimf_body_free(struct mailimf_body * body);

This is the text content of a message (without headers).

- bd_text is the beginning of the text part, it is a substring of an other string. It is not necessarily zero terminated.

- bd_size is the size of the text part

mailimf_body_new() creates and initializes a data structure with a value. Text given as argument will NOT be released.

mailimf_body_free() frees memory used by the structure.

Example 3-29. creation and display of message body

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_body * b;

      b = mailimf_body_new("this is the content of the message", 34);
      /* do the things */
      mailimf_body_free(b);

      return 0;
    }

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_body(struct mailimf_body * b)
    {
      char * text;

      text = malloc(b->size + 1);
      strncpy(text, b->bd_text, b->bd_size);
      text[b->size] = 0;

      puts(text);
      printf("\n");

      free(text);

      return 0;
    }

## mailimf_message - parsed message

    #include <libetpan/libetpan.h>

    struct mailimf_message {
      struct mailimf_fields * msg_fields; /* != NULL */
      struct mailimf_body * msg_body;     /* != NULL */
    };

    struct mailimf_message *
    mailimf_message_new(struct mailimf_fields * msg_fields,
        struct mailimf_body * msg_body);

    void mailimf_message_free(struct mailimf_message * message);

This is the message content (text and headers).

- msg_fields is the header fields of the message (see the Section called mailimf_fields - list of header fields).

- msg_body is the text part of the message (see the Section called mailimf_body - message body without headers).

mailimf_message_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will be freed if the object is released.

mailimf_message_free() frees memory used by the structure and substructures will also be released.

Example 3-30. creation and display of message

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_body * b;
      struct mailimf_message * m;
      struct mailimf_fields * fields;
      struct mailimf_fields * f;
      clist * list;
      struct mailimf_from * from;
      struct mailimf_to * to
      struct mailimf_mailbox * mb;
      struct mailimf_address * addr;
      struct mailimf_mailbox_list * mb_list;
      struct mailimf_address_list * addr_list;
      clist * fields_list;

      /* build text content */

      b = mailimf_body_new("this is the content of the message", 34);

      /* build headers */

      fields_list = clist_new();

      /* build header 'From' */

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      clist_append(list, mb);
      mb_list = mailimf_mailbox_list_new(list);

      from = mailimf_from_new(mb_list);

      f = mailimf_field_new(MAILIMF_FIELD_FROM,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        from, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, NULL);

      clist_append(fields_list, f);

      /* build header To */

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);
      addr_list = mailimf_address_list_new(list);

      to = mailimf_to_new(addr_list);

      f = mailimf_field_new(MAILIMF_FIELD_TO,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, to, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, NULL);

      clist_append(fields_list, f);

      fields = mailimf_fields_new(fields_list);

      /* build message */

      m = mailimf_message_new(fields, b);
      /* do the things */
      mailimf_message_free(m);

      return 0;
    }

    /* display the message */

    #include <libetpan/libetpan.h>
    #include <stdio.h>

    void display_message(struct mailimf_message * msg)
    {
      display_fields(msg->msg_fields);
      printf("\n");
      display_body(msg->msg_body);
      printf("\n");
    }

## mailimf_single_fields - simplified fields

    #include <libetpan/libetpan.h>

    struct mailimf_single_fields {
      struct mailimf_orig_date * fld_orig_date;      /* can be NULL */
      struct mailimf_from * fld_from;                /* can be NULL */
      struct mailimf_sender * fld_sender;            /* can be NULL */
      struct mailimf_reply_to * fld_reply_to;        /* can be NULL */
      struct mailimf_to * fld_to;                    /* can be NULL */
      struct mailimf_cc * fld_cc;                    /* can be NULL */
      struct mailimf_bcc * fld_bcc;                  /* can be NULL */
      struct mailimf_message_id * fld_message_id;    /* can be NULL */
      struct mailimf_in_reply_to * fld_in_reply_to;  /* can be NULL */
      struct mailimf_references * fld_references;    /* can be NULL */
      struct mailimf_subject * fld_subject;          /* can be NULL */
      struct mailimf_comments * fld_comments;        /* can be NULL */
      struct mailimf_keywords * fld_keywords;        /* can be NULL */
    };

    struct mailimf_single_fields *
    mailimf_single_fields_new(struct mailimf_fields * fields);

    void mailimf_single_fields_free(struct mailimf_single_fields *
                                    single_fields);

    void mailimf_single_fields_init(struct mailimf_single_fields * single_fields,
                                    struct mailimf_fields * fields);

Structure that contains some standard fields and allows access to a given header without running through the list.

mailimf_fields is the native structure that IMF module will use, this module will provide an easier structure to use when parsing fields. mailimf_single_fields is an easier structure to get parsed fields, rather than iteration over the list of fields

- fld_orig_date is the parsed "Date" field (see the Section called mailimf_orig_date - parsed content of date header).

- fld_from is the parsed "From" field (see the Section called mailimf_from - parsed content of From header).

- fld_sender is the parsed "Sender "field (see the Section called mailimf_sender - parsed content of Sender header).

- reply_to is the parsed "Reply-To" field (see the Section called mailimf_reply_to - parsed content of Reply-To header).

- fld_to is the parsed "To" field (see the Section called mailimf_to - parsed content of To header).

- fld_cc is the parsed "Cc" field (see the Section called mailimf_cc - parsed content of Cc).

- fld_bcc is the parsed "Bcc" field (see the Section called mailimf_bcc - parsed content of Bcc field).

- fld_message_id is the parsed "Message-ID" field. (see the Section called mailimf_message_id - parsed content of Message-ID header).

- fld_in_reply_to is the parsed "In-Reply-To" field. (see the Section called mailimf_in_reply_to - parsed content of In-Reply-To field).

- fld_references is the parsed "References" field. (see the Section called mailimf_references - parsed content of References field).

- fld_subject is the parsed "Subject" field (see the Section called mailimf_subject - parsed content of Subject field).

- fld_comments is the parsed "Comments" field (see the Section called mailimf_comments - parsed content of Comments field).

- fld_keywords is the parsed "Keywords" field (see the Section called mailimf_keywords - parsed content of Keywords field).

mailimf_single_fields_new() creates and initializes a data structure with a value. Structures given as argument are referenced by the created object and will NOT be freed if the object is released.

mailimf_single_fields_free() frees memory used by the structure and substructures will NOT be released. They should be released by the application.

mailimf_single_fields_init() will initialize fill the data structure, using the given argument (fields). The interesting fields will be filled into single_fields.

Example 3-31. using mailimf_single_fields

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_single_fields * single_fields;
      struct mailimf_fields * fields;
      struct mailimf_field * f;
      clist * list;
      struct mailimf_from * from;
      struct mailimf_to * to
      struct mailimf_mailbox * mb;
      struct mailimf_address * addr;
      struct mailimf_mailbox_list * mb_list;
      struct mailimf_address_list * addr_list;
      clist * fields_list;

      /* build headers */

      fields_list = clist_new();

      /* build header 'From' */

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      clist_append(list, mb);
      mb_list = mailimf_mailbox_list_new(list);

      from = mailimf_from_new(mb_list);

      f = mailimf_field_new(MAILIMF_FIELD_FROM,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        from, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, NULL);

      clist_append(fields_list, f);

      /* build header To */

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);
      addr_list = mailimf_address_list_new(list);

      to = mailimf_to_new(addr_list);

      f = mailimf_field_new(MAILIMF_FIELD_TO,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, to, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, NULL);

      clist_append(fields_list, f);

      fields = mailimf_fields_new(fields_list);

      /* create the single fields */
      single_fields = mailimf_single_fields_new(fields);
      /* do the things */
      mailimf_single_fields_free(single_fields);
      mailimf_fields_free(fields);

      return 0;
    }

Example 3-32. using mailimf_single_fields without memory allocation

    #include <libetpan/libetpan.h>

    int main(int argc, char ** argv)
    {
      struct mailimf_single_fields single_fields;
      struct mailimf_fields * fields;
      struct mailimf_field * f;
      clist * list;
      struct mailimf_from * from;
      struct mailimf_to * to
      struct mailimf_mailbox * mb;
      struct mailimf_address * addr;
      struct mailimf_mailbox_list * mb_list;
      struct mailimf_address_list * addr_list;
      clist * fields_list;

      /* build headers */

      fields_list = clist_new();

      /* build header 'From' */

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      clist_append(list, mb);
      mb_list = mailimf_mailbox_list_new(list);

      from = mailimf_from_new(mb_list);

      f = mailimf_field_new(MAILIMF_FIELD_FROM,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        from, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, NULL);

      clist_append(fields_list, f);

      /* build header To */

      list = clist_new();
      mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
        strdup("dinh.viet.hoa@free.fr"));
      addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
      clist_append(list, addr);
      addr_list = mailimf_address_list_new(list);

      to = mailimf_to_new(addr_list);

      f = mailimf_field_new(MAILIMF_FIELD_TO,
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, to, NULL, NULL, NULL, NULL, NULL,
        NULL, NULL, NULL, NULL);

      clist_append(fields_list, f);

      fields = mailimf_fields_new(fields_list);

      /* fill the single fields */
      mailimf_fields_fields_init(&single_fields, fields);
      /* do the things */
      mailimf_fields_free(fields);

      return 0;
    }

Prev | Home | Next
Internet Message Format | Up | Parser functions