
   2003-12-03 Viet Hoa DINH 2003 DINH Viet Hoa This document will
   describe the API of libEtPan! libEtPan! include a collection of
   datatypes such as lists, arrays, hash tables and tools such as
   buffered I/O. #include <libetpan/libetpan.h> typedef struct carray_s
   carray; carray is an array of pointers that will resize automatically
   in case a new element is added. The carray is implemented with an
   array (void **) that can be resized. An array has a size: this is the
   number of elements that can be added before the table is resized. It
   also has a count of elements: this is the elements that exist in the
   array. carray * carray_new(unsigned int initsize); void
   carray_free(carray * array); carray_new() creates a new array with an
   initial size. The array is not resized until the number of element
   reach the initial size. It returns NULL in case of failure.
   carray_free() releases memory used by the given array. #include
   <libetpan/libetpan.h> #include <stdlib.h> #define SIZE 50 int
   main(void) { carray * a; a = carray_new(SIZE); if (a == NULL)
   exit(EXIT_FAILURE); /* do things here */ carray_free(a);
   exit(EXIT_SUCESS); } int carray_set_size(carray * array, uint32_t
   new_size); carray_set_size() sets the size of the array. It returns 0
   in case of success, -1 in case of failure. #include
   <libetpan/libetpan.h> #include <stdlib.h> #define SIZE 50 #define
   NEWSIZE 200 int main(void) { carray * a; unsigned int i; char p[500];
   a = carray_new(SIZE); if (a == NULL) goto err; r =
   carray_set_size(NEWSIZE); if (r < 0) goto free; for(i = 0 ; i <
   NEWSIZE ; i ++) carray_set(a, i, &p[i]); /* do things here */
   carray_free(a); exit(EXIT_SUCESS); free: carray_free(a); err:
   exit(EXIT_FAILURE); } int carray_count(carray); int carray_add(carray
   * array, void * data, unsigned int * index); void * carray_get(carray
   * array, unsigned int indx); void carray_set(carray * array, unsigned
   int indx, void * value); carray_count() returns the number of elements
   in the carray. Complexity is O(1). carray_add()adds an element at the
   end of the array. The index of the element is returns in (* index) if
   index is not NULL. It returns 0 in case of success, -1 in case of
   failure. Complexity is O(1). carray_get() returns the elements
   contained at the given cell of the table. Complexity is O(1).
   carray_set() replace the element at the given index of table table
   with the given value. Complexity is O(1). #include
   <libetpan/libetpan.h> #include <string.h> #define SIZE 50 int
   main(void) { carray * a; int r; a = carray_new(SIZE); if (a == NULL)
   goto err; r = carray_add(a, "foo-bar-1", NULL); if (r < 0) goto free;
   carray_add(a, "foo-bar-2", NULL); if (r < 0) goto free; carray_add(a,
   "foo-bar-3", NULL); if (r < 0) goto free; for(i = 0 ; i <
   carray_count(a) ; i ++) { char * str; str = carray_get(a, i); if
   (strcmp("foo-bar-2", str) == 0) carray_set(a, i,
   "foo-bar-2-replacement"); printf("%s\n", str); } carray_free(a);
   exit(EXIT_SUCESS); free: carray_free(a); err: exit(EXIT_FAILURE); }
   int carray_delete(carray * array, uint32_t indx); int
   carray_delete_slow(carray * array, uint32_t indx); int
   carray_delete_fast(carray * array, uint32_t indx); carray_delete()
   removes an element of the table. Order will not be garanteed. The
   returned result can be ignored. Complexity is O(1).
   carray_delete_slow() removes an element of the table. Order will be
   garanteed. The returned result can be ignored. Complexity is O(n).
   carray_delete_fast() the element will just be replaced with NULL.
   Order will be kept but the number of elements will remains the same.
   The returned result can be ignored. Complexity is O(1). #include
   <libetpan/libetpan.h> #define SIZE 50 carray * build_array(void) {
   carray * a; a = carray_new(SIZE); if (a == NULL) goto err; r =
   carray_add(a, "foo-bar-1", NULL); if (r < 0) goto free; carray_add(a,
   "foo-bar-2", NULL); if (r < 0) goto free; carray_add(a, "foo-bar-3",
   NULL); if (r < 0) goto free; return a; free: carray_free(a); err:
   exit(EXIT_FAILURE); } void delete(carray * a) { /* deleting foo-bar-1
   */ carray_delete(a, 0); /* resulting size is 2, order of elements is
   undefined */ } void delete_slow(carray * a) { /* deleting foo-bar-1 */
   carray_delete_slow(a, 0); /* resulting size is 2, order of elements is
   the same */ } void delete_fast(carray * a) { /* deleting foo-bar-1 */
   carray_delete_slow(a, 0); /* resulting size is 3, order of elements is
   { NULL, foo-bar-2, foo-bar-3 } */ } void ** carray_data(carray);
   carray_datareturns the table used for implementation : (void **).
   #include <libetpan/libetpan.h> typedef struct clist_s clist; typedef
   clistcell clistiter; clist() is a list of cells. Each cell of the list
   contains one element. This element is a pointer. An iterator
   (clistiter) is a pointer to an element of the list. With an iterator,
   we can get the previous element of the list, the next element of the
   list and the content of the element. clist * clist_new(void); void
   clist_free(clist *); clist_new() allocates a new empty list and
   returns it. clist_free() frees the entire list with its cells.
   #include <libetpan/libetpan.h> int main(void) { clist * list; list =
   clist_new(); if (list == NULL) goto err; r = clist_append(list,
   "foo-bar"); if (r < 0) clist_free(list); exit(EXIT_SUCCESS); free:
   clist_free(list); err: exit(EXIT_FAILURE); } int clist_isempty(clist
   *); int clist_count(clist *); clist_isempty() returns 1 if the list is
   empty, else it is 0. Complexity is O(1). clist_count() returns the
   number of elements in the list. Complexity is O(1). clistiter *
   clist_begin(clist *); clistiter * clist_end(clist *); clistiter *
   clist_next(clistiter *); clistiter * clist_previous(clistiter *); void
   * clist_content(clistiter *); void * clist_nth_data(clist * lst, int
   index); clistiter * clist_nth(clist * lst, int index); clist_begin()
   returns an iterator to the first element of the list. Complexity is
   O(1). clist_end() returns an iterator to the last element of the list.
   Complexity is O(1). clist_next() returns an iterator to the next
   element of the list. Complexity is O(1). clist_previous() returns an
   iterator to the previous element of the list. Complexity is O(1).
   clist_content() returns the element contained in the cell pointed by
   the iterator in the list. Complexity is O(1). clist_nth() returns an
   iterator on the index-th element of the list. Complexity is O(n).
   clist_nth_data() returns the index-th element of the list. Complexity
   is O(n). #include <libetpan/libetpan.h> int main(void) { clist * list;
   clistiter * iter; list = build_string_list(); if (list == NULL) goto
   err; for(iter = clist_begin(list) ; iter != NULL ; iter =
   clist_next(iter)) { char * str; str = clist_content(iter);
   printf("%s\n", str); } clist_free(list); exit(EXIT_SUCCESS); free:
   clist_free(list); err: exit(EXIT_FAILURE); } int clist_prepend(clist
   *, void *); int clist_append(clist *, void *); int
   clist_insert_before(clist *, clistiter *, void *); int
   clist_insert_after(clist *, clistiter *, void *); clistiter *
   clist_delete(clist *, clistiter *); clist_prepend() adds an element at
   the beginning of the list. Returns 0 on sucess, -1 on error.
   Complexity is O(1). clist_append() adds an element at the end of the
   list. Returns 0 on sucess, -1 on error. Complexity is O(1).
   clist_insert_before() adds an element before the element pointed by
   the given iterator in the list. Returns 0 on sucess, -1 on error.
   Complexity is O(1). clist_insert_after() adds an element after the
   element pointed by the given iterator in the list. Returns 0 on
   sucess, -1 on error. Complexity is O(1). clist_delete() the elements
   pointed by the given iterator in the list and returns an iterator to
   the next element of the list. Complexity is O(1). #include
   <libetpan/libetpan.h> voir print_content(void * content, void *
   user_data) { char * str; str = content; printf("%s\n", str); } int
   main(void) { clist * list; clistiter * iter; list =
   build_string_list(); if (list == NULL) goto err; iter = =
   clist_begin(list); while (iter != NULL) char * str; str =
   clist_content(iter); if (strcmp(str, "foo-bar") == 0) iter =
   clist_delete(list, cur); else iter = clist_next(iter); }
   clist_foreach(list, print_content, NULL); printf("\n");
   clist_free(list); exit(EXIT_SUCCESS); free: clist_free(list); err:
   exit(EXIT_FAILURE); } typedef void (* clist_func)(void *, void *);
   void clist_foreach(clist * lst, clist_func func, void * data);
   clist_foreach() apply a fonction to each element of the list.
   Complexity is O(n). void clist_concat(clist * dest, clist * src);
   clist_concat() adds all the elements of src at the end of dest.
   Elements are added in the same order. src is an empty list when the
   operation is finished. Complexity is O(1). #include
   <libetpan/libetpan.h> int main(void) { clist * list; clist * list_2;
   clistiter * iter; list = build_string_list(); if (list == NULL) goto
   err; list_2 = build_string_list_2(); if (list == NULL) goto free_list;
   clist_concat(list, list_2); clist_free(list_2); for(iter =
   clist_begin(list) ; iter != NULL ; iter = clist_next(iter)) { char *
   str; str = clist_content(iter); printf("%s\n", str); }
   clist_free(list); exit(EXIT_SUCCESS); free_list: clist_free(list);
   err: exit(EXIT_FAILURE); } #include <libetpan/libetpan.h> typedef
   struct chash chash; typedef struct chashcell chashiter; typedef struct
   { char * data; int len; } chashdatum; chash is a hash table. chashiter
   is a pointer to an element of the hash table. chashdatum is an element
   to be placed in the hash table as a key or a value. It consists in
   data and a corresponding length. #define CHASH_COPYNONE 0 #define
   CHASH_COPYKEY 1 #define CHASH_COPYVALUE 2 #define CHASH_COPYALL
   (CHASH_COPYKEY | CHASH_COPYVALUE) chash * chash_new(int size, int
   flags); void chash_free(chash * hash); chash_new() returns a new empty
   hash table or NULL if this failed. size is the initial size of the
   table used for implementation. flags can be a combinaison of
   CHASH_COPYKEY and CHASH_COPYVALUE. CHASH_COPYKEY enables copy of key,
   so that the initial value used for chash_set() chash_free() releases
   memory used by the hash table. int chash_set(chash * hash, chashdatum
   * key, chashdatum * value, chashdatum * oldvalue); int chash_get(chash
   * hash, chashdatum * key, chashdatum * result); chash_set() adds a new
   element into the hash table. If a previous element had the same key,
   it is returns into oldvalue if oldvalue is different of NULL. Medium
   complexity is O(1). returns -1 if it fails, 0 on success.
   chash_get()returns the corresponding value of the given key. If there
   is no corresponding value, -1 is returned. 0 on success. Medium
   complexity is O(1). int main(void) { chash * hash; int r; chashdatum
   key; chashdatum value; char * str1 = "my-data"; char * str2 =
   "my-data"; hash = chash_new(CHASH_DEFAULTSIZE, CHASH_COPYNONE);
   key.data = "foo"; key.len = strlen("foo"); value.data = str1;
   value.data = strlen(str1) + 1; /* + 1 is needed to get the terminal
   zero in the returned string */ r = chash_set(hash, &key, &value,
   NULL); if (r < 0) goto free_hash; key.data = "bar"; key.len =
   strlen("bar"); value.data = str2; value.data = strlen(str2) + 1; if (r
   < 0) goto free_hash; key.data = "foo"; key.len = strlen("foo"); r =
   chash_get(hash, &key, &value); if (r < 0) { printf("element not
   found\n"); } else { char * str; str = value.data; printf("found : %s",
   str); } chash_free(hash); exit(EXIT_SUCCESS); free_hash:
   chash_free(hash); err: exit(EXIT_FAILURE); } int chash_delete(chash *
   hash, chashdatum * key, chashdatum * oldvalue); deletes the key/value
   pair given the corresponding key. The value is returned in old_value.
   If there is no corresponding value, -1 is returned. 0 on success.
   Medium complexity is O(1). int main(void) { chash * hash; int r;
   chashdatum key; chashdatum value; char * str1 = "my-data"; char * str2
   = "my-data"; hash = build_hash(); key.data = "foo"; key.len =
   strlen("foo"); chash_delete(hash, &key, &value); /* it will never be
   possible to lookup "foo" */ key.data = "foo"; key.len = strlen("foo");
   r = chash_get(hash, &key, &value); if (r < 0) { printf("element not
   found\n"); } else { char * str; str = value.data; printf("found : %s",
   str); } chash_free(hash); exit(EXIT_SUCCESS); free_hash:
   chash_free(hash); err: exit(EXIT_FAILURE); } int chash_resize(chash *
   hash, int size); chash_resize() changes the size of the table used for
   implementation of the hash table. returns 0 on success, -1 on failure.
   chashiter * chash_begin(chash * hash); chashiter * chash_next(chash *
   hash, chashiter * iter); void chash_key(chashiter * iter, chashdatum *
   result); void chash_value(chashiter iter, chashdatum * result);
   chash_begin() returns a pointer to the first element of the hash
   table. Returns NULL if there is no elements in the hash table.
   Complexity is O(n). chash_next() returns a pointer to the next element
   of the hash table. Returns NULL if there is no next element.
   Complexity is O(n) but n calls to chash_next() also has a complexity
   of O(n). chash_key() returns the key of the given element of the hash
   table. chash_value returns the value of the given element of the hash
   table. int main(void) { chash * hash; int r; chashiter * iter; hash =
   build_hash(); /* this will display all the values stored in the hash
   */ for(iter = chash_begin(hash) ; iter != NULL ; iter =
   chash_next(hash, iter)) { chashdatum key; chashdatum value; char *
   str; chash_value(iter, &value); str = value.data; printf("%s\n", str);
   } chash_free(hash); } int chash_size(chash * hash); int
   chash_count(chash * hash); chash_size() returns the size of the table
   used for implementation of the hash table. Complexity is O(1).
   chash_count() returns the number of elements in the hash table.
   Complexity is O(1). #include <libetpan/libetpan.h> typedef struct
   _mailstream mailstream; streams are objects where we can read data
   from and write data to. They are not seekable. That can be for example
   a pipe or a network stream. mailstream * mailstream_new(mailstream_low
   * low, size_t buffer_size); int mailstream_close(mailstream * s);
   mailstream_new() creates a new stream stream with the low-level (see )
   stream and a given buffer size. mailstream_close() closes the stream.
   This function will be in charge to free the mailstream_low structure.
   ssize_t mailstream_write(mailstream * s, void * buf, size_t count);
   int mailstream_flush(mailstream * s); ssize_t
   mailstream_read(mailstream * s, void * buf, size_t count); ssize_t
   mailstream_feed_read_buffer(mailstream * s); mailstream_write() writes
   a buffer to the given stream. This write operation will be buffered.
   mailstream_flush() will force a write of all buffered data for a given
   stream. mailstream_read() reads data from the stream to the given
   buffer. mailstream_feed_read_buffer() this function will just fill the
   buffer for reading. mailstream_low * mailstream_get_low(mailstream *
   s); void mailstream_set_low(mailstream * s, mailstream_low * low);
   mailstream_get_low() returns the low-level stream of the given stream.
   mailstream_set_low() changes the low-level of the given stream.
   Useful, for example, when a stream change from clear stream to SSL
   stream. char * mailstream_read_line(mailstream * stream, MMAPString *
   line); char * mailstream_read_line_append(mailstream * stream,
   MMAPString * line); char * mailstream_read_line_remove_eol(mailstream
   * stream, MMAPString * line); char *
   mailstream_read_multiline(mailstream * s, size_t size, MMAPString *
   stream_buffer, MMAPString * multiline_buffer, size_t progr_rate,
   progress_function * progr_fun); mailstream_read_line() reads an entire
   line from the buffer and store it into the given string. returns NULL
   on error, the corresponding array of char is returned otherwise.
   mailstream_read_line_append() reads an entire line from the buffer and
   appends it to the given string. returns NULL on error, the array of
   char corresponding to the entire buffer is returned otherwise.
   mailstream_read_line_remove_eol() reads an entire line from the buffer
   and store it into the given string. All CR LF are removed. returns
   NULL on error, the corresponding array of char is returned otherwise.
   mailstream_read_multiline() reads a multiline data (several lines, the
   data are ended with a single period '.') from the given stream and
   store it into the given multiline buffer (multiline_buffer).
   progr_rate should be 0 and progr_fun NULL (deprecated things).
   stream_buffer is a buffer used for internal work of the function. size
   should be 0 (deprecated things). int mailstream_is_end_multiline(char
   * line); returns 1 if the line is an end of multiline data (a single
   period '.', eventually with CR and/or LF). 0 is returned otherwise.
   int mailstream_send_data(mailstream * s, char * message, size_t size,
   size_t progr_rate, progress_function * progr_fun); sends multiline
   data to the given stream. size is the size of the data. progr_rate and
   progr_fun are deprecated. progr_rate must be 0, progr_fun must be
   NULL. mailstream * mailstream_socket_open(int fd); mailstream *
   mailstream_ssl_open(int fd); mailstream_socket_open() will open a
   clear-text socket. mailstream_socket_open() will open a TLS/SSL
   socket. #include <libetpan/libetpan.h> struct mailstream_low_driver {
   ssize_t (* mailstream_read)(mailstream_low *, void *, size_t); ssize_t
   (* mailstream_write)(mailstream_low *, void *, size_t); int (*
   mailstream_close)(mailstream_low *); int (*
   mailstream_get_fd)(mailstream_low *); void (*
   mailstream_free)(mailstream_low *); }; typedef struct
   mailstream_low_driver mailstream_low_driver; struct _mailstream_low {
   void * data; mailstream_low_driver * driver; }; mailstream_low is a
   non-buffered stream. The mailstream_low_driver is a set of functions
   used to access the stream. mailstream_read/write/close() is the same
   interface as read/write/close() system calls, except that the file
   descriptor is replaced with the mailstream_low structure.
   mailstream_get_fd() returns the file descriptor used for this
   non-buffered stream. mailstream_free() is in charge to free the
   internal structure of the mailstream_low and the mailstream_low
   itself. mailstream_low * mailstream_low_new(void * data,
   mailstream_low_driver * driver); mailstream_low_new() creates a
   low-level mailstream with the given internal structure (data) and
   using the given set of functions (driver). ssize_t
   mailstream_low_write(mailstream_low * s, void * buf, size_t count);
   ssize_t mailstream_low_read(mailstream_low * s, void * buf, size_t
   count); int mailstream_low_close(mailstream_low * s); int
   mailstream_low_get_fd(mailstream_low * s); void
   mailstream_low_free(mailstream_low * s); Each of these calls will call
   the corresponding function defined in the driver. #include
   <libetpan/libetpan.h> struct _MMAPString { char * str; size_t len;
   size_t allocated_len; int fd; size_t mmapped_size; }; typedef struct
   _MMAPString MMAPString; MMAPString is a string which size that can
   increase automatically. MMAPString * mmap_string_new(const char *
   init); MMAPString * mmap_string_new_len(const char * init, size_t
   len); MMAPString * mmap_string_sized_new(size_t dfl_size); void
   mmap_string_free(MMAPString * string); mmap_string_new() allocates a
   new string. init is the intial value of the string. NULL will be
   returned on error. mmap_string_new_len() allocates a new string. init
   is the intial value of the string, len is the length of the initial
   string. NULL will be returned on error. mmap_string_sized_new()
   allocates a new string. dfl_size is the initial allocation of the
   string. NULL will be returned on error. mmap_string_free() release the
   memory used by the string. MMAPString * mmap_string_assign(MMAPString
   * string, const char * rval); MMAPString *
   mmap_string_truncate(MMAPString *string, size_t len);
   mmap_string_assign() sets a new value for the given string. NULL will
   be returned on error. mmap_string_truncate() sets a length for the
   string. NULL will be returned on error. MMAPString *
   mmap_string_set_size (MMAPString * string, size_t len); sets the
   allocation of the string. NULL will be returned on error. MMAPString *
   mmap_string_insert_len(MMAPString * string, size_t pos, const char *
   val, size_t len); MMAPString * mmap_string_append(MMAPString * string,
   const char * val); MMAPString * mmap_string_append_len(MMAPString *
   string, const char * val, size_t len); MMAPString *
   mmap_string_append_c(MMAPString * string, char c); MMAPString *
   mmap_string_prepend(MMAPString * string, const char * val); MMAPString
   * mmap_string_prepend_c(MMAPString * string, char c); MMAPString *
   mmap_string_prepend_len(MMAPString * string, const char * val, size_t
   len); MMAPString * mmap_string_insert(MMAPString * string, size_t pos,
   const char * val); MMAPString * mmap_string_insert_c(MMAPString
   *string, size_t pos, char c); MMAPString *
   mmap_string_erase(MMAPString * string, size_t pos, size_t len); For
   complexity here, n is the size of the given MMAPString, and len is the
   size of the string to insert. mmap_string_insert_len() inserts the
   given string value of given length in the string at the given
   position. NULL will be returned on error. Complexity is O(n + len).
   mmap_string_append() appends the given string value at the end of the
   string. NULL will be returned on error. Complexity is O(len).
   mmap_string_append_len() appends the given string value of given
   length at the end of the string. NULL will be returned on error.
   Complexity is O(len). mmap_string_append_c() appends the given
   character at the end of the string. NULL will be returned on error.
   Complexity is O(1). mmap_string_prepend() insert the given string
   value at the beginning of the string. NULL will be returned on error.
   Complexity is O(n + len). mmap_string_prepend_c() insert the given
   character at the beginning of the string. NULL will be returned on
   error. Complexity is O(n). mmap_string_prepend_len() insert the given
   string value of given length at the beginning of the string. NULL will
   be returned on error. Complexity is O(n + len). mmap_string_insert()
   inserts the given string value in the string at the given position.
   NULL will be returned on error. Complexity is O(n + len).
   mmap_string_insert_c() inserts the given character in the string at
   the given position. NULL will be returned on error. Complexity is
   O(n). mmap_string_erase() removes the given count of characters (len)
   at the given position of the string. NULL will be returned on error.
   Complexity is O(n). int mmap_string_ref(MMAPString * string); int
   mmap_string_unref(char * str); MMAPString provides a mechanism that
   let you use MMAPString like normal strings. You have first to use
   mmap_string_ref(), so that you notify that the string will be used as
   a normal string, then, you use mmapstr->str to refer to the string.
   When you have finished and you want to free a string corresponding to
   a MMAPString, you will use mmap_string_unref. mmap_string_ref()
   references the string so that the array of characters can be used as a
   normal string then released with mmap_string_unref(). The array of
   characters will be obtained with string->str. returns -1 on error, 0
   on success. All allocation functions will take as argument allocated
   data and will store these data in the structure they will allocate.
   Data should be persistant during all the use of the structure and will
   be freed by the free function of the structure allocation functions
   will return NULL on failure functions returning integer will be
   returning one of the following error code: MAILIMF_NO_ERROR,
   MAILIMF_ERROR_PARSE, MAILIMF_ERROR_MEMORY, MAILIMF_ERROR_INVAL, or
   MAILIMF_ERROR_FILE. #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. 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. #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); } #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 ) ad_data.group is a group if type is MAILIMF_ADDRESS_GROUP. see )
   mailimf_address_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.
   mailimf_address_free frees memory used by the structure and
   substructures will also be released. /* 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; } } #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 ).
   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. /* 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"); } } #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 ).
   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. /* 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"); } } #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. 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 ). 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. /* 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"); } } #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 : 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. #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); } #include <libetpan/libetpan.h> struct mailimf_orig_date
   { struct * 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 ).
   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. #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); }
   #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 ). 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. #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); } #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 ). 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. #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); } #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 ). 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. #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); } 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 ). 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. #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); } #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
   ). 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. #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); } #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 ). 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. /* 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); } } #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 : 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. #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); } #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> TODO 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.
   #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); } } #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. #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); } } #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. #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); } #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. #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); } #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. #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); } } #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 ). 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. #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); } #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. #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); } #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. #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); } #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 ). fld_data.fld_resent_date is the parsed content of the
   Resent-Date field if type is MAILIMF_FIELD_RESENT_DATE (see ).
   fld_data.fld_resent_from is the parsed content of the Resent-From
   field if type is MAILIMF_FIELD_RESENT_FROM (see ).
   fld_data.fld_resent_sender is the parsed content of the Resent-Sender
   field if type is MAILIMF_FIELD_RESENT_SENDER (see ).
   fld_data.fld_resent_to is the parsed content of the Resent-To field if
   type is MAILIMF_FIELD_RESENT_TO (see ). fld_data.fld_resent_cc is the
   parsed content of the Resent-Cc field if type is MAILIMF_FIELD_CC (see
   ). fld_data.fld_resent_bcc is the parsed content of the Resent-Bcc
   field if type is MAILIMF_FIELD_BCC (see ). 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 ). fld_data.fld_orig_date is the
   parsed content of the Date field if type is MAILIMF_FIELD_ORIG_DATE
   (see ). fld_data.fld_from is the parsed content of the From field if
   type is MAILIMF_FIELD_FROM (see ). fld_data.fld_sender is the parsed
   content of the Sender field if type is MAILIMF_FIELD_SENDER (see ).
   fld_data.fld_reply_to is the parsed content of the Reply-To field if
   type is MAILIMF_FIELD_REPLY_TO (see ). fld_data.fld_to is the parsed
   content of the To field if type is MAILIMF_FIELD_TO (see ).
   fld_data.fld_cc is the parsed content of the Cc field if type is
   MAILIMF_FIELD_CC (see ). fld_data.fld_bcc is the parsed content of the
   Bcc field if type is MAILIMF_FIELD_BCC (see ). fld_data.fld_message_id
   is the parsed content of the Message-ID field if type is
   MAILIMF_FIELD_MESSAGE_ID (see ). 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 ). fld_data.fld_references is the
   parsed content of the References field if type is
   MAILIMF_FIELD_REFERENCES (see ). fld_data.fld_subject is the content
   of the Subject field if type is MAILIMF_FIELD_SUBJECT (see ).
   fld_data.fld_comments is the content of the Comments field if type is
   MAILIMF_FIELD_COMMENTS (see ). fld_data.fld_keywords is the parsed
   content of the Keywords field if type is MAILIMF_FIELD_KEYWORDS (see
   ). fld_data.fld_optional_field is an other field and is not parsed if
   type is MAILIMF_FIELD_OPTIONAL_FIELD (see ). 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.
   #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; } }
   #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 ).
   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. #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"); } } #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.
   #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; }
   #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 ).
   msg_body is the text part of the message (see ). 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.
   #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"); } #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 ).
   fld_from is the parsed "From" field (see ). fld_sender is the parsed
   "Sender "field (see ). reply_to is the parsed "Reply-To" field (see ).
   fld_to is the parsed "To" field (see ). fld_cc is the parsed "Cc"
   field (see ). fld_bcc is the parsed "Bcc" field (see ). fld_message_id
   is the parsed "Message-ID" field. (see ). fld_in_reply_to is the
   parsed "In-Reply-To" field. (see ). fld_references is the parsed
   "References" field. (see ). fld_subject is the parsed "Subject" field
   (see ). fld_comments is the parsed "Comments" field (see ).
   fld_keywords is the parsed "Keywords" field (see ).
   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. #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; } #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; } int
   mailimf_address_list_parse(char * message, size_t length, size_t *
   index, struct mailimf_address_list ** result);
   mailimf_address_list_parse() parse a list of addresses in RFC 2822
   form. message this is a string containing the list of addresses.
   length this is the size of the given string index this is a pointer to
   the start of the list of addresses in the given string, (* index) is
   modified to point at the end of the parsed data. result the result of
   the parse operation is stored in (* result) (see ). return
   MAILIMF_NO_ERROR on success, MAILIMF_ERROR_XXX on error. #include
   <libetpan/libetpan.h> #include <sys/stat.h> #include <sys/mman.h> int
   main(int argc, char ** argv) { int fd; int r; status = EXIT_FAILURE;
   fd = open("message.rfc2822", O_RDONLY); if (fd >= 0) { void * mem;
   struct stat stat_info; r = fstat(fd, &stat_info); if (r >= 0) { mem =
   mmap(NULL, stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem !=
   MAP_FAILED) { struct mailimf_address_list * addr_list; size_t
   current_index; current_index = 0; r = mailimf_address_list_parse(mem,
   stat_info.st_size, &current_index, &addr_list); if (r ==
   MAILIMF_NO_ERROR) { display_address_list(addr_list); /* do the things
   */ status = EXIT_SUCCESS; mailimf_address_list_free(addr_list); } }
   munmap(mem, stat_info.st_size); } close(fd); } exit(status); }
   #include <libetpan/libetpan.h> int mailimf_address_parse(char *
   message, size_t length, size_t * index, struct mailimf_address **
   result); mailimf_address_parse() parse an address in RFC 2822 form.
   message this is a string containing the address. length this is the
   size of the given string. index index this is a pointer to the start
   of the address in the given string, (* index) is modified to point at
   the end of the parsed data. result the result of the parse operation
   is stored in (* result) (see ). return MAILIMF_NO_ERROR on success,
   MAILIMF_ERROR_XXX on error. #include <libetpan/libetpan.h> #include
   <sys/stat.h> #include <sys/mman.h> int main(int argc, char ** argv) {
   int fd; int r; status = EXIT_FAILURE; fd = open("message.rfc2822",
   O_RDONLY); if (fd >= 0) { void * mem; struct stat stat_info; r =
   fstat(fd, &stat_info); if (r >= 0) { mem = mmap(NULL,
   stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem != MAP_FAILED) {
   struct mailimf_address * addr; size_t current_index; current_index =
   0; r = mailimf_address_parse(mem, stat_info.st_size, &current_index,
   &addr); if (r == MAILIMF_NO_ERROR) { display_address(addr); /* do the
   things */ status = EXIT_SUCCESS; mailimf_address_free(addr); } }
   munmap(mem, stat_info.st_size); } close(fd); } exit(status); }
   #include <libetpan/libetpan.h> int mailimf_body_parse(char * message,
   size_t length, size_t * index, struct mailimf_body ** result);
   mailimf_body_parse() parse text body of a message. message this is a
   string containing the message body part. length this is the size of
   the given string. index this is a pointer to the start of the message
   text part in the given string, (* index) is modified to point at the
   end of the parsed data. result the result of the parse operation is
   stored in (* result) (see ). return MAILIMF_NO_ERROR on success,
   MAILIMF_ERROR_XXX on error. #include <libetpan/libetpan.h> #include
   <sys/stat.h> #include <sys/mman.h> int main(int argc, char ** argv) {
   int fd; int r; status = EXIT_FAILURE; fd = open("message.rfc2822",
   O_RDONLY); if (fd >= 0) { void * mem; struct stat stat_info; r =
   fstat(fd, &stat_info); if (r >= 0) { mem = mmap(NULL,
   stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem != MAP_FAILED) {
   struct mailimf_body * b; struct mailimf_fields * f; size_t
   current_index; size_t size; size = stat_info.st_size; current_index =
   0; r = mailimf_fields_parse(mem, size, &current_index, &f); if (r ==
   MAILIMF_NO_ERROR) { r = mailimf_crlf_parse(mem, size, &current_index);
   /* ignore parse error of crlf */ r = mailimf_body_parse(mem, size,
   &current_index, &b); if (r == MAILIMF_NO_ERROR) { display_body(b); /*
   do the things */ status = EXIT_SUCCESS; mailimf_body_free(b); }
   mailimf_fields_free(f); } } munmap(mem, stat_info.st_size); }
   close(fd); } exit(status); } #include <libetpan/libetpan.h> int
   mailimf_envelope_and_optional_fields_parse(char * message, size_t
   length, size_t * index, struct mailimf_fields ** result);
   mailimf_envelope_and_optional_fields_parse() returns a list of most
   useful headers (parsed). The other headers will be placed in the list
   in a non-parsed form. message this is a string containing the header.
   length this is the size of the given string index index this is a
   pointer to the start of the header in the given string, (* index) is
   modified to point at the end of the parsed data result the result of
   the parse operation is stored in (* result) (see ). return
   MAILIMF_NO_ERROR on success, MAILIMF_ERROR_XXX on error. #include
   <libetpan/libetpan.h> #include <sys/stat.h> #include <sys/mman.h> int
   main(int argc, char ** argv) { int fd; int r; status = EXIT_FAILURE;
   fd = open("message.rfc2822", O_RDONLY); if (fd >= 0) { void * mem;
   struct stat stat_info; r = fstat(fd, &stat_info); if (r >= 0) { mem =
   mmap(NULL, stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem !=
   MAP_FAILED) { struct mailimf_fields * f; size_t current_index;
   current_index = 0; r = mailimf_envelope_and_optional_fields_parse(mem,
   stat_info.st_size, &current_index, &f); if (r == MAILIMF_NO_ERROR) {
   display_fields(m); /* do the things */ status = EXIT_SUCCESS;
   mailimf_fields_free(f); } } munmap(mem, stat_info.st_size); }
   close(fd); } exit(status); } #include <libetpan/libetpan.h> int
   mailimf_envelope_fields_parse(char * message, size_t length, size_t *
   index, struct mailimf_fields ** result);
   mailimf_envelope_fields_parse() return a list of most useful headers
   (parsed). message this is a string containing the header length this
   is the size of the given string index index this is a pointer to the
   start of the header in the given string, (* index) is modified to
   point at the end of the parsed data result the result of the parse
   operation is stored in (* result) (see ). return MAILIMF_NO_ERROR on
   success, MAILIMF_ERROR_XXX on error. #include <libetpan/libetpan.h>
   #include <sys/stat.h> #include <sys/mman.h> int main(int argc, char **
   argv) { int fd; int r; status = EXIT_FAILURE; fd =
   open("message.rfc2822", O_RDONLY); if (fd >= 0) { void * mem; struct
   stat stat_info; r = fstat(fd, &stat_info); if (r >= 0) { mem =
   mmap(NULL, stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem !=
   MAP_FAILED) { struct mailimf_fields * f; size_t current_index;
   current_index = 0; r = mailimf_envelope_fields_parse(mem,
   stat_info.st_size, &current_index, &f); if (r == MAILIMF_NO_ERROR) {
   display_fields(m); /* do the things */ status = EXIT_SUCCESS;
   mailimf_fields_free(f); } } munmap(mem, stat_info.st_size); }
   close(fd); } exit(status); } #include <libetpan/libetpan.h> int
   mailimf_envelope_and_optional_fields_parse(char * message, size_t
   length, size_t * index, struct mailimf_fields ** result);
   mailimf_optional_fields_parse return a list of non-parsed headers.
   message this is a string containing the header length this is the size
   of the given string index index this is a pointer to the start of the
   header in the given string, (* index) is modified to point at the end
   of the parsed data result the result of the parse operation is stored
   in (* result) (see ). return MAILIMF_NO_ERROR on success,
   MAILIMF_ERROR_XXX on error. #include <libetpan/libetpan.h> #include
   <sys/stat.h> #include <sys/mman.h> int main(int argc, char ** argv) {
   int fd; int r; status = EXIT_FAILURE; fd = open("message.rfc2822",
   O_RDONLY); if (fd >= 0) { void * mem; struct stat stat_info; r =
   fstat(fd, &stat_info); if (r >= 0) { mem = mmap(NULL,
   stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem != MAP_FAILED) {
   struct mailimf_fields * f; size_t current_index; current_index = 0; r
   = mailimf_optional_fields_parse(mem, stat_info.st_size,
   &current_index, &f); if (r == MAILIMF_NO_ERROR) { display_fields(m);
   /* do the things */ status = EXIT_SUCCESS; mailimf_fields_free(f); } }
   munmap(mem, stat_info.st_size); } close(fd); } exit(status); } TODO
   #include <libetpan/libetpan.h> int mailimf_fields_parse(char *
   message, size_t length, size_t * index, struct mailimf_fields **
   result); mailimf_fields_parse() parse headers of a message. message
   this is a string containing the header length this is the size of the
   given string index index this is a pointer to the start of the header
   in the given string, (* index) is modified to point at the end of the
   parsed data result the result of the parse operation is stored in (*
   result) (see ). return MAILIMF_NO_ERROR on success, MAILIMF_ERROR_XXX
   on error. #include <libetpan/libetpan.h> #include <sys/stat.h>
   #include <sys/mman.h> int main(int argc, char ** argv) { int fd; int
   r; status = EXIT_FAILURE; fd = open("message.rfc2822", O_RDONLY); if
   (fd >= 0) { void * mem; struct stat stat_info; r = fstat(fd,
   &stat_info); if (r >= 0) { mem = mmap(NULL, stat_info.st_size,
   PROT_READ, MAP_PRIVATE); if (mem != MAP_FAILED) { struct
   mailimf_fields * f; size_t current_index; current_index = 0; r =
   mailimf_fields_parse(mem, stat_info.st_size, &current_index, &f); if
   (r == MAILIMF_NO_ERROR) { display_fields(f); /* do the things */
   status = EXIT_SUCCESS; mailimf_fields_free(f); } } munmap(mem,
   stat_info.st_size); } close(fd); } exit(status); } #include
   <libetpan/libetpan.h> int mailimf_ignore_field_parse(char * message,
   size_t length, size_t * index); mailimf_ignore_field_parse() skip the
   next header. message this is a string containing the header length
   this is the size of the given string index index this is a pointer to
   the start of the field to skip in the given string, (* index) is
   modified to point at the end of the parsed data return
   MAILIMF_NO_ERROR on success, MAILIMF_ERROR_XXX on error. #include
   <libetpan/libetpan.h> #include <sys/stat.h> #include <sys/mman.h> int
   main(int argc, char ** argv) { int fd; int r; status = EXIT_FAILURE;
   fd = open("message.rfc2822", O_RDONLY); if (fd >= 0) { void * mem;
   struct stat stat_info; r = fstat(fd, &stat_info); if (r >= 0) { mem =
   mmap(NULL, stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem !=
   MAP_FAILED) { size_t current_index; current_index = 0; r =
   mailimf_ignore_field_parse(mem, stat_info.st_size, &current_index); if
   (r == MAILIMF_NO_ERROR) { /* do the things */ status = EXIT_SUCCESS; }
   } munmap(mem, stat_info.st_size); } close(fd); } exit(status); }
   #include <libetpan/libetpan.h> int mailimf_mailbox_list_parse(char *
   message, size_t length, size_t * index, struct mailimf_mailbox_list **
   result); mailimf_mailbox_list_parse() parse a list of mailboxes in RFC
   2822 form. message this is a string containing the list of mailboxes.
   length this is the size of the given string. index index this is a
   pointer to the start of the list of mailboxes in the given string, (*
   index) is modified to point at the end of the parsed data. result the
   result of the parse operation is stored in (* result). (see ) return
   MAILIMF_NO_ERROR on success, MAILIMF_ERROR_XXX on error. #include
   <libetpan/libetpan.h> #include <sys/stat.h> #include <sys/mman.h> int
   main(int argc, char ** argv) { int fd; int r; status = EXIT_FAILURE;
   fd = open("message.rfc2822", O_RDONLY); if (fd >= 0) { void * mem;
   struct stat stat_info; r = fstat(fd, &stat_info); if (r >= 0) { mem =
   mmap(NULL, stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem !=
   MAP_FAILED) { struct mailimf_mailbox_list * mb_list; size_t
   current_index; current_index = 0; r = mailimf_mailbox_list_parse(mem,
   stat_info.st_size, &current_index, &mb_list); if (r ==
   MAILIMF_NO_ERROR) { display_mailbox_list(mb_list); /* do the things */
   status = EXIT_SUCCESS; mailimf_mailbox_list_free(mb_list); } }
   munmap(mem, stat_info.st_size); } close(fd); } exit(status); }
   #include <libetpan/libetpan.h> int mailimf_mailbox_parse(char *
   message, size_t length, size_t * index, struct mailimf_mailbox **
   result); mailimf_mailbox_parse parse a mailbox in RFC 2822 form.
   message this is a string containing the mailbox. length this is the
   size of the given string. index index this is a pointer to the start
   of the mailbox in the given string, (* index) is modified to point at
   the end of the parsed data. result the result of the parse operation
   is stored in (* result). (see ) return MAILIMF_NO_ERROR on success,
   MAILIMF_ERROR_XXX on error. #include <libetpan/libetpan.h> #include
   <sys/stat.h> #include <sys/mman.h> int main(int argc, char ** argv) {
   int fd; int r; status = EXIT_FAILURE; fd = open("message.rfc2822",
   O_RDONLY); if (fd >= 0) { void * mem; struct stat stat_info; r =
   fstat(fd, &stat_info); if (r >= 0) { mem = mmap(NULL,
   stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem != MAP_FAILED) {
   struct mailimf_mailbox_list * mb_list; size_t current_index;
   current_index = 0; r = mailimf_mailbox_parse(mem, stat_info.st_size,
   &current_index, &mb_list); if (r == MAILIMF_NO_ERROR) {
   display_mailbox_list(mb_list); /* do the things */ status =
   EXIT_SUCCESS; mailimf_mailbox_free(mb_list); } } munmap(mem,
   stat_info.st_size); } close(fd); } exit(status); } #include
   <libetpan/libetpan.h> int mailimf_message_parse(char * message, size_t
   length, size_t * index, struct mailimf_message ** result);
   mailimf_message_parse parse message (headers and body). message this
   is a string containing the message content. param length this is the
   size of the given string. param index this is a pointer to the start
   of the message in the given string, (* index) is modified to point at
   the end of the parsed data. param result the result of the parse
   operation is stored in (* result) (see ). #include
   <libetpan/libetpan.h> #include <sys/stat.h> #include <sys/mman.h> int
   main(int argc, char ** argv) { int fd; int r; status = EXIT_FAILURE;
   fd = open("message.rfc2822", O_RDONLY); if (fd >= 0) { void * mem;
   struct stat stat_info; r = fstat(fd, &stat_info); if (r >= 0) { mem =
   mmap(NULL, stat_info.st_size, PROT_READ, MAP_PRIVATE); if (mem !=
   MAP_FAILED) { struct mailimf_message * m; size_t current_index;
   current_index = 0; r = mailimf_message_parse(mem, stat_info.st_size,
   &current_index, &m); if (r == MAILIMF_NO_ERROR) { display_message(m);
   /* do the things */ status = EXIT_SUCCESS; mailimf_message_free(m); }
   } munmap(mem, stat_info.st_size); } close(fd); } exit(status); }
   #include <libetpan/libetpan.h> struct mailimf_mailbox_list *
   mailimf_mailbox_list_new_empty(); int mailimf_mailbox_list_add(struct
   mailimf_mailbox_list * mailbox_list, struct mailimf_mailbox * mb); int
   mailimf_mailbox_list_add_parse(struct mailimf_mailbox_list *
   mailbox_list, char * mb_str); int mailimf_mailbox_list_add_mb(struct
   mailimf_mailbox_list * mailbox_list, char * display_name, char *
   address); mailimf_mailbox_list_new_empty creates a new empty list of
   mailboxes. mailimf_mailbox_list_add adds a mailbox to the list of
   mailboxes. mailimf_mailbox_list_add_parse adds a mailbox given in form
   of a string to the list of mailboxes. mailimf_mailbox_list_add_mb adds
   a mailbox given in form of a couple : display name, mailbox address.
   mailbox_list is the list of mailboxes. mb is a mailbox (see ). mb_str
   is a mailbox given in the form of a string. display_name is the
   display name. address is the mailbox address. #include
   <libetpan/libetpan.h> int main(int argc, char ** argv) { struct
   mailimf_mailbox_list * mb_list; struct mailimf_mailbox * mb; mb_list =
   mailimf_mailbox_list_new_empty(); mb =
   mailimf_mailbox_new(strdup("DINH Viet Hoa"),
   strdup("dinh.viet.hoa@free.fr")); mailimf_mailbox_list_add(mb_list,
   mb); mailimf_mailbox_list_add_parse(mb_list, "foo bar <foo@bar.org>");
   mailimf_mailbox_list_add_mb(mb_list, strdup("bar foo"),
   strdup("bar@foo.com")); mailimf_mailbox_list_free(mb_list); } #include
   <libetpan/libetpan.h> struct mailimf_address_list *
   mailimf_address_list_new_empty(); int mailimf_address_list_add(struct
   mailimf_address_list * address_list, struct mailimf_address * addr);
   int mailimf_address_list_add_parse(struct mailimf_address_list *
   address_list, char * addr_str); int mailimf_address_list_add_mb(struct
   mailimf_address_list * address_list, char * display_name, char *
   address); mailimf_address_list_new_empty creates a new empty list of
   addresses. mailimf_address_list_add adds an address to the list of
   addresses. mailimf_address_list_add_parse adds an address given in
   form of a string to the list of addresses. mailimf_address_list_add_mb
   adds a mailbox given in form of a couple : display name, mailbox
   address. address_list is the list of mailboxes. addr is an address.
   (see ). addr_str is an address given in the form of a string.
   display_name is the display name. address is the mailbox address.
   #include <libetpan/libetpan.h> struct mailimf_fields *
   mailimf_fields_new_empty(void); struct mailimf_field *
   mailimf_field_new_custom(char * name, char * value); int
   mailimf_fields_add(struct mailimf_fields * fields, struct
   mailimf_field * field); int mailimf_fields_add_data(struct
   mailimf_fields * fields, struct mailimf_date_time * date, struct
   mailimf_mailbox_list * from, struct mailimf_mailbox * sender, struct
   mailimf_address_list * reply_to, struct mailimf_address_list * to,
   struct mailimf_address_list * cc, struct mailimf_address_list * bcc,
   char * msg_id, clist * in_reply_to, clist * references, char *
   subject); struct mailimf_fields *
   mailimf_fields_new_with_data_all(struct mailimf_date_time * date,
   struct mailimf_mailbox_list * from, struct mailimf_mailbox * sender,
   struct mailimf_address_list * reply_to, struct mailimf_address_list *
   to, struct mailimf_address_list * cc, struct mailimf_address_list *
   bcc, char * message_id, clist * in_reply_to, clist * references, char
   * subject); struct mailimf_fields *
   mailimf_fields_new_with_data(struct mailimf_mailbox_list * from,
   struct mailimf_mailbox * sender, struct mailimf_address_list *
   reply_to, struct mailimf_address_list * to, struct
   mailimf_address_list * cc, struct mailimf_address_list * bcc, clist *
   in_reply_to, clist * references, char * subject); char *
   mailimf_get_message_id(void); struct mailimf_date_time *
   mailimf_get_current_date(void); int
   mailimf_resent_fields_add_data(struct mailimf_fields * fields, struct
   mailimf_date_time * resent_date, struct mailimf_mailbox_list *
   resent_from, struct mailimf_mailbox * resent_sender, struct
   mailimf_address_list * resent_to, struct mailimf_address_list *
   resent_cc, struct mailimf_address_list * resent_bcc, char *
   resent_msg_id); struct mailimf_fields *
   mailimf_resent_fields_new_with_data_all(struct mailimf_date_time *
   resent_date, struct mailimf_mailbox_list * resent_from, struct
   mailimf_mailbox * resent_sender, struct mailimf_address_list *
   resent_to, struct mailimf_address_list * resent_cc, struct
   mailimf_address_list * resent_bcc, char * resent_msg_id); struct
   mailimf_fields * mailimf_resent_fields_new_with_data(struct
   mailimf_mailbox_list * from, struct mailimf_mailbox * resent_sender,
   struct mailimf_address_list * resent_to, struct mailimf_address_list *
   resent_cc, struct mailimf_address_list * resent_bcc); from is the
   parsed content of the From field (see ). sender is the parsed content
   of the Sender field (see ). reply_to is the parsed content of the
   Reply-To field (see ). to is the parsed content of the To field (see
   ). cc is the parsed content of the Cc field (see ). bcc is the parsed
   content of the Bcc field (see ). message_id is the parsed content of
   the Message-ID field (see ). in_reply_to is the parsed content of the
   In-Reply-To field (see ). references is the parsed content of the
   References field (see ). subject is the content of the Subject field
   (see ). resent_date is the parsed content of the Resent-Date field
   (see ). resent_from is the parsed content of the Resent-From field
   (see ). resent_sender is the parsed content of the Resent-Sender field
   (see ). resent_to is the parsed content of the Resent-To field (see ).
   resent_cc is the parsed content of the Resent-Cc field (see ).
   resent_bcc is the parsed content of the Resent-Bcc field (see ).
   resent_msg_id is the parsed content of the Resent-Message-ID field
   (see ). mailimf_fields_new_empty creates a new empty set of headers.
   mailimf_field_new_custom creates a new custom header.
   mailimf_fields_add adds a header to the set of headers.
   mailimf_fields_add_data adds some headers to the set of headers.
   mailimf_fields_new_with_data_all creates a set of headers with some
   headers (including Date and Message-ID). mailimf_fields_new_with_data
   creates a set of headers with some headers (Date and Message-ID will
   be generated). mailimf_get_message_id generates a Message-ID.
   mailimf_get_current_date generates a Date.
   mailimf_resent_fields_add_data adds some resent headers to the set of
   headers. mailimf_resent_fields_new_with_data_all creates a set of
   headers with some resent headers (including Resent-Date and
   Resent-Message-ID). mailimf_resent_fields_new_with_data creates a set
   of headers with some resent headers (Resent-Date and Resent-Message-ID
   will be generated) #include <libetpan/libetpan.h> int main(int argc,
   char ** argv) { struct mailimf_fields * fields; struct mailimf_field *
   field; struct mailimf_date_time * date; char * msg_id; struct
   mailimf_mailbox_list * from; struct mailimf_address_list * to; fields
   = mailimf_fields_new_empty(); field =
   mailimf_field_new_custom(strdup("X-Mailer"), strdup("my-mailer"));
   mailimf_fields_add(fields, field); from =
   mailimf_mailbox_list_new_empty(); mailimf_mailbox_list_add_mb(from,
   strdup("DINH Viet Hoa"), strdup("dinh.viet.hoa@free.fr"); date =
   mailimf_get_current_date(); msg_id = mailimf_get_message_id(); to =
   mailimf_address_list_new_empty(); mailimf_address_list_add_mb(to,
   strdup("FOO Bar"), strdup("foo@bar.org");
   mailimf_fields_add_data(fields, date, from, NULL, NULL, to, NULL,
   NULL, msg_id, NULL, NULL, strdup("hello")); /* do the things */
   mailimf_fields_free(fields); } #include <libetpan/libetpan.h> int
   main(int argc, char ** argv) { struct mailimf_fields * fields; struct
   mailimf_mailbox_list * from; struct mailimf_address_list * to; struct
   mailimf_date_time * date; char * msg_id; from =
   mailimf_mailbox_list_new_empty(); mailimf_mailbox_list_add_mb(from,
   strdup("DINH Viet Hoa"), strdup("dinh.viet.hoa@free.fr"); to =
   mailimf_address_list_new_empty(); mailimf_address_list_add_mb(to,
   strdup("FOO Bar"), strdup("foo@bar.org"); date =
   mailimf_get_current_date(); msg_id = mailimf_get_message_id(); fields
   = mailimf_fields_new_with_all_data(date, from, NULL, NULL, to, NULL,
   NULL, msg_id, NULL, NULL, strdup("hello")); /* do the things */
   mailimf_fields_free(fields); } #include <libetpan/libetpan.h> int
   main(int argc, char ** argv) { struct mailimf_fields * fields; struct
   mailimf_mailbox_list * from; struct mailimf_address_list * to; from =
   mailimf_mailbox_list_new_empty(); mailimf_mailbox_list_add_mb(from,
   strdup("DINH Viet Hoa"), strdup("dinh.viet.hoa@free.fr"); to =
   mailimf_address_list_new_empty(); mailimf_address_list_add_mb(to,
   strdup("FOO Bar"), strdup("foo@bar.org"); fields =
   mailimf_fields_new_with_data(from, NULL, NULL, to, NULL, NULL, NULL,
   NULL, strdup("hello")); /* do the things */
   mailimf_fields_free(fields); } #include <libetpan/libetpan.h> int
   mailimf_fields_write(FILE * f, int * col, struct mailimf_fields *
   fields); int mailimf_envelope_fields_write(FILE * f, int * col, struct
   mailimf_fields * fields); int mailimf_field_write(FILE * f, int * col,
   struct mailimf_field * field); col current column is given for
   wrapping purpose in (* col), the resulting columns will be returned..
   f is the file descriptor. It can be stdout for example. fields is the
   header fields (see ). field is a field (see ). mailimf_fields_write
   outputs the set of header fields. mailimf_envelope_fields_write
   outputs the set of header fields except the optional fields.
   mailimf_field_write outputs a header. int main(int argc, char ** argv)
   { struct mailimf_fields * fields; int col; /* look at the example in
   mailimf_fields to see how to build a mailimf_fields */ fields =
   build_imf_fields(); col = 0; mailimf_fields_write(stdout, &col,
   fields); mailimf_fields_free(fields); } int main(int argc, char **
   argv) { struct mailimf_fields * fields; int col; /* look at the
   example in mailimf_fields to see how to build a mailimf_fields */
   fields = build_imf_fields(); col = 0;
   mailimf_envelope_fields_write(stdout, &col, fields);
   mailimf_fields_free(fields); } int main(int argc, char ** argv) {
   struct mailimf_field * field; int col; field =
   mailimf_field_new_custom(strdup("X-Mailer"), strdup("my mailer")); col
   = 0; mailimf_field_write(stdout, &col, field);
   mailimf_field_free(field); }
