camel-mime-utils

camel-mime-utils

Synopsis

#define             CAMEL_FOLD_SIZE
#define             CAMEL_FOLD_MAX_SIZE
#define             CAMEL_UUDECODE_STATE_INIT
#define             CAMEL_UUDECODE_STATE_BEGIN
#define             CAMEL_UUDECODE_STATE_END
#define             CAMEL_UUDECODE_STATE_MASK
enum                CamelTransferEncoding;
struct              camel_header_references;
struct              camel_header_param;
                    CamelContentType;
struct              camel_header_raw;
                    CamelContentDisposition;
enum                camel_header_address_t;
struct              camel_header_address;
struct              camel_header_newsgroup;
struct _camel_header_address * camel_header_address_new (void);
struct _camel_header_address * camel_header_address_new_name
                                                        (const gchar *name,
                                                         const gchar *addr);
struct _camel_header_address * camel_header_address_new_group
                                                        (const gchar *name);
void                camel_header_address_ref            (struct _camel_header_address *addrlist);
void                camel_header_address_unref          (struct _camel_header_address *addrlist);
void                camel_header_address_set_name       (struct _camel_header_address *addrlist,
                                                         const gchar *name);
void                camel_header_address_set_addr       (struct _camel_header_address *addrlist,
                                                         const gchar *addr);
void                camel_header_address_set_members    (struct _camel_header_address *addrlist,
                                                         struct _camel_header_address *group);
void                camel_header_address_add_member     (struct _camel_header_address *addrlist,
                                                         struct _camel_header_address *member);
void                camel_header_address_list_append_list
                                                        (struct _camel_header_address **addrlistp,
                                                         struct _camel_header_address **addrs);
void                camel_header_address_list_append    (struct _camel_header_address **addrlistp,
                                                         struct _camel_header_address *addr);
void                camel_header_address_list_clear     (struct _camel_header_address **addrlistp);
struct _camel_header_address * camel_header_address_decode
                                                        (const gchar *in,
                                                         const gchar *charset);
struct _camel_header_address * camel_header_mailbox_decode
                                                        (const gchar *in,
                                                         const gchar *charset);
gchar *             camel_header_address_list_encode    (struct _camel_header_address *addrlist);
gchar *             camel_header_address_list_format    (struct _camel_header_address *addrlist);
struct _camel_header_param * camel_header_param_list_decode
                                                        (const gchar *in);
struct _camel_header_param * camel_header_set_param     (struct _camel_header_param **paramsp,
                                                         const gchar *name,
                                                         const gchar *value);
void                camel_header_param_list_format_append
                                                        (GString *out,
                                                         struct _camel_header_param *params);
gchar *             camel_header_param_list_format      (struct _camel_header_param *params);
void                camel_header_param_list_free        (struct _camel_header_param *params);
CamelContentType *  camel_content_type_new              (const gchar *type,
                                                         const gchar *subtype);
CamelContentType *  camel_content_type_decode           (const gchar *in);
void                camel_content_type_unref            (CamelContentType *content_type);
void                camel_content_type_ref              (CamelContentType *content_type);
const gchar *       camel_content_type_param            (CamelContentType *content_type,
                                                         const gchar *name);
void                camel_content_type_set_param        (CamelContentType *content_type,
                                                         const gchar *name,
                                                         const gchar *value);
gint                camel_content_type_is               (CamelContentType *content_type,
                                                         const gchar *type,
                                                         const gchar *subtype);
gchar *             camel_content_type_format           (CamelContentType *content_type);
gchar *             camel_content_type_simple           (CamelContentType *content_type);
void                camel_content_type_dump             (CamelContentType *content_type);
CamelContentDisposition * camel_content_disposition_decode
                                                        (const gchar *in);
void                camel_content_disposition_ref       (CamelContentDisposition *disposition);
void                camel_content_disposition_unref     (CamelContentDisposition *disposition);
gchar *             camel_content_disposition_format    (CamelContentDisposition *disposition);
gchar *             camel_content_transfer_encoding_decode
                                                        (const gchar *in);
void                camel_header_raw_append             (struct _camel_header_raw **list,
                                                         const gchar *name,
                                                         const gchar *value,
                                                         gint offset);
void                camel_header_raw_append_parse       (struct _camel_header_raw **list,
                                                         const gchar *header,
                                                         gint offset);
const gchar *       camel_header_raw_find               (struct _camel_header_raw **list,
                                                         const gchar *name,
                                                         gint *offset);
const gchar *       camel_header_raw_find_next          (struct _camel_header_raw **list,
                                                         const gchar *name,
                                                         gint *offset,
                                                         const gchar *last);
void                camel_header_raw_replace            (struct _camel_header_raw **list,
                                                         const gchar *name,
                                                         const gchar *value,
                                                         gint offset);
void                camel_header_raw_remove             (struct _camel_header_raw **list,
                                                         const gchar *name);
void                camel_header_raw_fold               (struct _camel_header_raw **list);
void                camel_header_raw_clear              (struct _camel_header_raw **list);
gchar *             camel_header_raw_check_mailing_list (struct _camel_header_raw **list);
gchar *             camel_header_address_fold           (const gchar *in,
                                                         gsize headerlen);
gchar *             camel_header_fold                   (const gchar *in,
                                                         gsize headerlen);
gchar *             camel_header_unfold                 (const gchar *in);
gchar *             camel_header_token_decode           (const gchar *in);
gint                camel_header_decode_int             (const gchar **in);
gchar *             camel_header_decode_string          (const gchar *in,
                                                         const gchar *default_charset);
gchar *             camel_header_encode_string          (const guchar *in);
gchar *             camel_header_format_ctext           (const gchar *in,
                                                         const gchar *default_charset);
gchar *             camel_header_encode_phrase          (const guchar *in);
time_t              camel_header_decode_date            (const gchar *str,
                                                         gint *tz_offset);
gchar *             camel_header_format_date            (time_t date,
                                                         gint tz_offset);
gchar *             camel_header_msgid_decode           (const gchar *in);
gchar *             camel_header_contentid_decode       (const gchar *in);
gchar *             camel_header_msgid_generate         (void);
struct _camel_header_references * camel_header_references_inreplyto_decode
                                                        (const gchar *in);
struct _camel_header_references * camel_header_references_decode
                                                        (const gchar *in);
void                camel_header_references_list_clear  (struct _camel_header_references **list);
void                camel_header_references_list_append_asis
                                                        (struct _camel_header_references **list,
                                                         gchar *ref);
gint                camel_header_references_list_size   (struct _camel_header_references **list);
struct _camel_header_references * camel_header_references_dup
                                                        (const struct _camel_header_references *list);
gchar *             camel_header_location_decode        (const gchar *in);
struct _camel_header_newsgroup * camel_header_newsgroups_decode
                                                        (const gchar *in);
void                camel_header_newsgroups_free        (struct _camel_header_newsgroup *ng);
const gchar *       camel_transfer_encoding_to_string   (CamelTransferEncoding encoding);
CamelTransferEncoding camel_transfer_encoding_from_string
                                                        (const gchar *string);
void                camel_header_mime_decode            (const gchar *in,
                                                         gint *maj,
                                                         gint *min);
gsize               camel_uudecode_step                 (guchar *in,
                                                         gsize inlen,
                                                         guchar *out,
                                                         gint *state,
                                                         guint32 *save);
gsize               camel_uuencode_step                 (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         guchar *uubuf,
                                                         gint *state,
                                                         guint32 *save);
gsize               camel_uuencode_close                (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         guchar *uubuf,
                                                         gint *state,
                                                         guint32 *save);
gsize               camel_quoted_decode_step            (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         gint *savestate,
                                                         gint *saveme);
gsize               camel_quoted_encode_step            (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         gint *state,
                                                         gint *save);
gsize               camel_quoted_encode_close           (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         gint *state,
                                                         gint *save);
#define             camel_mime_is_ctrl                  (x)
#define             camel_mime_is_lwsp                  (x)
#define             camel_mime_is_tspecial              (x)
#define             camel_mime_is_type                  (x,
                                                         t)
#define             camel_mime_is_ttoken                (x)
#define             camel_mime_is_atom                  (x)
#define             camel_mime_is_dtext                 (x)
#define             camel_mime_is_fieldname             (x)
#define             camel_mime_is_qpsafe                (x)
#define             camel_mime_is_especial              (x)
#define             camel_mime_is_psafe                 (x)
#define             camel_mime_is_attrchar              (x)

Description

Details

CAMEL_FOLD_SIZE

#define CAMEL_FOLD_SIZE (77)


CAMEL_FOLD_MAX_SIZE

#define CAMEL_FOLD_MAX_SIZE (998)


CAMEL_UUDECODE_STATE_INIT

#define CAMEL_UUDECODE_STATE_INIT   (0)


CAMEL_UUDECODE_STATE_BEGIN

#define CAMEL_UUDECODE_STATE_BEGIN  (1 << 16)


CAMEL_UUDECODE_STATE_END

#define CAMEL_UUDECODE_STATE_END    (1 << 17)


CAMEL_UUDECODE_STATE_MASK

#define CAMEL_UUDECODE_STATE_MASK   (CAMEL_UUDECODE_STATE_BEGIN | CAMEL_UUDECODE_STATE_END)


enum CamelTransferEncoding

typedef enum {
	CAMEL_TRANSFER_ENCODING_DEFAULT,
	CAMEL_TRANSFER_ENCODING_7BIT,
	CAMEL_TRANSFER_ENCODING_8BIT,
	CAMEL_TRANSFER_ENCODING_BASE64,
	CAMEL_TRANSFER_ENCODING_QUOTEDPRINTABLE,
	CAMEL_TRANSFER_ENCODING_BINARY,
	CAMEL_TRANSFER_ENCODING_UUENCODE,
	CAMEL_TRANSFER_NUM_ENCODINGS
} CamelTransferEncoding;


struct camel_header_references

struct camel_header_references {
	struct _camel_header_references *next;
	gchar *id;
};


struct camel_header_param

struct camel_header_param {
	struct _camel_header_param *next;
	gchar *name;
	gchar *value;
};

Searches params for a param named name and gets the value.

struct _camel_header_param *next;

gchar *name;

name of param to find

gchar *value;


CamelContentType

typedef struct {
	gchar *type;
	gchar *subtype;
	struct _camel_header_param *params;
	guint refcount;
} CamelContentType;


struct camel_header_raw

struct camel_header_raw {
	struct _camel_header_raw *next;
	gchar *name;
	gchar *value;
	gint offset;		/* in file, if known */
};


CamelContentDisposition

typedef struct {
	gchar *disposition;
	struct _camel_header_param *params;
	guint refcount;
} CamelContentDisposition;


enum camel_header_address_t

typedef enum {
	CAMEL_HEADER_ADDRESS_NONE, /* uninitialised */
	CAMEL_HEADER_ADDRESS_NAME,
	CAMEL_HEADER_ADDRESS_GROUP
} camel_header_address_t;


struct camel_header_address

struct camel_header_address {
	struct _camel_header_address *next;
	camel_header_address_t type;
	gchar *name;
	union {
		gchar *addr;
		struct _camel_header_address *members;
	} v;
	guint refcount;
};


struct camel_header_newsgroup

struct camel_header_newsgroup {
	struct _camel_header_newsgroup *next;

	gchar *newsgroup;
};


camel_header_address_new ()

struct _camel_header_address * camel_header_address_new (void);


camel_header_address_new_name ()

struct _camel_header_address * camel_header_address_new_name
                                                        (const gchar *name,
                                                         const gchar *addr);


camel_header_address_new_group ()

struct _camel_header_address * camel_header_address_new_group
                                                        (const gchar *name);


camel_header_address_ref ()

void                camel_header_address_ref            (struct _camel_header_address *addrlist);


camel_header_address_unref ()

void                camel_header_address_unref          (struct _camel_header_address *addrlist);


camel_header_address_set_name ()

void                camel_header_address_set_name       (struct _camel_header_address *addrlist,
                                                         const gchar *name);


camel_header_address_set_addr ()

void                camel_header_address_set_addr       (struct _camel_header_address *addrlist,
                                                         const gchar *addr);


camel_header_address_set_members ()

void                camel_header_address_set_members    (struct _camel_header_address *addrlist,
                                                         struct _camel_header_address *group);


camel_header_address_add_member ()

void                camel_header_address_add_member     (struct _camel_header_address *addrlist,
                                                         struct _camel_header_address *member);


camel_header_address_list_append_list ()

void                camel_header_address_list_append_list
                                                        (struct _camel_header_address **addrlistp,
                                                         struct _camel_header_address **addrs);


camel_header_address_list_append ()

void                camel_header_address_list_append    (struct _camel_header_address **addrlistp,
                                                         struct _camel_header_address *addr);


camel_header_address_list_clear ()

void                camel_header_address_list_clear     (struct _camel_header_address **addrlistp);


camel_header_address_decode ()

struct _camel_header_address * camel_header_address_decode
                                                        (const gchar *in,
                                                         const gchar *charset);


camel_header_mailbox_decode ()

struct _camel_header_address * camel_header_mailbox_decode
                                                        (const gchar *in,
                                                         const gchar *charset);


camel_header_address_list_encode ()

gchar *             camel_header_address_list_encode    (struct _camel_header_address *addrlist);


camel_header_address_list_format ()

gchar *             camel_header_address_list_format    (struct _camel_header_address *addrlist);


camel_header_param_list_decode ()

struct _camel_header_param * camel_header_param_list_decode
                                                        (const gchar *in);


camel_header_set_param ()

struct _camel_header_param * camel_header_set_param     (struct _camel_header_param **paramsp,
                                                         const gchar *name,
                                                         const gchar *value);

Set a parameter in the list.

paramsp :

poinetr to a list of params

name :

name of param to set

value :

value to set

Returns :

the set param

camel_header_param_list_format_append ()

void                camel_header_param_list_format_append
                                                        (GString *out,
                                                         struct _camel_header_param *params);


camel_header_param_list_format ()

gchar *             camel_header_param_list_format      (struct _camel_header_param *params);


camel_header_param_list_free ()

void                camel_header_param_list_free        (struct _camel_header_param *params);

Free the list of params.

params :

a list of params

camel_content_type_new ()

CamelContentType *  camel_content_type_new              (const gchar *type,
                                                         const gchar *subtype);

Create a new CamelContentType.

type :

the major type of the new content-type

subtype :

the subtype

Returns :

the new CamelContentType

camel_content_type_decode ()

CamelContentType *  camel_content_type_decode           (const gchar *in);


camel_content_type_unref ()

void                camel_content_type_unref            (CamelContentType *content_type);

Unrefs, and potentially frees, the content type.

content_type :

a CamelContentType

camel_content_type_ref ()

void                camel_content_type_ref              (CamelContentType *content_type);

Refs the content type.

content_type :

a CamelContentType

camel_content_type_param ()

const gchar *       camel_content_type_param            (CamelContentType *content_type,
                                                         const gchar *name);

Searches the params on s CamelContentType for a param named name and gets the value.

content_type :

a CamelContentType

name :

name of param to find

Returns :

the value of the name param

camel_content_type_set_param ()

void                camel_content_type_set_param        (CamelContentType *content_type,
                                                         const gchar *name,
                                                         const gchar *value);

Set a parameter on content_type.

content_type :

a CamelContentType

name :

name of param to set

value :

value of param to set

camel_content_type_is ()

gint                camel_content_type_is               (CamelContentType *content_type,
                                                         const gchar *type,
                                                         const gchar *subtype);

The subtype of "*" will match any subtype. If ct is NULL, then it will match the type "text/plain".

content_type :

A content type specifier, or NULL.

type :

A type to check against.

subtype :

A subtype to check against, or "*" to match any subtype.

Returns :

TRUE if the content type ct is of type type/subtype or FALSE otherwise

camel_content_type_format ()

gchar *             camel_content_type_format           (CamelContentType *content_type);


camel_content_type_simple ()

gchar *             camel_content_type_simple           (CamelContentType *content_type);


camel_content_type_dump ()

void                camel_content_type_dump             (CamelContentType *content_type);


camel_content_disposition_decode ()

CamelContentDisposition * camel_content_disposition_decode
                                                        (const gchar *in);


camel_content_disposition_ref ()

void                camel_content_disposition_ref       (CamelContentDisposition *disposition);


camel_content_disposition_unref ()

void                camel_content_disposition_unref     (CamelContentDisposition *disposition);


camel_content_disposition_format ()

gchar *             camel_content_disposition_format    (CamelContentDisposition *disposition);


camel_content_transfer_encoding_decode ()

gchar *             camel_content_transfer_encoding_decode
                                                        (const gchar *in);


camel_header_raw_append ()

void                camel_header_raw_append             (struct _camel_header_raw **list,
                                                         const gchar *name,
                                                         const gchar *value,
                                                         gint offset);


camel_header_raw_append_parse ()

void                camel_header_raw_append_parse       (struct _camel_header_raw **list,
                                                         const gchar *header,
                                                         gint offset);


camel_header_raw_find ()

const gchar *       camel_header_raw_find               (struct _camel_header_raw **list,
                                                         const gchar *name,
                                                         gint *offset);


camel_header_raw_find_next ()

const gchar *       camel_header_raw_find_next          (struct _camel_header_raw **list,
                                                         const gchar *name,
                                                         gint *offset,
                                                         const gchar *last);


camel_header_raw_replace ()

void                camel_header_raw_replace            (struct _camel_header_raw **list,
                                                         const gchar *name,
                                                         const gchar *value,
                                                         gint offset);


camel_header_raw_remove ()

void                camel_header_raw_remove             (struct _camel_header_raw **list,
                                                         const gchar *name);


camel_header_raw_fold ()

void                camel_header_raw_fold               (struct _camel_header_raw **list);


camel_header_raw_clear ()

void                camel_header_raw_clear              (struct _camel_header_raw **list);


camel_header_raw_check_mailing_list ()

gchar *             camel_header_raw_check_mailing_list (struct _camel_header_raw **list);


camel_header_address_fold ()

gchar *             camel_header_address_fold           (const gchar *in,
                                                         gsize headerlen);


camel_header_fold ()

gchar *             camel_header_fold                   (const gchar *in,
                                                         gsize headerlen);


camel_header_unfold ()

gchar *             camel_header_unfold                 (const gchar *in);


camel_header_token_decode ()

gchar *             camel_header_token_decode           (const gchar *in);

Gets the first token in the string according to the rules of rfc0822.

in :

input string

Returns :

a new string containing the first token in in

camel_header_decode_int ()

gint                camel_header_decode_int             (const gchar **in);

Extracts an integer token from in and updates the pointer to point to after the end of the integer token (sort of like strtol).

in :

pointer to input string

Returns :

the gint value

camel_header_decode_string ()

gchar *             camel_header_decode_string          (const gchar *in,
                                                         const gchar *default_charset);

Decodes rfc2047 encoded-word tokens

in :

input header value string

default_charset :

default charset to use if improperly encoded

Returns :

a string containing the UTF-8 version of the decoded header value

camel_header_encode_string ()

gchar *             camel_header_encode_string          (const guchar *in);

Encodes a 'text' header according to the rules of rfc2047.

in :

input string

Returns :

the rfc2047 encoded header

camel_header_format_ctext ()

gchar *             camel_header_format_ctext           (const gchar *in,
                                                         const gchar *default_charset);

Decodes a header which contains rfc2047 encoded-word tokens that may or may not be within a comment.

in :

input header value string

default_charset :

default charset to use if improperly encoded

Returns :

a string containing the UTF-8 version of the decoded header value

camel_header_encode_phrase ()

gchar *             camel_header_encode_phrase          (const guchar *in);

Encodes a 'phrase' header according to the rules in rfc2047.

in :

header to encode

Returns :

the encoded 'phrase'

camel_header_decode_date ()

time_t              camel_header_decode_date            (const gchar *str,
                                                         gint *tz_offset);

Decodes the rfc822 date string and saves the GMT offset into tz_offset if non-NULL.

str :

input date string

tz_offset :

timezone offset

Returns :

the time_t representation of the date string specified by str or (time_t) 0 on error. If tz_offset is non-NULL, the value of the timezone offset will be stored.

camel_header_format_date ()

gchar *             camel_header_format_date            (time_t date,
                                                         gint tz_offset);

Allocates a string buffer containing the rfc822 formatted date string represented by time and tz_offset.

date :

time_t date representation

tz_offset :

Timezone offset

Returns :

a valid string representation of the date.

camel_header_msgid_decode ()

gchar *             camel_header_msgid_decode           (const gchar *in);

Extract a message-id token from in.

in :

input string

Returns :

the msg-id

camel_header_contentid_decode ()

gchar *             camel_header_contentid_decode       (const gchar *in);

Extract a content-id from in.

in :

input string

Returns :

the extracted content-id

camel_header_msgid_generate ()

gchar *             camel_header_msgid_generate         (void);


camel_header_references_inreplyto_decode ()

struct _camel_header_references * camel_header_references_inreplyto_decode
                                                        (const gchar *in);


camel_header_references_decode ()

struct _camel_header_references * camel_header_references_decode
                                                        (const gchar *in);


camel_header_references_list_clear ()

void                camel_header_references_list_clear  (struct _camel_header_references **list);


camel_header_references_list_append_asis ()

void                camel_header_references_list_append_asis
                                                        (struct _camel_header_references **list,
                                                         gchar *ref);


camel_header_references_list_size ()

gint                camel_header_references_list_size   (struct _camel_header_references **list);


camel_header_references_dup ()

struct _camel_header_references * camel_header_references_dup
                                                        (const struct _camel_header_references *list);


camel_header_location_decode ()

gchar *             camel_header_location_decode        (const gchar *in);


camel_header_newsgroups_decode ()

struct _camel_header_newsgroup * camel_header_newsgroups_decode
                                                        (const gchar *in);


camel_header_newsgroups_free ()

void                camel_header_newsgroups_free        (struct _camel_header_newsgroup *ng);


camel_transfer_encoding_to_string ()

const gchar *       camel_transfer_encoding_to_string   (CamelTransferEncoding encoding);


camel_transfer_encoding_from_string ()

CamelTransferEncoding camel_transfer_encoding_from_string
                                                        (const gchar *string);


camel_header_mime_decode ()

void                camel_header_mime_decode            (const gchar *in,
                                                         gint *maj,
                                                         gint *min);


camel_uudecode_step ()

gsize               camel_uudecode_step                 (guchar *in,
                                                         gsize inlen,
                                                         guchar *out,
                                                         gint *state,
                                                         guint32 *save);

Uudecodes a chunk of data. Performs a 'decode step' on a chunk of uuencoded data. Assumes the "begin mode filename" line has been stripped off.

in :

input stream

inlen :

max length of data to decode

out :

output stream

state :

holds the number of bits that are stored in save

save :

leftover bits that have not yet been decoded

Returns :

the number of bytes decoded

camel_uuencode_step ()

gsize               camel_uuencode_step                 (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         guchar *uubuf,
                                                         gint *state,
                                                         guint32 *save);

Uuencodes a chunk of data. Performs an 'encode step', only encodes blocks of 45 characters to the output at a time, saves left-over state in uubuf, state and save (initialize to 0 on first invocation).

in :

input stream

len :

input stream length

out :

output stream

uubuf :

temporary buffer of 60 bytes

state :

holds the number of bits that are stored in save

save :

leftover bits that have not yet been encoded

Returns :

the number of bytes encoded

camel_uuencode_close ()

gsize               camel_uuencode_close                (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         guchar *uubuf,
                                                         gint *state,
                                                         guint32 *save);

Uuencodes a chunk of data. Call this when finished encoding data with camel_uuencode_step() to flush off the last little bit.

in :

input stream

len :

input stream length

out :

output stream

uubuf :

temporary buffer of 60 bytes

state :

holds the number of bits that are stored in save

save :

leftover bits that have not yet been encoded

Returns :

the number of bytes encoded

camel_quoted_decode_step ()

gsize               camel_quoted_decode_step            (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         gint *savestate,
                                                         gint *saveme);

Decodes a block of quoted-printable encoded data. Performs a 'decode step' on a chunk of QP encoded data.

in :

input stream

len :

max length of data to decode

out :

output stream

savestate :

holds the number of bits that are stored in save

saveme :

leftover bits that have not yet been decoded

Returns :

the number of bytes decoded

camel_quoted_encode_step ()

gsize               camel_quoted_encode_step            (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         gint *state,
                                                         gint *save);

Quoted-printable encodes a block of text. Performs an 'encode step', saves left-over state in state and save (initialise to -1 on first invocation).

in :

input stream

len :

length of the input

out :

output string

state :

holds the number of bits that are stored in save

save :

leftover bits that have not yet been encoded

Returns :

the number of bytes encoded

camel_quoted_encode_close ()

gsize               camel_quoted_encode_close           (guchar *in,
                                                         gsize len,
                                                         guchar *out,
                                                         gint *state,
                                                         gint *save);

Quoted-printable encodes a block of text. Call this when finished encoding data with camel_quoted_encode_step() to flush off the last little bit.

in :

input stream

len :

length of the input

out :

output string

state :

holds the number of bits that are stored in save

save :

leftover bits that have not yet been encoded

Returns :

the number of bytes encoded

camel_mime_is_ctrl()

#define camel_mime_is_ctrl(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_CTRL) != 0)


camel_mime_is_lwsp()

#define camel_mime_is_lwsp(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_LWSP) != 0)


camel_mime_is_tspecial()

#define camel_mime_is_tspecial(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_TSPECIAL) != 0)


camel_mime_is_type()

#define camel_mime_is_type(x, t) ((camel_mime_special_table[(guchar)(x)] & (t)) != 0)


camel_mime_is_ttoken()

#define camel_mime_is_ttoken(x) ((camel_mime_special_table[(guchar)(x)] & (CAMEL_MIME_IS_TSPECIAL|CAMEL_MIME_IS_LWSP|CAMEL_MIME_IS_CTRL)) == 0)


camel_mime_is_atom()

#define camel_mime_is_atom(x) ((camel_mime_special_table[(guchar)(x)] & (CAMEL_MIME_IS_SPECIAL|CAMEL_MIME_IS_SPACE|CAMEL_MIME_IS_CTRL)) == 0)


camel_mime_is_dtext()

#define camel_mime_is_dtext(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_DSPECIAL) == 0)


camel_mime_is_fieldname()

#define camel_mime_is_fieldname(x) ((camel_mime_special_table[(guchar)(x)] & (CAMEL_MIME_IS_CTRL|CAMEL_MIME_IS_SPACE)) == 0)


camel_mime_is_qpsafe()

#define camel_mime_is_qpsafe(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_QPSAFE) != 0)


camel_mime_is_especial()

#define camel_mime_is_especial(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_ESPECIAL) != 0)


camel_mime_is_psafe()

#define camel_mime_is_psafe(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_PSAFE) != 0)


camel_mime_is_attrchar()

#define camel_mime_is_attrchar(x) ((camel_mime_special_table[(guchar)(x)] & CAMEL_MIME_IS_ATTRCHAR) != 0)