2536 lines
47 KiB
HTML
2536 lines
47 KiB
HTML
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
|
|
<HTML
|
|
><HEAD
|
|
><TITLE
|
|
>Parser functions</TITLE
|
|
><META
|
|
NAME="GENERATOR"
|
|
CONTENT="Modular DocBook HTML Stylesheet Version 1.79"><LINK
|
|
REL="HOME"
|
|
TITLE="libEtPan! API"
|
|
HREF="book1.htm"><LINK
|
|
REL="UP"
|
|
TITLE="MIME"
|
|
HREF="c1586.htm"><LINK
|
|
REL="PREVIOUS"
|
|
TITLE="Data types"
|
|
HREF="x1614.htm"><LINK
|
|
REL="NEXT"
|
|
TITLE="Rendering of MIME parts"
|
|
HREF="x2583.htm"></HEAD
|
|
><BODY
|
|
CLASS="SECT1"
|
|
BGCOLOR="#FFFFFF"
|
|
TEXT="#000000"
|
|
LINK="#0000FF"
|
|
VLINK="#840084"
|
|
ALINK="#0000FF"
|
|
><DIV
|
|
CLASS="NAVHEADER"
|
|
><TABLE
|
|
SUMMARY="Header navigation table"
|
|
WIDTH="100%"
|
|
BORDER="0"
|
|
CELLPADDING="0"
|
|
CELLSPACING="0"
|
|
><TR
|
|
><TH
|
|
COLSPAN="3"
|
|
ALIGN="center"
|
|
>libEtPan! API</TH
|
|
></TR
|
|
><TR
|
|
><TD
|
|
WIDTH="10%"
|
|
ALIGN="left"
|
|
VALIGN="bottom"
|
|
><A
|
|
HREF="x1614.htm"
|
|
ACCESSKEY="P"
|
|
>Prev</A
|
|
></TD
|
|
><TD
|
|
WIDTH="80%"
|
|
ALIGN="center"
|
|
VALIGN="bottom"
|
|
>Chapter 4. MIME</TD
|
|
><TD
|
|
WIDTH="10%"
|
|
ALIGN="right"
|
|
VALIGN="bottom"
|
|
><A
|
|
HREF="x2583.htm"
|
|
ACCESSKEY="N"
|
|
>Next</A
|
|
></TD
|
|
></TR
|
|
></TABLE
|
|
><HR
|
|
ALIGN="LEFT"
|
|
WIDTH="100%"></DIV
|
|
><DIV
|
|
CLASS="SECT1"
|
|
><H1
|
|
CLASS="SECT1"
|
|
><A
|
|
NAME="AEN2180"
|
|
>Parser functions</A
|
|
></H1
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-CONTENT-PARSE"
|
|
>mailmime_content_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_content_parse(const char * message, size_t length,
|
|
size_t * index,
|
|
struct mailmime_content ** result);
|
|
</PRE
|
|
><P
|
|
> This function will parse the content of a
|
|
<B
|
|
CLASS="COMMAND"
|
|
>Content-Type</B
|
|
> header field.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME content type.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-CONTENT"
|
|
>the Section called <I
|
|
>mailmime_content - MIME content type (Content-Type)</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2203"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-16. Parsing MIME content type</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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) {
|
|
clistiter * cur;
|
|
|
|
for(cur = clist_begin(f->fld_list) ; cur != NULL ; cur =
|
|
clist_next(cur)) {
|
|
struct mailmime_field * mime_field;
|
|
struct mailimf_field * field;
|
|
|
|
field = clist_content(cur);
|
|
|
|
if (field->fld_type == MAILIMF_FIELD_OPTIONAL_FIELD) {
|
|
if (strcasecmp(field->fld_data.fld_optional_field->fld_name,
|
|
"Content-Type") == 0) {
|
|
struct mailmime_content * content_type;
|
|
size_t current_index;
|
|
|
|
current_index = 0;
|
|
r = mailmime_content_parse(field->fld_data.fld_optional_field->fld_value,
|
|
strlen(field->fld_data.fld_optional_field->fld_value),
|
|
&current_index, &content_type);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
display_mime_content(content_type);
|
|
/* do the things */
|
|
status = EXIT_SUCCESS;
|
|
mailmime_content_free(content_type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
mailimf_fields_free(f);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-DESCRIPTION-PARSE"
|
|
>mailmime_description_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include >libetpan/libetpan.h<
|
|
|
|
int mailmime_description_parse(const char * message, size_t length,
|
|
size_t * index,
|
|
char ** result);
|
|
</PRE
|
|
><P
|
|
> This will parse the content of
|
|
<B
|
|
CLASS="COMMAND"
|
|
>Content-Description</B
|
|
> MIME header field.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME content description.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>.
|
|
The result string must be freed with
|
|
<B
|
|
CLASS="COMMAND"
|
|
>free()</B
|
|
>.
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2227"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-17. Parsing MIME description</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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) {
|
|
clistiter * cur;
|
|
|
|
for(cur = clist_begin(f->fld_list) ; cur != NULL ; cur =
|
|
clist_next(cur)) {
|
|
struct mailmime_field * mime_field;
|
|
struct mailimf_field * field;
|
|
|
|
field = clist_content(cur);
|
|
|
|
if (field->fld_type == MAILIMF_FIELD_OPTIONAL_FIELD) {
|
|
if (strcasecmp(field->fld_data.fld_optional_field->fld_name,
|
|
"Content-Description") == 0) {
|
|
char * description;
|
|
size_t current_index;
|
|
|
|
current_index = 0;
|
|
r = mailmime_description_parse(field->fld_data.fld_optional_field->fld_value,
|
|
strlen(field->fld_data.fld_optional_field->fld_value),
|
|
&current_index, &description);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
printf("%s\n", description);
|
|
/* do the things */
|
|
status = EXIT_SUCCESS;
|
|
free(description);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
mailimf_fields_free(f);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-ENCODING-PARSE"
|
|
>mailmime_encoding_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include >libetpan/libetpan.h<
|
|
|
|
int mailmime_encoding_parse(const char * message, size_t length,
|
|
size_t * index,
|
|
struct mailmime_mechanism ** result);
|
|
</PRE
|
|
><P
|
|
> This function will parse the content of
|
|
<B
|
|
CLASS="COMMAND"
|
|
>Content-Transfer-Encoding</B
|
|
> header field.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME encoding mechanism.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-MECHANISM"
|
|
>the Section called <I
|
|
>mailmime_mechanism - MIME transfer encoding mechanism (Content-Transfer-Encoding)</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2251"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-18. parsing MIME encoding mechanism</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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) {
|
|
clistiter * cur;
|
|
|
|
for(cur = clist_begin(f->fld_list) ; cur != NULL ; cur =
|
|
clist_next(cur)) {
|
|
struct mailmime_field * mime_field;
|
|
struct mailimf_field * field;
|
|
|
|
field = clist_content(cur);
|
|
|
|
if (field->fld_type == MAILIMF_FIELD_OPTIONAL_FIELD) {
|
|
if (strcasecmp(field->fld_data.fld_optional_field->fld_name,
|
|
"Content-Transfer-Encoding") == 0) {
|
|
struct mailmime_content * encoding;
|
|
size_t current_index;
|
|
|
|
current_index = 0;
|
|
r = mailmime_encoding_parse(field->fld_data.fld_optional_field->fld_value,
|
|
strlen(field->fld_data.fld_optional_field->fld_value),
|
|
&current_index, &encoding);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
display_mime_mechanism(encoding);
|
|
/* do the things */
|
|
status = EXIT_SUCCESS;
|
|
mailmime_mechanism_free(encoding);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
mailimf_fields_free(f);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-FIELD-PARSE"
|
|
>mailmime_field_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int
|
|
mailmime_field_parse(struct mailimf_optional_field * field,
|
|
struct mailmime_field ** result);
|
|
</PRE
|
|
><P
|
|
> This function will parse a MIME header field.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>field</B
|
|
> is a non-parsed field
|
|
(see <A
|
|
HREF="x425.htm#MAILIMF-OPTIONAL-FIELD"
|
|
>the Section called <I
|
|
>mailimf_optional_field - non-standard header</I
|
|
> in Chapter 3</A
|
|
>).
|
|
</P
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-FIELD"
|
|
>the Section called <I
|
|
>mailmime_field - MIME header field</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2267"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-19. parsing MIME header field</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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) {
|
|
clistiter * cur;
|
|
|
|
for(cur = clist_begin(f->fld_list) ; cur != NULL ; cur =
|
|
clist_next(cur)) {
|
|
struct mailmime_field * mime_field;
|
|
struct mailimf_field * field;
|
|
|
|
field = clist_content(cur);
|
|
|
|
if (field->fld_type == MAILIMF_FIELD_OPTIONAL_FIELD) {
|
|
r = mailmime_field_parse(field->fld_data.fld_optional_field,
|
|
&mime_fields);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
display_mime_field(mime_field);
|
|
mailmime_field_free(mime_field);
|
|
status = EXIT_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
|
|
mailimf_fields_free(f);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-ID-PARSE"
|
|
>mailmime_id_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include >libetpan/libetpan.h<
|
|
|
|
int mailmime_id_parse(const char * message, size_t length,
|
|
size_t * index, char ** result);
|
|
</PRE
|
|
><P
|
|
> This will parse the content of
|
|
<B
|
|
CLASS="COMMAND"
|
|
>Content-ID</B
|
|
> MIME header field.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME content identifier.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>.
|
|
The result string must be freed with
|
|
<B
|
|
CLASS="COMMAND"
|
|
>free()</B
|
|
>.
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2291"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-20. Parsing MIME content identifier</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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) {
|
|
clistiter * cur;
|
|
|
|
for(cur = clist_begin(f->fld_list) ; cur != NULL ; cur =
|
|
clist_next(cur)) {
|
|
struct mailmime_field * mime_field;
|
|
struct mailimf_field * field;
|
|
|
|
field = clist_content(cur);
|
|
|
|
if (field->fld_type == MAILIMF_FIELD_OPTIONAL_FIELD) {
|
|
if (strcasecmp(field->fld_data.fld_optional_field->fld_name,
|
|
"Content-ID") == 0) {
|
|
char * id;
|
|
size_t current_index;
|
|
|
|
current_index = 0;
|
|
r = mailmime_id_parse(field->fld_data.fld_optional_field->fld_value,
|
|
strlen(field->fld_data.fld_optional_field->fld_value),
|
|
&current_index, &id);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
printf("%s\n", id);
|
|
/* do the things */
|
|
status = EXIT_SUCCESS;
|
|
free(id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
mailimf_fields_free(f);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-FIELDS-PARSE"
|
|
>mailmime_fields_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int
|
|
mailmime_fields_parse(struct mailimf_fields * fields,
|
|
struct mailmime_fields ** result);
|
|
</PRE
|
|
><P
|
|
> This function will parse a MIME header fields.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>fields</B
|
|
> is a list of RFC 2822 fields
|
|
(see <A
|
|
HREF="x425.htm#MAILIMF-FIELDS"
|
|
>the Section called <I
|
|
>mailimf_fields - list of header fields</I
|
|
> in Chapter 3</A
|
|
>).
|
|
</P
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-FIELDS"
|
|
>the Section called <I
|
|
>mailmime_fields - header fields</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2307"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-21. parsing MIME header fields</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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) {
|
|
struct mailmime_fields * mime_fields;
|
|
|
|
r = mailmime_fields_parse(f, &mime_fields);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
display_mime_fields(mime_fields);
|
|
mailmime_fields_free(mime_fields);
|
|
status = EXIT_SUCCESS;
|
|
}
|
|
|
|
mailimf_fields_free(f);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-VERSION-PARSE"
|
|
>mailmime_version_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_version_parse(const char * message, size_t length,
|
|
size_t * index,
|
|
uint32_t * result);
|
|
</PRE
|
|
><P
|
|
> This will parse the content of
|
|
<B
|
|
CLASS="COMMAND"
|
|
>MIME-Version</B
|
|
> MIME header field.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME version.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-FIELD"
|
|
>the Section called <I
|
|
>mailmime_field - MIME header field</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2331"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-22. parsing MIME version</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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) {
|
|
clistiter * cur;
|
|
|
|
for(cur = clist_begin(f->fld_list) ; cur != NULL ; cur =
|
|
clist_next(cur)) {
|
|
struct mailmime_field * mime_field;
|
|
struct mailimf_field * field;
|
|
|
|
field = clist_content(cur);
|
|
|
|
if (field->fld_type == MAILIMF_FIELD_OPTIONAL_FIELD) {
|
|
if (strcasecmp(field->fld_data.fld_optional_field->fld_name,
|
|
"MIME-Version") == 0) {
|
|
uint32_t version;
|
|
size_t current_index;
|
|
|
|
current_index = 0;
|
|
r = mailmime_version_parse(field->fld_data.fld_optional_field->fld_value,
|
|
strlen(field->fld_data.fld_optional_field->fld_value),
|
|
&current_index, &version);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
printf("%i.%i\n", version >> 16, version & 0xFFFF);
|
|
/* do the things */
|
|
status = EXIT_SUCCESS;
|
|
free(description);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
mailimf_fields_free(f);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-PARAMETER-PARSE"
|
|
>mailmime_parameter_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_parameter_parse(const char * message, size_t length,
|
|
size_t * index,
|
|
struct mailmime_parameter ** result);
|
|
</PRE
|
|
><P
|
|
> This will parse a MIME parameter (parameter of
|
|
<B
|
|
CLASS="COMMAND"
|
|
>Content-Type</B
|
|
> or parameter of
|
|
<B
|
|
CLASS="COMMAND"
|
|
>Content-Disposition</B
|
|
>).
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME parameter.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-PARAMETER"
|
|
>the Section called <I
|
|
>mailmime_parameter - MIME type parameter</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2356"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-23. parsing a MIME parameter</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
#define PARAM_STR "foo=bar"
|
|
|
|
int main(int argc, char ** argv)
|
|
{
|
|
int fd;
|
|
int r;
|
|
size_t current_index;
|
|
struct mailmime_parameter * param;
|
|
int status;
|
|
|
|
status = EXIT_FAILURE;
|
|
|
|
current_index = 0;
|
|
r = mailmime_parameter_parse(PARAM_STR, sizeof(PARAM_STR) - 1,
|
|
&current_index, &param);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
display_mime_parameter(param);
|
|
/* do the things */
|
|
mailmime_parameter_free(param);
|
|
status = EXIT_SUCCESS;
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-LANGUAGE-PARSE"
|
|
>mailmime_language_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_language_parse(const char * message, size_t length,
|
|
size_t * index,
|
|
struct mailmime_language ** result);
|
|
</PRE
|
|
><P
|
|
> This function will parse the content of a
|
|
<B
|
|
CLASS="COMMAND"
|
|
>Content-Language</B
|
|
> header.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME content language.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-LANGUAGE"
|
|
>the Section called <I
|
|
>mailmime_language - Language of MIME part</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2380"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-24. Parsing the MIME content langage</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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) {
|
|
clistiter * cur;
|
|
|
|
for(cur = clist_begin(f->fld_list) ; cur != NULL ; cur =
|
|
clist_next(cur)) {
|
|
struct mailmime_field * mime_field;
|
|
struct mailimf_field * field;
|
|
|
|
field = clist_content(cur);
|
|
|
|
if (field->fld_type == MAILIMF_FIELD_OPTIONAL_FIELD) {
|
|
if (strcasecmp(field->fld_data.fld_optional_field->fld_name,
|
|
"Content-Language") == 0) {
|
|
struct mailmime_language * lang;
|
|
size_t current_index;
|
|
|
|
current_index = 0;
|
|
r = mailmime_id_parse(field->fld_data.fld_optional_field->fld_value,
|
|
strlen(field->fld_data.fld_optional_field->fld_value),
|
|
&current_index, &lang);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
display_mime_language(lang);
|
|
/* do the things */
|
|
status = EXIT_SUCCESS;
|
|
free(id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
mailimf_fields_free(f);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-DISPOSITION-PARSE"
|
|
>mailmime_disposition_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_disposition_parse(const char * message, size_t length,
|
|
size_t * index,
|
|
struct mailmime_disposition ** result);
|
|
</PRE
|
|
><P
|
|
> This function will parse the content of a
|
|
<B
|
|
CLASS="COMMAND"
|
|
>Content-Disposition</B
|
|
> MIME header field.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME content disposition.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-DISPOSITION"
|
|
>the Section called <I
|
|
>mailmime_disposition - MIME disposition information (Content-Disposition)</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2404"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-25. Parsing the MIME content disposition</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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) {
|
|
clistiter * cur;
|
|
|
|
for(cur = clist_begin(f->fld_list) ; cur != NULL ; cur =
|
|
clist_next(cur)) {
|
|
struct mailmime_field * mime_field;
|
|
struct mailimf_field * field;
|
|
|
|
field = clist_content(cur);
|
|
|
|
if (field->fld_type == MAILIMF_FIELD_OPTIONAL_FIELD) {
|
|
if (strcasecmp(field->fld_data.fld_optional_field->fld_name,
|
|
"Content-Disposition") == 0) {
|
|
struct mailmime_disposition * dsp;
|
|
size_t current_index;
|
|
|
|
current_index = 0;
|
|
r = mailmime_id_parse(field->fld_data.fld_optional_field->fld_value,
|
|
strlen(field->fld_data.fld_optional_field->fld_value),
|
|
&current_index, &dsp);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
display_mime_disposition(dsp);
|
|
/* do the things */
|
|
status = EXIT_SUCCESS;
|
|
free(id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
mailimf_fields_free(f);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-DISPOSITION-TYPE-PARSE"
|
|
>mailmime_disposition_type_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int
|
|
mailmime_disposition_type_parse(const char * message, size_t length,
|
|
size_t * index,
|
|
struct mailmime_disposition_type **
|
|
result);
|
|
</PRE
|
|
><P
|
|
> This function will parse the type of MIME content
|
|
disposition.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME content disposition type.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-DISPOSITION-TYPE"
|
|
>the Section called <I
|
|
>mailmime_disposition_type - Type of MIME disposition</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2427"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-26. parsing a MIME content disposition type</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
#define DSP_TYPE_STR "attachment"
|
|
|
|
int main(int argc, char ** argv)
|
|
{
|
|
int fd;
|
|
int r;
|
|
size_t current_index;
|
|
struct mailmime_disposition_type * dsp_type;
|
|
int status;
|
|
|
|
status = EXIT_FAILURE;
|
|
|
|
current_index = 0;
|
|
r = mailmime_disposition_type_parse(DSP_TYPE_STR, sizeof(DSP_TYPE_STR) - 1,
|
|
&current_index, &dsp_type);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
display_mime_disposition_type(dsp_type);
|
|
/* do the things */
|
|
mailmime_disposition_type_free(dsp_type);
|
|
status = EXIT_SUCCESS;
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-ENCODED-PHRASE-PARSE"
|
|
>mailmime_encoded_phrase_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_encoded_phrase_parse(const char * default_fromcode,
|
|
const char * message, size_t length,
|
|
size_t * index, const char * tocode,
|
|
char ** result);
|
|
</PRE
|
|
><P
|
|
> This function will decode a MIME encoded header string,
|
|
encoded with RFC 2047.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>default_fromcode</B
|
|
> is the default
|
|
code to use for parts of string that are not marked
|
|
with charset.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is the string to decode.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>tocode</B
|
|
> is the destination charset
|
|
for decoding.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>.
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2455"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-27. decoding a MIME encoded header string</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
#define TEST_STRING "=?iso-8859-1?ab?= =?iso-8859-15?cd?="
|
|
|
|
int main(int argc, char ** argv)
|
|
{
|
|
size_t cur_token;
|
|
char * decoded_subject;
|
|
|
|
cur_token = 0;
|
|
mailmime_encoded_phrase_parse("iso-8859-1",
|
|
TEST_STRING, sizeof(TEST_STRING),
|
|
&cur_token, "iso-8859-1", &decoded_subject);
|
|
|
|
printf("%s\n", decoded_subject);
|
|
|
|
/* do the things */
|
|
|
|
free(decoded_subject);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-PARSE"
|
|
>mailmime_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_parse(const char * message, size_t length,
|
|
size_t * index, struct mailmime ** result);
|
|
</PRE
|
|
><P
|
|
> This will parse a MIME message.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string containing
|
|
the MIME message.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME"
|
|
>the Section called <I
|
|
>mailmime - MIME part</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2478"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-28. parsing a MIME message</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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 mailmime * mime;
|
|
size_t current_index;
|
|
|
|
current_index = 0;
|
|
r = mailmime_parse(mem, stat_info.st_size,
|
|
&current_index, &mime);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
display_mime(mime);
|
|
/* do the things */
|
|
status = EXIT_SUCCESS;
|
|
mailmime_free(mime);
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-BASE64-BODY-PARSE"
|
|
>mailmime_base64_body_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_base64_body_parse(const char * message, size_t length,
|
|
size_t * index, char ** result,
|
|
size_t * result_len);
|
|
</PRE
|
|
><P
|
|
> This function will parse a body part encoded using base64.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string encoded using
|
|
base64.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
The result must be freed with
|
|
<B
|
|
CLASS="COMMAND"
|
|
>mmap_string_unref()</B
|
|
>.
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2501"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-29. Parsing a base64 encoded part</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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;
|
|
char * result;
|
|
size_t result_len;
|
|
|
|
current_index = 0;
|
|
r = mailmime_base64_body_parse(mem, stat_info.st_size,
|
|
&current_index, &result, &result_len);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
|
|
/* do the things */
|
|
|
|
mailmime_decoded_part_free(mem);
|
|
status = EXIT_SUCCESS;
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-QUOTED-PRINTABLE-BODY-PARSE"
|
|
>mailmime_quoted_printable_body_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_quoted_printable_body_parse(const char * message, size_t length,
|
|
size_t * index, char ** result,
|
|
size_t * result_len, int in_header);
|
|
</PRE
|
|
><P
|
|
> This function will parse a body part encoded using quoted
|
|
printable.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string encoded using
|
|
quoted printable.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
The result must be freed with
|
|
<B
|
|
CLASS="COMMAND"
|
|
>mmap_string_unref()</B
|
|
>.
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2524"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-30. Parsing a quoted printable encoded part</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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;
|
|
char * result;
|
|
size_t result_len;
|
|
|
|
current_index = 0;
|
|
r = mailmime_quoted_printable_body_parse(mem, stat_info.st_size,
|
|
&current_index, &result, &result_len);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
|
|
/* do the things */
|
|
|
|
mailmime_decoded_part_free(mem);
|
|
status = EXIT_SUCCESS;
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-BINARY-BODY-PARSE"
|
|
>mailmime_binary_body_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
int mailmime_binary_body_parse(const char * message, size_t length,
|
|
size_t * index, char ** result,
|
|
size_t * result_len);
|
|
</PRE
|
|
><P
|
|
> This function will parse a body part encoded using binary
|
|
(no encoding).
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string encoded using
|
|
binary.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
The result must be freed with
|
|
<B
|
|
CLASS="COMMAND"
|
|
>mmap_string_unref()</B
|
|
>.
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2547"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-31. Parsing a binary encoded part</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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;
|
|
char * result;
|
|
size_t result_len;
|
|
|
|
current_index = 0;
|
|
r = mailmime_binary_body_parse(mem, stat_info.st_size,
|
|
&current_index, &result, &result_len);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
|
|
/* do the things */
|
|
|
|
mailmime_decoded_part_free(mem);
|
|
status = EXIT_SUCCESS;
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="SECT2"
|
|
><H2
|
|
CLASS="SECT2"
|
|
><A
|
|
NAME="MAILMIME-PART-PARSE"
|
|
>mailmime_part_parse</A
|
|
></H2
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#include <libetpan/libetpan.h>
|
|
|
|
enum {
|
|
MAILMIME_MECHANISM_ERROR,
|
|
MAILMIME_MECHANISM_7BIT,
|
|
MAILMIME_MECHANISM_8BIT,
|
|
MAILMIME_MECHANISM_BINARY,
|
|
MAILMIME_MECHANISM_QUOTED_PRINTABLE,
|
|
MAILMIME_MECHANISM_BASE64,
|
|
MAILMIME_MECHANISM_TOKEN
|
|
};
|
|
|
|
int mailmime_part_parse(const char * message, size_t length,
|
|
size_t * index,
|
|
int encoding, char ** result, size_t * result_len);
|
|
</PRE
|
|
><P
|
|
> This function will parse a body part encoded using a
|
|
given MIME encoding mechanism.
|
|
</P
|
|
><P
|
|
></P
|
|
><UL
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>message</B
|
|
> is a string encoded using
|
|
binary.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>length</B
|
|
> is the size of the given
|
|
string.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>index</B
|
|
> is a pointer to the start of
|
|
the address in the given string, <B
|
|
CLASS="COMMAND"
|
|
>(*
|
|
index)</B
|
|
> is modified to point at the end of the
|
|
parsed data.
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>encoding</B
|
|
> is a MIME encoding
|
|
mechanism. The value can be
|
|
<B
|
|
CLASS="COMMAND"
|
|
>MAILMIME_MECHANISM_7BIT</B
|
|
>,
|
|
<B
|
|
CLASS="COMMAND"
|
|
>MAILMIME_MECHANISM_8BIT</B
|
|
>,
|
|
<B
|
|
CLASS="COMMAND"
|
|
>MAILMIME_MECHANISM_BINARY</B
|
|
>,
|
|
<B
|
|
CLASS="COMMAND"
|
|
>MAILMIME_MECHANISM_QUOTED_PRINTABLE</B
|
|
>,
|
|
<B
|
|
CLASS="COMMAND"
|
|
>MAILMIME_MECHANISM_BASE64</B
|
|
> or
|
|
<B
|
|
CLASS="COMMAND"
|
|
>MAILMIME_MECHANISM_TOKEN</B
|
|
>
|
|
(see <A
|
|
HREF="x1614.htm#MAILMIME-MECHANISM"
|
|
>the Section called <I
|
|
>mailmime_mechanism - MIME transfer encoding mechanism (Content-Transfer-Encoding)</I
|
|
></A
|
|
>).
|
|
</P
|
|
></LI
|
|
><LI
|
|
><P
|
|
> <B
|
|
CLASS="COMMAND"
|
|
>result</B
|
|
>. The result of the parse
|
|
operation is stored in <B
|
|
CLASS="COMMAND"
|
|
>(* result)</B
|
|
>
|
|
The result must be freed with
|
|
<B
|
|
CLASS="COMMAND"
|
|
>mmap_string_unref()</B
|
|
>.
|
|
</P
|
|
></LI
|
|
></UL
|
|
><DIV
|
|
CLASS="EXAMPLE"
|
|
><A
|
|
NAME="AEN2580"
|
|
></A
|
|
><P
|
|
><B
|
|
>Example 4-32. Parsing a MIME encoded part</B
|
|
></P
|
|
><PRE
|
|
CLASS="PROGRAMLISTING"
|
|
>#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;
|
|
char * result;
|
|
size_t result_len;
|
|
|
|
current_index = 0;
|
|
r = mailmime_part_parse(mem, stat_info.st_size, &current_index,
|
|
MAILMIME_MECHANISM_QUOTED_PRINTABLE, &result, &result_len);
|
|
if (r == MAILIMF_NO_ERROR) {
|
|
|
|
/* do the things */
|
|
|
|
mailmime_decoded_part_free(mem);
|
|
status = EXIT_SUCCESS;
|
|
}
|
|
}
|
|
munmap(mem, stat_info.st_size);
|
|
}
|
|
|
|
close(fd);
|
|
}
|
|
|
|
exit(status);
|
|
}
|
|
</PRE
|
|
></DIV
|
|
></DIV
|
|
></DIV
|
|
><DIV
|
|
CLASS="NAVFOOTER"
|
|
><HR
|
|
ALIGN="LEFT"
|
|
WIDTH="100%"><TABLE
|
|
SUMMARY="Footer navigation table"
|
|
WIDTH="100%"
|
|
BORDER="0"
|
|
CELLPADDING="0"
|
|
CELLSPACING="0"
|
|
><TR
|
|
><TD
|
|
WIDTH="33%"
|
|
ALIGN="left"
|
|
VALIGN="top"
|
|
><A
|
|
HREF="x1614.htm"
|
|
ACCESSKEY="P"
|
|
>Prev</A
|
|
></TD
|
|
><TD
|
|
WIDTH="34%"
|
|
ALIGN="center"
|
|
VALIGN="top"
|
|
><A
|
|
HREF="book1.htm"
|
|
ACCESSKEY="H"
|
|
>Home</A
|
|
></TD
|
|
><TD
|
|
WIDTH="33%"
|
|
ALIGN="right"
|
|
VALIGN="top"
|
|
><A
|
|
HREF="x2583.htm"
|
|
ACCESSKEY="N"
|
|
>Next</A
|
|
></TD
|
|
></TR
|
|
><TR
|
|
><TD
|
|
WIDTH="33%"
|
|
ALIGN="left"
|
|
VALIGN="top"
|
|
>Data types</TD
|
|
><TD
|
|
WIDTH="34%"
|
|
ALIGN="center"
|
|
VALIGN="top"
|
|
><A
|
|
HREF="c1586.htm"
|
|
ACCESSKEY="U"
|
|
>Up</A
|
|
></TD
|
|
><TD
|
|
WIDTH="33%"
|
|
ALIGN="right"
|
|
VALIGN="top"
|
|
>Rendering of MIME parts</TD
|
|
></TR
|
|
></TABLE
|
|
></DIV
|
|
></BODY
|
|
></HTML
|
|
> |