Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#ifndef _LIBMIME_H_
#define _LIBMIME_H_
#ifdef XP_UNIX
# undef Bool
#endif
#include "nsString.h"
#include "nsMailHeaders.h"
#include "nsIMimeStreamConverter.h"
#include "mozilla/Encoding.h"
#include "nsIPrefBranch.h"
#include "mozITXTToHTMLConv.h"
#include "nsCOMPtr.h"
#include "modmimee.h" // for MimeConverterOutputCallback
#define MIME_DRAFTS
/* Opaque object describing a block of message headers, and a couple of
routines for extracting data from one.
*/
typedef struct MimeHeaders {
char* all_headers; /* A char* of the entire header section. */
int32_t all_headers_fp; /* The length (it is not NULL-terminated.) */
int32_t all_headers_size; /* The size of the allocated block. */
bool done_p; /* Whether we've read the end-of-headers marker
(the terminating blank line.) */
char** heads; /* An array of length heads_size which points
to the beginning of each distinct header:
just after the newline which terminated
the previous one. This is to speed search.
This is not initialized until all the
headers have been read.
*/
int32_t heads_size; /* The number of entries (pointers) in the heads
array (and consequently, how many
distinct headers are in here.) */
char* obuffer; /* This buffer is used for output. */
int32_t obuffer_size;
int32_t obuffer_fp;
char* munged_subject; /* What a hack. This is a place to write down
the subject header, after it's been
charset-ified and stuff. Remembered so that
we can later use it to generate the
<TITLE> tag. (Also works for giving names to
RFC822 attachments) */
} MimeHeaders;
class MimeDisplayOptions;
class MimeParseStateObject;
typedef struct MSG_AttachmentData MSG_AttachmentData;
/* Given the name of a header, returns the contents of that header as
a newly-allocated string (which the caller must free.) If the header
is not present, or has no contents, NULL is returned.
If `strip_p' is true, then the data returned will be the first token
of the header; else it will be the full text of the header. (This is
useful for getting just "text/plain" from "text/plain; name=foo".)
If `all_p' is false, then the first header encountered is used, and
any subsequent headers of the same name are ignored. If true, then
all headers of the same name are appended together (this is useful
for gathering up all CC headers into one, for example.)
*/
extern char* MimeHeaders_get(MimeHeaders* hdrs, const char* header_name,
bool strip_p, bool all_p);
// clang-format off
/* Given a header of the form of the MIME "Content-" headers, extracts a
named parameter from it, if it exists. For example,
MimeHeaders_get_parameter("text/plain; charset=us-ascii", "charset")
would return "us-ascii".
Returns NULL if there is no match, or if there is an allocation failure.
RFC2231 - MIME Parameter Value and Encoded Word Extensions: Character Sets,
Languages, and Continuations
RFC2231 has added the character sets, languages, and continuations mechanism.
charset, and language information may also be returned to the caller.
Note that charset and language should be free()'d while
the return value (parameter) has to be PR_FREE'd.
For example,
MimeHeaders_get_parameter("text/plain; name*=us-ascii'en-us'This%20is%20%2A%2A%2Afun%2A%2A%2A", "name")
MimeHeaders_get_parameter("text/plain; name*0*=us-ascii'en-us'This%20is%20; CRLFLWSPname*1*=%2A%2A%2Afun%2A%2A%2A", "name") would return "This is ***fun***" and *charset = "us-ascii", *language = "en-us"
*/
// clang-format on
extern char* MimeHeaders_get_parameter(const char* header_value,
const char* parm_name, char** charset,
char** language);
extern MimeHeaders* MimeHeaders_copy(MimeHeaders* srcHeaders);
extern void MimeHeaders_free(MimeHeaders* hdrs);
typedef enum {
MimeHeadersAll, /* Show all headers */
MimeHeadersSome, /* Show all "interesting" headers */
MimeHeadersSomeNoRef, /* Same, but suppress the `References' header
(for when we're printing this message.) */
MimeHeadersMicro, /* Show a one-line header summary */
MimeHeadersMicroPlus, /* Same, but show the full recipient list as
well (To, CC, etc.) */
MimeHeadersCitation, /* A one-line summary geared toward use in a
reply citation ("So-and-so wrote:") */
MimeHeadersOnly, /* Just parse and output headers...nothing else! */
MimeHeadersNone /* Skip showing any headers */
} MimeHeadersState;
/* The signature for various callbacks in the MimeDisplayOptions structure.
*/
typedef char* (*MimeHTMLGeneratorFunction)(const char* data, void* closure,
MimeHeaders* headers);
class MimeDisplayOptions {
public:
MimeDisplayOptions();
virtual ~MimeDisplayOptions();
mozITXTToHTMLConv* conv; // For text conversion...
nsCOMPtr<nsIPrefBranch> m_prefBranch; /* prefBranch-service */
nsMimeOutputType format_out; // The format out type
const char* url; /* Base URL for the document. This string should
be freed by the caller, after the parser
completes (possibly at the same time as the
MimeDisplayOptions itself.) */
MimeHeadersState headers; /* How headers should be displayed. */
bool fancy_headers_p; /* Whether to do clever formatting of headers
using tables, instead of spaces. */
bool output_vcard_buttons_p; /* Whether to output the buttons */
/* on vcards. */
bool variable_width_plaintext_p; /* Whether text/plain messages should
be in variable width, or fixed. */
bool wrap_long_lines_p; /* Whether to wrap long lines in text/plain
messages. */
bool rot13_p; /* Whether text/plain parts should be rotated
Set by "?rot13=true" */
char* part_to_load; /* The particular part of the multipart which
we are extracting. Set by "?part=3.2.4" */
bool no_output_p; /* Will never write output when this is true.
(When false, output or not may depend on other things.)
This needs to be in the options, because the method
MimeObject_parse_begin is controlling the property
"output_p" (on the MimeObject) so we need a way for other
functions to override it and tell that we do not want
output. */
bool write_html_p; /* Whether the output should be HTML, or raw. */
bool decrypt_p; /* Whether all traces of xlateion should be
eradicated -- this is only meaningful when
write_html_p is false; we set this when
attaching a message for forwarding, since
forwarding someone else a message that wasn't
xlated for them doesn't work. We have to
dexlate it before sending it.
*/
/* Whether this MIME part is a child of another part (and not top level). */
bool is_child = false;
uint32_t whattodo; /* from the prefs, we'll get if the user wants to do glyph
or structure substitutions and set this member variable.
*/
char* default_charset; /* If this is non-NULL, then it is the charset to
assume when no other one is specified via a
`charset' parameter.
*/
bool override_charset; /* If this is true, then we will assume that
all data is in the default_charset, regardless
of what the `charset' parameter of that part
says. (This is to cope with the fact that, in
the real world, many messages are mislabelled
with the wrong charset.)
*/
bool force_user_charset; /* this is the new strategy to deal with incorrectly
labeled attachments */
/* =======================================================================
Stream-related callbacks; for these functions, the `closure' argument
is what is found in `options->stream_closure'. (One possible exception
is for output_fn; see "output_closure" below.)
*/
void* stream_closure;
/* For setting up the display stream, so that the MIME parser can inform
the caller of the type of the data it will be getting. */
int (*output_init_fn)(const char* type, const char* charset, const char* name,
const char* x_mac_type, const char* x_mac_creator,
void* stream_closure);
/* How the MIME parser feeds its output (HTML or raw) back to the caller. */
MimeConverterOutputCallback output_fn;
/* Closure to pass to the above output_fn. If NULL, then the
stream_closure is used. */
void* output_closure;
/* A hook for the caller to perform charset-conversion before HTML is
returned. Each set of characters which originated in a mail message
(body or headers) will be run through this filter before being converted
into HTML. (This should return bytes which may appear in an HTML file,
ie, we must be able to scan through the string to search for "<" and
turn it in to "<", and so on.)
`input' is a non-NULL-terminated string of a single line from the message.
`input_length' is how long it is.
`input_charset' is a string representing the charset of this string (as
specified by MIME headers.)
The conversion is always to UTF-8.
`output_ret' is where a newly-malloced string is returned. It may be
NULL if no translation is needed.
`output_size_ret' is how long the returned string is (it need not be
NULL-terminated.).
*/
int (*charset_conversion_fn)(const char* input_line, int32_t input_length,
const char* input_charset,
nsACString& output_ret, void* stream_closure);
/* If true, perform both charset-conversion and decoding of
MIME-2 header fields (using RFC-1522 encoding.)
*/
bool rfc1522_conversion_p;
/* A hook for the caller to turn a file name into a content-type. */
char* (*file_type_fn)(const char* filename, void* stream_closure);
/* A hook by which the user may be prompted for a password by the security
library. (This is really of type `SECKEYGetPasswordKey'; see sec.h.) */
void* (*passwd_prompt_fn)(void* arg1, void* arg2);
/* =======================================================================
Various callbacks; for all of these functions, the `closure' argument
is what is found in `html_closure'.
*/
void* html_closure;
/* For emitting some HTML before the start of the outermost message
(this is called before any HTML is written to layout.) */
MimeHTMLGeneratorFunction generate_header_html_fn;
/* For emitting some HTML after the outermost header block, but before
the body of the first message. */
MimeHTMLGeneratorFunction generate_post_header_html_fn;
/* For emitting some HTML at the very end (this is called after libmime
has written everything it's going to write.) */
MimeHTMLGeneratorFunction generate_footer_html_fn;
/* For turning a message ID into a loadable URL. */
MimeHTMLGeneratorFunction generate_reference_url_fn;
/* For turning a mail address into a mailto URL. */
MimeHTMLGeneratorFunction generate_mailto_url_fn;
/* For turning a newsgroup name into a news URL. */
MimeHTMLGeneratorFunction generate_news_url_fn;
/* =======================================================================
Callbacks to handle the backend-specific inlined image display
(internal-external-reconnect junk.) For `image_begin', the `closure'
argument is what is found in `stream_closure'; but for all of the
others, the `closure' argument is the data that `image_begin' returned.
*/
/* Begins processing an embedded image; the URL and content_type are of the
image itself. */
void* (*image_begin)(const char* image_url, const char* content_type,
void* stream_closure);
/* Stop processing an image. */
void (*image_end)(void* image_closure, int status);
/* Dump some raw image data down the stream. */
int (*image_write_buffer)(const char* buf, int32_t size, void* image_closure);
/* What HTML should be dumped out for this image. */
char* (*make_image_html)(void* image_closure);
/* =======================================================================
Other random opaque state.
*/
MimeParseStateObject* state; /* Some state used by libmime internals;
initialize this to 0 and leave it alone.
*/
#ifdef MIME_DRAFTS
/* =======================================================================
Mail Draft hooks -- 09-19-1996
*/
bool decompose_file_p; /* are we decomposing a mime msg
into separate files */
bool done_parsing_outer_headers; /* are we done parsing the outer message
headers; this is really useful when
we have multiple Message/RFC822
headers */
bool is_multipart_msg; /* are we decomposing a multipart
message */
int decompose_init_count; /* used for non multipart message only */
bool signed_p; /* to tell draft this is a signed message */
bool caller_need_root_headers; /* set it to true to receive the message main
headers through the callback
decompose_headers_info_fn */
/* Callback to gather the outer most headers so we could use the
information to initialize the addressing/subject/newsgroups fields
for the composition window. */
int (*decompose_headers_info_fn)(void* closure, MimeHeaders* headers);
/* Callbacks to create temporary files for drafts attachments. */
int (*decompose_file_init_fn)(void* stream_closure, MimeHeaders* headers);
MimeConverterOutputCallback decompose_file_output_fn;
int (*decompose_file_close_fn)(void* stream_closure);
#endif /* MIME_DRAFTS */
int32_t attachment_icon_layer_id; /* Hackhackhack. This is zero if we have
not yet emitted the attachment layer
stuff. If we have, then this is the
id number for that layer, which is a
unique random number every time, to keep
evil people from writing javascript code
to hack it. */
bool missing_parts; /* Whether or not this message is going to contain
missing parts (from IMAP Mime Parts On Demand) */
bool show_attachment_inline_p; /* Whether or not we should display attachment
inline (whatever say the
content-disposition) */
bool show_attachment_inline_text; /* Whether or not we should display text
attachment inline (whatever the
content-disposition says) */
bool quote_attachment_inline_p; /* Whether or not we should include inlined
attachments in quotes of replies) */
int32_t html_as_p; /* How we should display HTML, which allows us to know if
we should display all body parts */
/**
* Should StartBody/EndBody events be generated for nested MimeMessages. If
* false (the default value), the events are only generated for the outermost
* MimeMessage.
*/
bool notify_nested_bodies;
/**
* When true, compels mime parts to only write the actual body
* payload and not display-gunk like links to attachments. This was
* primarily introduced for the benefit of the javascript emitter.
*/
bool write_pure_bodies;
/**
* When true, only processes metadata (i.e. size) for streamed attachments.
* Mime emitters that expect any attachment data (including inline text and
* image attachments) should leave this as false (the default value). At
* the moment, only the JS mime emitter uses this.
*/
bool metadata_only;
};
#endif /* _MODLMIME_H_ */