mime.c File Reference

#include <string.h>
#include <limits.h>
#include <ctype.h>
#include "gwlib/gwlib.h"
#include "gwlib/mime.h"

Go to the source code of this file.

Data Structures
struct	MIMEEntity

Functions
MIMEEntity *	mime_entity_create (void)
static void	mime_entity_destroy_item (void *e)
void	mime_entity_destroy (MIMEEntity *e)
static int	read_mime_headers (ParseContext *context, List *headers)
static void	fix_boundary_element (List *headers, Octstr **boundary_elem)
Octstr *	mime_entity_to_octstr (MIMEEntity *m)
static Octstr *	get_start_param (Octstr *content_type)
static int	cid_matches (List *headers, Octstr *start)
static MIMEEntity *	mime_something_to_entity (Octstr *mime, List *headers)
MIMEEntity *	mime_octstr_to_entity (Octstr *mime)
MIMEEntity *	mime_http_to_entity (List *headers, Octstr *body)
List *	mime_entity_headers (MIMEEntity *m)
Octstr *	mime_entity_body (MIMEEntity *m)
MIMEEntity *	mime_entity_duplicate (MIMEEntity *e)
void	mime_replace_headers (MIMEEntity *e, List *headers)
int	mime_entity_num_parts (MIMEEntity *e)
void	mime_entity_add_part (MIMEEntity *e, MIMEEntity *part)
MIMEEntity *	mime_entity_get_part (MIMEEntity *e, int i)
void	mime_entity_remove_part (MIMEEntity *e, int i)
void	mime_entity_replace_part (MIMEEntity *e, int i, MIMEEntity *newpart)
void	mime_entity_set_body (MIMEEntity *e, Octstr *body)
MIMEEntity *	mime_multipart_start_elem (MIMEEntity *e)
static void	mime_entity_dump_real (MIMEEntity *m, unsigned int level)
void	mime_entity_dump (MIMEEntity *m)

Function Documentation

cid_matches()

static int cid_matches ( List *  headers, Octstr *  start  )

static

Definition at line 300 of file mime.c.

References MIMEEntity::headers, http_header_value(), octstr_compare(), octstr_destroy(), octstr_get_cstr, octstr_imm(), octstr_len(), octstr_str_ncompare(), and start.

Referenced by mime_multipart_start_elem(), and mime_something_to_entity().

{
     Octstr *cid = http_header_value(headers, octstr_imm("Content-ID"));
     char *cid_str;
     int cid_len;
     int ret;

     if (cid == NULL) 
         return 0;
     
     /* First, strip the <> if any. XXX some mime coders produce such messiness! */
     cid_str = octstr_get_cstr(cid);
     cid_len = octstr_len(cid);
     if (cid_str[0] == '<') {
         cid_str+=1;
     cid_len-=2;
     }
     if (start != NULL && cid != NULL  && 
     (octstr_compare(start, cid) == 0 || octstr_str_ncompare(start, cid_str, cid_len) == 0)) 
      ret = 1;
     else 
      ret = 0;

     octstr_destroy(cid);
     return ret;
}

fix_boundary_element()

static void fix_boundary_element ( List *  headers, Octstr **  boundary_elem  )

static

Definition at line 163 of file mime.c.

References boundary, MIMEEntity::headers, http_get_header_parameter(), http_header_add(), http_header_remove_all(), http_header_value(), octstr_create, octstr_delete(), octstr_destroy(), octstr_format(), octstr_format_append(), octstr_get_char(), octstr_get_cstr, octstr_imm(), and octstr_len().

Referenced by mime_entity_headers(), and mime_entity_to_octstr().

{
    Octstr *value, *boundary;
    long len;
    
     /* 
      * Check if we have an boundary parameter already in the 
      * Content-Type header. If no, add one, otherwise parse which one 
      * we should use.
      * XXX this can be abstracted as function in gwlib/http.[ch].
      */
     value = http_header_value(headers, octstr_imm("Content-Type"));
     boundary = value ? http_get_header_parameter(value, octstr_imm("boundary")) : NULL;

     if (value == NULL) {
        /* we got here because it is multi-part, so... */
        value = octstr_create("multipart/mixed");
        http_header_add(headers, "Content-Type", "multipart/mixed");
     }
     if (boundary == NULL) {
        Octstr *v;
        boundary = octstr_format("_boundary_%d_%ld_%c_%c_bd%d", 
                                 random(), (long) time(NULL), 'A' + (random() % 26), 
                                 'a' + (random() % 26), random());
           
        octstr_format_append(value, "; boundary=%S", boundary);
      
        http_header_remove_all(headers, "Content-Type");
        http_header_add(headers, "Content-Type", octstr_get_cstr(value));
        if ((v = http_header_value(headers, octstr_imm("MIME-Version"))) == NULL)
            http_header_add(headers, "MIME-Version", "1.0");
        else
            octstr_destroy(v);
    } 
    else if ((len = octstr_len(boundary)) > 0 &&
             octstr_get_char(boundary, 0) == '"' && 
             octstr_get_char(boundary, len - 1) == '"') {
        octstr_delete(boundary, 0, 1);
        octstr_delete(boundary, len - 2, 1);      
    }

    octstr_destroy(value);
    if (boundary_elem)
        *boundary_elem = boundary;
    else
        octstr_destroy(boundary);
}

get_start_param()

static Octstr* get_start_param ( Octstr *  content_type )

static

Definition at line 282 of file mime.c.

References content_type, http_get_header_parameter(), octstr_delete(), octstr_get_char(), octstr_imm(), octstr_len(), and start.

Referenced by mime_multipart_start_elem(), and mime_something_to_entity().

{
     Octstr *start;
     int len;

     if (!content_type)
      return NULL;

     start = http_get_header_parameter(content_type, octstr_imm("start"));
     if (start && (len = octstr_len(start)) > 0 &&
     octstr_get_char(start, 0) == '"' && octstr_get_char(start, len-1) == '"') {
      octstr_delete(start, 0, 1);
      octstr_delete(start, len-2, 1);
     }
     
     return start;  
}

mime_entity_add_part()

void mime_entity_add_part	(	MIMEEntity *	e,
		MIMEEntity *	part
	)

Definition at line 560 of file mime.c.

References gw_assert(), gwlist_append(), mime_entity_duplicate(), and MIMEEntity::multiparts.

{
     gw_assert(e != NULL);
     gw_assert(part != NULL);
     
     gwlist_append(e->multiparts, mime_entity_duplicate(part));
}

mime_entity_body()

Octstr* mime_entity_body

(

MIMEEntity *

m

)

Definition at line 485 of file mime.c.

References MIMEEntity::body, debug(), gw_assert(), MIMEEntity::headers, mime_entity_create(), mime_entity_destroy(), mime_entity_num_parts(), mime_entity_to_octstr(), octstr_destroy(), octstr_dump, octstr_duplicate, parse_context_create(), parse_context_destroy(), parse_get_rest(), and read_mime_headers().

{
    Octstr *os, *body;
    ParseContext *context;
    MIMEEntity *e;

    gw_assert(m != NULL && m->headers != NULL);

    /* For non-multipart, return body directly. */
    if (mime_entity_num_parts(m) == 0)
     return octstr_duplicate(m->body);

    os = mime_entity_to_octstr(m);
    context = parse_context_create(os);
    e = mime_entity_create();

    /* parse the headers up to the body */
    if ((read_mime_headers(context, e->headers) != 0) || e->headers == NULL) {
        debug("mime.parse",0,"Failed to read MIME headers in Octstr block:");
        octstr_dump(os, 0);
        mime_entity_destroy(e);
        parse_context_destroy(context);
        return NULL;
    }

    /* the rest is the body */
    body = parse_get_rest(context);

    octstr_destroy(os);
    mime_entity_destroy(e);
    parse_context_destroy(context);

    return body;
}

mime_entity_create()

MIMEEntity* mime_entity_create

(

void

)

Definition at line 87 of file mime.c.

References MIMEEntity::body, gwlist_create, MIMEEntity::headers, http_create_empty_headers(), MIMEEntity::multiparts, and MIMEEntity::start.

Referenced by mime_entity_body(), mime_entity_duplicate(), and mime_something_to_entity().

{
    MIMEEntity *e;

    e = gw_malloc(sizeof(MIMEEntity));
    e->headers = http_create_empty_headers();
    e->multiparts = gwlist_create();
    e->body = NULL;
    e->start = NULL;

    return e;
}

mime_entity_destroy()

void mime_entity_destroy

(

MIMEEntity *

e

)

Definition at line 105 of file mime.c.

References MIMEEntity::body, gw_assert(), gwlist_destroy(), MIMEEntity::headers, mime_entity_destroy_item(), MIMEEntity::multiparts, octstr_destroy(), octstr_destroy_item(), and MIMEEntity::start.

Referenced by main(), mime_entity_body(), mime_entity_destroy_item(), mime_entity_remove_part(), mime_entity_replace_part(), and mime_something_to_entity().

{
    gw_assert(e != NULL);

    if (e->headers != NULL)
        gwlist_destroy(e->headers, octstr_destroy_item);
    if (e->multiparts != NULL)
        gwlist_destroy(e->multiparts, mime_entity_destroy_item);
    octstr_destroy(e->body);
    e->start = NULL; /* will be destroyed on it's own via gwlist_destroy */
  
    gw_free(e);
}    

mime_entity_destroy_item()

static void mime_entity_destroy_item ( void *  e )

static

Definition at line 100 of file mime.c.

References mime_entity_destroy().

Referenced by mime_entity_destroy().

{
    mime_entity_destroy(e);
}

mime_entity_dump()

void mime_entity_dump

(

MIMEEntity *

m

)

Definition at line 717 of file mime.c.

References debug(), gw_assert(), MIMEEntity::headers, and mime_entity_dump_real().

Referenced by main().

{
    gw_assert(m != NULL && m->headers != NULL);

    debug("mms",0,"Dumping MIMEEntity at address %p", m);
    mime_entity_dump_real(m, 0);
}

mime_entity_dump_real()

static void mime_entity_dump_real ( MIMEEntity *  m, unsigned int  level  )

static

Definition at line 679 of file mime.c.

References MIMEEntity::body, charset, debug(), gw_assert(), gwlist_get(), gwlist_len(), MIMEEntity::headers, http_header_get_content_type(), http_header_value(), MIMEEntity::multiparts, octstr_append_cstr(), octstr_create, octstr_destroy(), octstr_get_cstr, octstr_imm(), octstr_len(), MIMEEntity::start, and type.

Referenced by mime_entity_dump().

{
    long i, items;
    Octstr *prefix, *type, *charset;
    unsigned int j;

    gw_assert(m != NULL && m->headers != NULL);

    prefix = octstr_create("");
    for (j = 0; j < level * 2; j++)
        octstr_append_cstr(prefix, " ");

    http_header_get_content_type(m->headers, &type, &charset);
    debug("mime.dump",0,"%sContent-Type `%s'", octstr_get_cstr(prefix),
          octstr_get_cstr(type));
    if (m->start != NULL) {
        Octstr *cid = http_header_value(m->start->headers, octstr_imm("Content-ID"));
        debug("mime.dump",0,"%sRelated to Content-ID <%s> MIMEEntity at address `%p'", 
              octstr_get_cstr(prefix), octstr_get_cstr(cid), m->start);
        octstr_destroy(cid);
    }
    items = gwlist_len(m->multiparts);
    debug("mime.dump",0,"%sBody contains %ld MIME entities, size %ld", octstr_get_cstr(prefix),
          items, (items == 0 && m->body) ? octstr_len(m->body) : -1);

    octstr_destroy(prefix);
    octstr_destroy(type);
    octstr_destroy(charset);

    for (i = 0; i < items; i++) {
        MIMEEntity *e = gwlist_get(m->multiparts, i);

        mime_entity_dump_real(e, level + 1);
    }

}

mime_entity_duplicate()

MIMEEntity* mime_entity_duplicate

(

MIMEEntity *

e

)

Definition at line 521 of file mime.c.

References MIMEEntity::body, gwlist_append(), gwlist_get(), gwlist_len(), MIMEEntity::headers, mime_entity_create(), mime_entity_duplicate(), mime_replace_headers(), MIMEEntity::multiparts, and octstr_duplicate.

Referenced by mime_entity_add_part(), mime_entity_duplicate(), mime_entity_get_part(), mime_entity_replace_part(), and mime_multipart_start_elem().

{
     MIMEEntity *copy = mime_entity_create();
     int i, n;
     
     mime_replace_headers(copy, e->headers);
     copy->body = e->body ? octstr_duplicate(e->body) : NULL;
     
     for (i = 0, n = gwlist_len(e->multiparts); i < n; i++)
      gwlist_append(copy->multiparts, 
            mime_entity_duplicate(gwlist_get(e->multiparts, i)));
     return copy;
}

mime_entity_get_part()

MIMEEntity* mime_entity_get_part	(	MIMEEntity *	e,
		int	i
	)

Definition at line 570 of file mime.c.

References gw_assert(), gwlist_get(), gwlist_len(), mime_entity_duplicate(), and MIMEEntity::multiparts.

{
     MIMEEntity *m;
     gw_assert(e != NULL);
     gw_assert(i >= 0);
     gw_assert(i < gwlist_len(e->multiparts));

     m = gwlist_get(e->multiparts, i);
     gw_assert(m);
     return mime_entity_duplicate(m);
}

mime_entity_headers()

List* mime_entity_headers

(

MIMEEntity *

m

)

Definition at line 469 of file mime.c.

References fix_boundary_element(), gw_assert(), MIMEEntity::headers, http_header_duplicate(), and mime_entity_num_parts().

{
    List *headers;

    gw_assert(m != NULL && m->headers != NULL);

    /* Need a fixup before hand over. */
    if (mime_entity_num_parts(m) > 0)
       fix_boundary_element(m->headers, NULL);

    headers = http_header_duplicate(m->headers);

    return headers;
}

mime_entity_num_parts()

int mime_entity_num_parts

(

MIMEEntity *

e

)

Definition at line 550 of file mime.c.

References gw_assert(), gwlist_len(), and MIMEEntity::multiparts.

Referenced by mime_entity_body(), and mime_entity_headers().

{
     gw_assert(e != NULL);
     return e->multiparts ? gwlist_len(e->multiparts) : 0;
}

mime_entity_remove_part()

void mime_entity_remove_part	(	MIMEEntity *	e,
		int	i
	)

Definition at line 584 of file mime.c.

References gw_assert(), gwlist_delete(), gwlist_get(), gwlist_len(), mime_entity_destroy(), MIMEEntity::multiparts, and MIMEEntity::start.

{
     MIMEEntity *m;

     gw_assert(e != NULL);
     gw_assert(i >= 0);
     gw_assert(i < gwlist_len(e->multiparts));
     
     
     m = gwlist_get(e->multiparts, i);
     gwlist_delete(e->multiparts, i, 1);
     if (m == e->start) e->start = NULL;

     mime_entity_destroy(m);
}

mime_entity_replace_part()

void mime_entity_replace_part	(	MIMEEntity *	e,
		int	i,
		MIMEEntity *	newpart
	)

Definition at line 601 of file mime.c.

References gw_assert(), gwlist_delete(), gwlist_get(), gwlist_insert(), gwlist_len(), mime_entity_destroy(), mime_entity_duplicate(), MIMEEntity::multiparts, and MIMEEntity::start.

{

     MIMEEntity *m;
     
     gw_assert(e != NULL);
     gw_assert(i >= 0);
     gw_assert(i < gwlist_len(e->multiparts));
     
     m = gwlist_get(e->multiparts, i);
     gwlist_delete(e->multiparts, i, 1);
     gwlist_insert(e->multiparts, i, mime_entity_duplicate(newpart));
     if (m == e->start) e->start = NULL;

     mime_entity_destroy(m);
}

mime_entity_set_body()

void mime_entity_set_body	(	MIMEEntity *	e,
		Octstr *	body
	)

Definition at line 622 of file mime.c.

References MIMEEntity::body, gw_assert(), octstr_destroy(), and octstr_duplicate.

{
     gw_assert(e != NULL);
     gw_assert(body != NULL);

     if (e->body)
      octstr_destroy(e->body);
     e->body = octstr_duplicate(body);
}

mime_entity_to_octstr()

Octstr* mime_entity_to_octstr

(

MIMEEntity *

m

)

Definition at line 216 of file mime.c.

References MIMEEntity::body, boundary, finished, fix_boundary_element(), gw_assert(), gwlist_get(), gwlist_len(), MIMEEntity::headers, http_destroy_headers(), http_header_duplicate(), mime_entity_to_octstr(), MIMEEntity::multiparts, octstr_append(), octstr_create, octstr_destroy(), and octstr_imm().

Referenced by main(), mime_entity_body(), and mime_entity_to_octstr().

{
    Octstr *mime, *boundary = NULL;
    List *headers;
    long i;

    gw_assert(m != NULL && m->headers != NULL);

    mime = octstr_create("");

    /* 
     * First of all check if we have further MIME entity dependencies,
     * which means we have further MIMEEntities in our m->multiparts
     * list. If no, then add headers and body and return. This is the
     * easy case. Otherwise we have to loop inside our entities.
     */
    if (gwlist_len(m->multiparts) == 0) {
        for (i = 0; i < gwlist_len(m->headers); i++) {
            octstr_append(mime, gwlist_get(m->headers, i));
            octstr_append(mime, octstr_imm("\r\n"));
        }
        octstr_append(mime, octstr_imm("\r\n"));
        if (m->body != NULL)
            octstr_append(mime, m->body);
        goto finished;
    }

    /* This call ensures boundary exists, and returns it */
    fix_boundary_element(m->headers, &boundary);
    headers = http_header_duplicate(m->headers);

    /* headers */
    for (i = 0; i < gwlist_len(headers); i++) {
        octstr_append(mime, gwlist_get(headers, i));
        octstr_append(mime, octstr_imm("\r\n"));
    }
    http_destroy_headers(headers);
    octstr_append(mime, octstr_imm("\r\n")); /* Mark end of headers. */

    /* loop through all MIME multipart entities of this entity */
    for (i = 0; i < gwlist_len(m->multiparts); i++) {
        MIMEEntity *e = gwlist_get(m->multiparts, i);
        Octstr *body;

        octstr_append(mime, octstr_imm("\r\n--"));
        octstr_append(mime, boundary);
        octstr_append(mime, octstr_imm("\r\n"));

        /* call ourself to produce the MIME entity body */
        body = mime_entity_to_octstr(e);
        octstr_append(mime, body);

        octstr_destroy(body);
    }

    octstr_append(mime, octstr_imm("\r\n--"));
    octstr_append(mime, boundary);
    octstr_append(mime, octstr_imm("--\r\n"));

    octstr_destroy(boundary);

finished:

    return mime;
}

mime_http_to_entity()

MIMEEntity* mime_http_to_entity	(	List *	headers,
		Octstr *	body
	)

Definition at line 461 of file mime.c.

References MIMEEntity::body, gw_assert(), MIMEEntity::headers, and mime_something_to_entity().

{
    gw_assert(headers != NULL && body != NULL);

    return mime_something_to_entity(body, headers);
}

mime_multipart_start_elem()

MIMEEntity* mime_multipart_start_elem

(

MIMEEntity *

e

)

Definition at line 633 of file mime.c.

References cid_matches(), get_start_param(), gw_assert(), gwlist_get(), gwlist_len(), MIMEEntity::headers, http_header_value(), mime_entity_duplicate(), MIMEEntity::multiparts, octstr_destroy(), octstr_imm(), MIMEEntity::start, and start.

{
     gw_assert(e != NULL);
     
    /* If e->start element is not yet set, set it as follows:
     * - if content type is not set, then set it to NULL
     * - if the start element is not set but this is a multipart object, set
     *   it to first multipart element, else set it to null
     * - if the start element of the content type is set, find a matching object
     *    and set e->start accordingly.
     * Finally, return a copy of it.
     */
     if (!e->start) {
      Octstr *ctype = http_header_value(e->headers, octstr_imm("Content-Type"));
      Octstr *start = get_start_param(ctype);
      int i;
      
      if (!ctype)
           e->start = NULL;
      else if (!start) {
           if (gwlist_len(e->multiparts) > 0) 
            e->start = gwlist_get(e->multiparts, 0); 
           else 
            e->start = NULL;
      } else 
           for (i = 0; i < gwlist_len(e->multiparts); i++) {
            MIMEEntity *x = gwlist_get(e->multiparts, i);
            if (cid_matches(x->headers, start)) {
             e->start = x;
             break;
            }
           }
      
      if (ctype)
           octstr_destroy(ctype);
      if (start)
           octstr_destroy(start);
     }
     
     return (e->start) ? mime_entity_duplicate(e->start) : NULL;
}

mime_octstr_to_entity()

MIMEEntity* mime_octstr_to_entity

(

Octstr *

mime

)

Definition at line 453 of file mime.c.

References gw_assert(), and mime_something_to_entity().

Referenced by main(), and mime_something_to_entity().

{
    gw_assert(mime != NULL);

    return mime_something_to_entity(mime, NULL);
}

mime_replace_headers()

void mime_replace_headers	(	MIMEEntity *	e,
		List *	headers
	)

Definition at line 536 of file mime.c.

References gw_assert(), MIMEEntity::headers, http_destroy_headers(), http_header_duplicate(), and MIMEEntity::start.

Referenced by mime_entity_duplicate().

{
     gw_assert(e != NULL);
     gw_assert(headers != NULL);

     http_destroy_headers(e->headers);
     e->headers = http_header_duplicate(headers);
     e->start = NULL; /* clear it, since header change means it could have changed.*/
}

mime_something_to_entity()

static MIMEEntity* mime_something_to_entity ( Octstr *  mime, List *  headers  )

static

Definition at line 332 of file mime.c.

References MIMEEntity::body, boundary, cid_matches(), debug(), get_start_param(), gw_assert(), gwlist_append(), MIMEEntity::headers, http_destroy_headers(), http_get_header_parameter(), http_header_duplicate(), http_header_value(), mime_entity_create(), mime_entity_destroy(), mime_octstr_to_entity(), MIMEEntity::multiparts, octstr_append(), octstr_append_cstr(), octstr_compare(), octstr_create, octstr_delete(), octstr_destroy(), octstr_dump, octstr_get_char(), octstr_get_cstr, octstr_imm(), octstr_len(), parse_context_create(), parse_context_destroy(), parse_get_line(), parse_get_rest(), parse_get_seperated_block(), read_mime_headers(), MIMEEntity::start, and start.

Referenced by mime_http_to_entity(), and mime_octstr_to_entity().

{
    MIMEEntity *e;
    ParseContext *context;
    Octstr *value, *boundary, *start;
    int len = 0;

    gw_assert(mime != NULL);

    value = boundary = start = NULL;
    context = parse_context_create(mime);
    e = mime_entity_create();
    
    /* parse the headers up to the body. If we have headers already passed 
     * from our caller, then duplicate them and continue */
    if (headers != NULL) {
        /* we have some headers to duplicate, first ensure we destroy
         * the list from the previous creation inside mime_entity_create() */
        http_destroy_headers(e->headers);
        e->headers = http_header_duplicate(headers);
    } else {
        /* parse the headers out of the mime block */
        if ((read_mime_headers(context, e->headers) != 0) || e->headers == NULL) {
            debug("mime.parse",0,"Failed to read MIME headers in Octstr block:");
            octstr_dump(mime, 0);
            mime_entity_destroy(e);
            parse_context_destroy(context);
            return NULL;
        }
    }

    /* 
     * Now check if the body is a multipart. This is indicated by an 'boundary'
     * parameter in the 'Content-Type' value. If yes, call ourself for the 
     * multipart entities after parsing them.
     */
    value = http_header_value(e->headers, octstr_imm("Content-Type"));
    boundary = http_get_header_parameter(value, octstr_imm("boundary"));
    start = get_start_param(value);

    /* Beware that we need *unquoted* strings to compare against in the
     * following parsing sections. */
    if (boundary && (len = octstr_len(boundary)) > 0 &&
        octstr_get_char(boundary, 0) == '"' && octstr_get_char(boundary, len-1) == '"') {
        octstr_delete(boundary, 0, 1);
        octstr_delete(boundary, len-2, 1);

    }

    if (boundary != NULL) {
        /* we have a multipart block as body, parse the boundary blocks */
        Octstr *entity, *seperator, *os;
        
        /* loop by all boundary blocks we have in the body */
        seperator = octstr_create("--");
        octstr_append(seperator, boundary);
        while ((entity = parse_get_seperated_block(context, seperator)) != NULL) {
            MIMEEntity *m;
            int del2 = 0;
        
            /* we have still linefeeds at the beginning and end that we 
             * need to remove, these are from the separator. 
             * We check if it is LF only or CRLF! */
            del2 = (octstr_get_char(entity, 0) == '\r');
            if (del2) 
                octstr_delete(entity, 0, 2);          
            else
                octstr_delete(entity, 0, 1);

            /* we assume the same mechanism applies to beginning and end -- 
             * seems reasonable! */
            if (del2)
                octstr_delete(entity, octstr_len(entity) - 2, 2);
            else
                octstr_delete(entity, octstr_len(entity) - 1, 1);

            debug("mime.parse",0,"MIME multipart: Parsing entity:");
            octstr_dump(entity, 0);

            /* call ourself for this MIME entity and inject to list */
            if ((m = mime_octstr_to_entity(entity))) {
                gwlist_append(e->multiparts, m);
         
                /* check if this entity is our start entity (in terms of related)
                 * and set our start pointer to it */
                if (cid_matches(m->headers, start)) {
                    /* set only if none has been set before */
                    e->start = (e->start == NULL) ? m : e->start;
                }
            }

            octstr_destroy(entity);
        }
        /* ok, we parsed all blocks, we expect to see now the end boundary */
        octstr_append_cstr(seperator, "--");
        os = parse_get_line(context);
        if (os != NULL && octstr_compare(os, seperator) != 0) {
            debug("mime.parse",0,"Failed to see end boundary, parsed line is '%s'.",
                  octstr_get_cstr(os));
        }

        octstr_destroy(seperator);
        octstr_destroy(os);
    }
    else {

        /* we don't have boundaries, so this is no multipart block, 
         * pass the body to the MIME entity. */
        e->body = parse_get_rest(context);

    }

    parse_context_destroy(context);
    octstr_destroy(value);
    octstr_destroy(boundary);
    octstr_destroy(start);

    return e;
}

read_mime_headers()

static int read_mime_headers ( ParseContext *  context, List *  headers  )

static

Definition at line 129 of file mime.c.

References gwlist_append(), gwlist_get(), gwlist_len(), MIMEEntity::headers, octstr_append(), octstr_destroy(), octstr_get_char(), octstr_len(), and parse_get_line().

Referenced by mime_entity_body(), and mime_something_to_entity().

{
    Octstr *line, *prev;

    if (gwlist_len(headers) == 0)
        prev = NULL;
    else
        prev = gwlist_get(headers, gwlist_len(headers) - 1);

    for (;;) {
        line = parse_get_line(context);
        if (line == NULL) {
            return -1;
        }
        if (octstr_len(line) == 0) {
            octstr_destroy(line);
            break;
        }
        if (isspace(octstr_get_char(line, 0)) && prev != NULL) {
            octstr_append(prev, line);
            octstr_destroy(line);
        } else {
            gwlist_append(headers, line);
            prev = line;
        }
    }

    return 0;
}