static bool
MimeMultipartRelated_output_child_p(MimeObject *obj, MimeObject* child)
{
MimeMultipartRelated *relobj = (MimeMultipartRelated *) obj;
/* rhp - Changed from "if (relobj->head_loaded)" alone to support the
start parameter
*/
if (
(relobj->head_loaded) ||
(MimeStartParamExists(obj, child) && !MimeThisIsStartPart(obj, child))
)
{
/* This is a child part. Just remember the mapping between the URL
it represents and the part-URL to get it back. */
char* location = MimeHeaders_get(child->headers, HEADER_CONTENT_LOCATION,
false, false);
if (!location) {
char* tmp = MimeHeaders_get(child->headers, HEADER_CONTENT_ID,
false, false);
if (tmp) {
char* tmp2 = tmp;
if (*tmp2 == '<') {
int length;
tmp2++;
length = strlen(tmp2);
if (length > 0 && tmp2[length - 1] == '>') {
tmp2[length - 1] = '\0';
}
}
location = PR_smprintf("cid:%s", tmp2);
PR_Free(tmp);
}
}
if (location) {
char *absolute;
char *base_url = MimeHeaders_get(child->headers, HEADER_CONTENT_BASE,
false, false);
absolute = MakeAbsoluteURL(base_url ? base_url : relobj->base_url, location);
PR_FREEIF(base_url);
PR_Free(location);
if (absolute) {
nsCAutoString partnum;
nsCAutoString imappartnum;
partnum.Adopt(mime_part_address(child));
if (!partnum.IsEmpty()) {
if (obj->options->missing_parts)
{
char * imappart = mime_imap_part_address(child);
if (imappart)
imappartnum.Adopt(imappart);
}
/*
AppleDouble part need special care: we need to output only the data fork part of it.
The problem at this point is that we haven't yet decoded the children of the AppleDouble
part therfore we will have to hope the datafork is the second one!
*/
if (mime_typep(child, (MimeObjectClass *) &mimeMultipartAppleDoubleClass))
partnum.Append(".2");
char* part;
if (!imappartnum.IsEmpty())
part = mime_set_url_imap_part(obj->options->url, imappartnum.get(), partnum.get());
else
{
char *no_part_url = nullptr;
if (obj->options->part_to_load && obj->options->format_out == nsMimeOutput::nsMimeMessageBodyDisplay)
no_part_url = mime_get_base_url(obj->options->url);
if (no_part_url)
{
part = mime_set_url_part(no_part_url, partnum.get(), false);
PR_Free(no_part_url);
}
else
part = mime_set_url_part(obj->options->url, partnum.get(), false);
}
if (part)
{
char *name = MimeHeaders_get_name(child->headers, child->options);
// let's stick the filename in the part so save as will work.
if (name)
{
//char *savePart = part;
//part = PR_smprintf("%s&filename=%s", savePart, name);
//PR_Free(savePart);
PR_Free(name);
}
char *temp = part;
/* If there's a space in the url, escape the url.
(This happens primarily on Windows and Unix.) */
if (PL_strchr(part, ' ') || PL_strchr(part, '>') || PL_strchr(part, '%'))
temp = escape_for_mrel_subst(part);
MimeHashValue * value = new MimeHashValue(child, temp);
PL_HashTableAdd(relobj->hash, absolute, value);
/* rhp - If this part ALSO has a Content-ID we need to put that into
the hash table and this is what this code does
*/
{
char *tloc;
char *tmp = MimeHeaders_get(child->headers, HEADER_CONTENT_ID, false, false);
if (tmp)
{
char* tmp2 = tmp;
if (*tmp2 == '<')
{
int length;
tmp2++;
length = strlen(tmp2);
if (length > 0 && tmp2[length - 1] == '>')
{
tmp2[length - 1] = '\0';
}
}
tloc = PR_smprintf("cid:%s", tmp2);
PR_Free(tmp);
if (tloc)
{
MimeHashValue *value;
value = (MimeHashValue*)PL_HashTableLookup(relobj->hash, tloc);
if (!value)
{
value = new MimeHashValue(child, temp);
PL_HashTableAdd(relobj->hash, tloc, value);
}
else
PR_smprintf_free(tloc);
}
}
}
/* rhp - End of putting more stuff into the hash table */
/* it's possible that temp pointer is the same than the part pointer,
therefore be carefull to not freeing twice the same pointer */
if (temp && temp != part)
PR_Free(temp);
PR_Free(part);
}
}
}
}
} else {
/* Ah-hah! We're the head object. */
char* base_url;
relobj->head_loaded = true;
relobj->headobj = child;
relobj->buffered_hdrs = MimeHeaders_copy(child->headers);
base_url = MimeHeaders_get(child->headers, HEADER_CONTENT_BASE,
false, false);
/* rhp: need this for supporting Content-Location */
if (!base_url)
{
base_url = MimeHeaders_get(child->headers, HEADER_CONTENT_LOCATION, false, false);
}
/* rhp: need this for supporting Content-Location */
if (base_url) {
/* If the head object has a base_url associated with it, use
that instead of any base_url that may have been associated
with the multipart/related. */
PR_FREEIF(relobj->base_url);
relobj->base_url = base_url;
}
}
if (obj->options && !obj->options->write_html_p
#ifdef MIME_DRAFTS
&& !obj->options->decompose_file_p
#endif /* MIME_DRAFTS */
)
{
return true;
}
return false; /* Don't actually parse this child; we'll handle
all that at eof time. */
}
static int
MimeInlineImage_parse_begin (MimeObject *obj)
{
MimeInlineImage *img = (MimeInlineImage *) obj;
MimeInlineImageClass *clazz;
int status;
status = ((MimeObjectClass*)&MIME_SUPERCLASS)->parse_begin(obj);
if (status < 0) return status;
if (!obj->output_p) return 0;
if (!obj->options || !obj->options->output_fn ||
// don't bother processing if the consumer doesn't want us
// gunking the body up.
obj->options->write_pure_bodies)
return 0;
clazz = (MimeInlineImageClass *) obj->clazz;
if (obj->options &&
obj->options->image_begin &&
obj->options->write_html_p &&
obj->options->image_write_buffer)
{
char *html, *part, *image_url;
const char *ct;
part = mime_part_address(obj);
if (!part) return MIME_OUT_OF_MEMORY;
char *no_part_url = nullptr;
if (obj->options->part_to_load && obj->options->format_out == nsMimeOutput::nsMimeMessageBodyDisplay)
no_part_url = mime_get_base_url(obj->options->url);
if (no_part_url)
{
image_url = mime_set_url_part(no_part_url, part, true);
PR_Free(no_part_url);
}
else
image_url = mime_set_url_part(obj->options->url, part, true);
if (!image_url)
{
PR_Free(part);
return MIME_OUT_OF_MEMORY;
}
PR_Free(part);
ct = obj->content_type;
if (!ct) ct = IMAGE_GIF; /* Can't happen? Close enough. */
// Fill in content type and attachment name here.
nsCAutoString url_with_filename(image_url);
url_with_filename += "&type=";
url_with_filename += ct;
char * filename = MimeHeaders_get_name ( obj->headers, obj->options );
if (filename)
{
nsCString escapedName;
MsgEscapeString(nsDependentCString(filename), nsINetUtil::ESCAPE_URL_PATH,
escapedName);
url_with_filename += "&filename=";
url_with_filename += escapedName;
PR_Free(filename);
}
// We need to separate images with HR's...
MimeObject_write_separator(obj);
img->image_data =
obj->options->image_begin(url_with_filename.get(), ct, obj->options->stream_closure);
PR_Free(image_url);
if (!img->image_data) return MIME_OUT_OF_MEMORY;
html = obj->options->make_image_html(img->image_data);
if (!html) return MIME_OUT_OF_MEMORY;
status = MimeObject_write(obj, html, strlen(html), true);
PR_Free(html);
if (status < 0) return status;
}
//
// Now we are going to see if we should set the content type in the
// URI for the url being run...
//
if (obj->options && obj->options->stream_closure && obj->content_type)
{
mime_stream_data *msd = (mime_stream_data *) (obj->options->stream_closure);
if ( (msd) && (msd->channel) )
{
msd->channel->SetContentType(nsDependentCString(obj->content_type));
}
}
return 0;
}
static int
MimeExternalObject_parse_begin (MimeObject *obj)
{
int status;
status = ((MimeObjectClass*)&MIME_SUPERCLASS)->parse_begin(obj);
if (status < 0) return status;
// If we're writing this object, and we're doing it in raw form, then
// now is the time to inform the backend what the type of this data is.
//
if (obj->output_p &&
obj->options &&
!obj->options->write_html_p &&
!obj->options->state->first_data_written_p)
{
status = MimeObject_output_init(obj, 0);
if (status < 0) return status;
NS_ASSERTION(obj->options->state->first_data_written_p, "1.1 <*****@*****.**> 19 Mar 1999 12:00");
}
//
// If we're writing this object as HTML, do all the work now -- just write
// out a table with a link in it. (Later calls to the `parse_buffer' method
// will simply discard the data of the object itself.)
//
if (obj->options &&
obj->output_p &&
obj->options->write_html_p &&
obj->options->output_fn)
{
MimeDisplayOptions newopt = *obj->options; // copy it
char *id = 0;
char *id_url = 0;
char *id_name = 0;
nsCString id_imap;
PRBool all_headers_p = obj->options->headers == MimeHeadersAll;
id = mime_part_address (obj);
if (obj->options->missing_parts)
id_imap.Adopt(mime_imap_part_address (obj));
if (! id) return MIME_OUT_OF_MEMORY;
if (obj->options && obj->options->url)
{
const char *url = obj->options->url;
if (!id_imap.IsEmpty() && id)
{
// if this is an IMAP part.
id_url = mime_set_url_imap_part(url, id_imap.get(), id);
}
else
{
// This is just a normal MIME part as usual.
id_url = mime_set_url_part(url, id, PR_TRUE);
}
if (!id_url)
{
PR_Free(id);
return MIME_OUT_OF_MEMORY;
}
}
if (!strcmp (id, "0"))
{
PR_Free(id);
id = MimeGetStringByID(MIME_MSG_ATTACHMENT);
}
else
{
const char *p = "Part ";
PRUint32 slen = strlen(p) + strlen(id) + 1;
char *s = (char *)PR_MALLOC(slen);
if (!s)
{
PR_Free(id);
PR_Free(id_url);
return MIME_OUT_OF_MEMORY;
}
// we have a valid id
if (id)
id_name = mime_find_suggested_name_of_part(id, obj);
PL_strncpyz(s, p, slen);
PL_strcatn(s, slen, id);
PR_Free(id);
id = s;
}
if (all_headers_p &&
// Don't bother showing all headers on this part if it's the only
// part in the message: in that case, we've already shown these
// headers.
obj->options->state &&
obj->options->state->root == obj->parent)
all_headers_p = PR_FALSE;
newopt.fancy_headers_p = PR_TRUE;
newopt.headers = (all_headers_p ? MimeHeadersAll : MimeHeadersSome);
/******
RICHIE SHERRY
GOTTA STILL DO THIS FOR QUOTING!
status = MimeHeaders_write_attachment_box (obj->headers, &newopt,
obj->content_type,
obj->encoding,
id_name? id_name : id, id_url, 0)
*****/
// obj->options really owns the storage for this.
newopt.part_to_load = nsnull;
newopt.default_charset = nsnull;
PR_FREEIF(id);
PR_FREEIF(id_url);
PR_FREEIF(id_name);
if (status < 0) return status;
}
return 0;
}
