nsresult
nsMimeXmlEmitter::WriteXMLTag(const char *tagName, const char *value)
{
if ( (!value) || (!*value) )
return NS_OK;
char *upCaseTag = NULL;
char *newValue = MsgEscapeHTML(value);
if (!newValue)
return NS_OK;
nsCString newTagName(tagName);
newTagName.StripWhitespace();
ToUpperCase(newTagName);
upCaseTag = ToNewCString(newTagName);
UtilityWrite("<header field=\"");
UtilityWrite(upCaseTag);
UtilityWrite("\">");
// Here is where we are going to try to L10N the tagName so we will always
// get a field name next to an emitted header value. Note: Default will always
// be the name of the header itself.
//
UtilityWrite("<headerdisplayname>");
char *l10nTagName = LocalizeHeaderName(upCaseTag, tagName);
if ( (!l10nTagName) || (!*l10nTagName) )
UtilityWrite(tagName);
else
{
UtilityWrite(l10nTagName);
}
PR_FREEIF(l10nTagName);
UtilityWrite(": ");
UtilityWrite("</headerdisplayname>");
// Now write out the actual value itself and move on!
//
UtilityWrite(newValue);
UtilityWrite("</header>");
NS_Free(upCaseTag);
PR_FREEIF(newValue);
return NS_OK;
}
nsresult
nsMimeXmlEmitter::WriteXMLHeader(const char *msgID)
{
if ( (!msgID) || (!*msgID) )
msgID = "none";
char *newValue = MsgEscapeHTML(msgID);
if (!newValue)
return NS_ERROR_OUT_OF_MEMORY;
UtilityWrite("<?xml version=\"1.0\"?>");
UtilityWriteCRLF("<?xml-stylesheet href=\"chrome://messagebody/skin/messageBody.css\" type=\"text/css\"?>");
UtilityWrite("<message id=\"");
UtilityWrite(newValue);
UtilityWrite("\">");
mXMLHeaderStarted = true;
PR_FREEIF(newValue);
return NS_OK;
}
NS_IMETHODIMP nsSpamSettings::LogJunkString(const char *string)
{
bool loggingEnabled;
nsresult rv = GetLoggingEnabled(&loggingEnabled);
NS_ENSURE_SUCCESS(rv,rv);
if (!loggingEnabled)
return NS_OK;
nsCOMPtr <nsIOutputStream> logStream;
rv = GetLogStream(getter_AddRefs(logStream));
NS_ENSURE_SUCCESS(rv,rv);
PRUint32 writeCount;
rv = logStream->Write(LOG_ENTRY_START_TAG, LOG_ENTRY_START_TAG_LEN, &writeCount);
NS_ENSURE_SUCCESS(rv,rv);
NS_ASSERTION(writeCount == LOG_ENTRY_START_TAG_LEN, "failed to write out start log tag");
// html escape the log for security reasons.
// we don't want some to send us a message with a subject with
// html tags, especially <script>
char *escapedBuffer = MsgEscapeHTML(string);
if (!escapedBuffer)
return NS_ERROR_OUT_OF_MEMORY;
PRUint32 escapedBufferLen = strlen(escapedBuffer);
rv = logStream->Write(escapedBuffer, escapedBufferLen, &writeCount);
PR_Free(escapedBuffer);
NS_ENSURE_SUCCESS(rv,rv);
NS_ASSERTION(writeCount == escapedBufferLen, "failed to write out log hit");
rv = logStream->Write(LOG_ENTRY_END_TAG, LOG_ENTRY_END_TAG_LEN, &writeCount);
NS_ENSURE_SUCCESS(rv,rv);
NS_ASSERTION(writeCount == LOG_ENTRY_END_TAG_LEN, "failed to write out end log tag");
return NS_OK;
}
nsresult
nsMimeBaseEmitter::WriteHeaderFieldHTMLPrefix(const nsACString &name)
{
if (
( (mFormat == nsMimeOutput::nsMimeMessageSaveAs) && (mFirstHeaders) ) ||
( (mFormat == nsMimeOutput::nsMimeMessagePrintOutput) && (mFirstHeaders) )
)
/* DO NOTHING */ ; // rhp: Do nothing...leaving the conditional like this so its
// easier to see the logic of what is going on.
else {
mHTMLHeaders.Append("<br><fieldset class=\"mimeAttachmentHeader\">");
if (!name.IsEmpty()) {
mHTMLHeaders.Append("<legend class=\"mimeAttachmentHeaderName\">");
nsCString escapedName;
escapedName.Adopt(MsgEscapeHTML(nsCString(name).get()));
mHTMLHeaders.Append(escapedName);
mHTMLHeaders.Append("</legend>");
}
mHTMLHeaders.Append("</fieldset>");
}
mFirstHeaders = false;
return NS_OK;
}
nsresult
nsMimeHtmlDisplayEmitter::EndHeader(const nsACString &name)
{
if (mDocHeader && (mFormat != nsMimeOutput::nsMimeMessageFilterSniffer))
{
UtilityWriteCRLF("<html>");
UtilityWriteCRLF("<head>");
const char * val = GetHeaderValue(HEADER_SUBJECT); // do not free this value
if (val)
{
char * subject = MsgEscapeHTML(val);
if (subject)
{
int32_t bufLen = strlen(subject) + 16;
char *buf = new char[bufLen];
if (!buf)
return NS_ERROR_OUT_OF_MEMORY;
PR_snprintf(buf, bufLen, "<title>%s</title>", subject);
UtilityWriteCRLF(buf);
delete [] buf;
nsMemory::Free(subject);
}
}
// Stylesheet info!
UtilityWriteCRLF("<link rel=\"important stylesheet\" href=\"chrome://messagebody/skin/messageBody.css\">");
UtilityWriteCRLF("</head>");
UtilityWriteCRLF("<body>");
}
WriteHTMLHeaders(name);
return NS_OK;
}
nsresult
nsMimeBaseEmitter::WriteHeaderFieldHTML(const char *field, const char *value)
{
char *newValue = nullptr;
char *i18nValue = nullptr;
if ( (!field) || (!value) )
return NS_OK;
//
// This is a check to see what the pref is for header display. If
// We should only output stuff that corresponds with that setting.
//
if (!EmitThisHeaderForPrefSetting(mHeaderDisplayType, field))
return NS_OK;
//
// If we encounter the 'Date' header we try to convert it's value
// into localized format.
//
if ( strcmp(field, "Date") == 0 )
i18nValue = GetLocalizedDateString(value);
else
i18nValue = strdup(value);
if ( (mUnicodeConverter) && (mFormat != nsMimeOutput::nsMimeMessageSaveAs) )
{
nsCString tValue;
// we're going to need a converter to convert
nsresult rv = mUnicodeConverter->DecodeMimeHeaderToUTF8(
nsDependentCString(i18nValue), nullptr, false, true, tValue);
if (NS_SUCCEEDED(rv) && !tValue.IsEmpty())
newValue = MsgEscapeHTML(tValue.get());
else
newValue = MsgEscapeHTML(i18nValue);
}
else
{
newValue = MsgEscapeHTML(i18nValue);
}
free(i18nValue);
if (!newValue)
return NS_OK;
mHTMLHeaders.Append("<tr>");
mHTMLHeaders.Append("<td>");
if (mFormat == nsMimeOutput::nsMimeMessageSaveAs)
mHTMLHeaders.Append("<b>");
else
mHTMLHeaders.Append("<div class=\"headerdisplayname\" style=\"display:inline;\">");
// Here is where we are going to try to L10N the tagName so we will always
// get a field name next to an emitted header value. Note: Default will always
// be the name of the header itself.
//
nsCString newTagName(field);
newTagName.StripWhitespace();
ToUpperCase(newTagName);
char *l10nTagName = LocalizeHeaderName(newTagName.get(), field);
if ( (!l10nTagName) || (!*l10nTagName) )
mHTMLHeaders.Append(field);
else
{
mHTMLHeaders.Append(l10nTagName);
PR_FREEIF(l10nTagName);
}
mHTMLHeaders.Append(": ");
if (mFormat == nsMimeOutput::nsMimeMessageSaveAs)
mHTMLHeaders.Append("</b>");
else
mHTMLHeaders.Append("</div>");
// Now write out the actual value itself and move on!
//
mHTMLHeaders.Append(newValue);
mHTMLHeaders.Append("</td>");
mHTMLHeaders.Append("</tr>");
PR_FREEIF(newValue);
return NS_OK;
}
// Attachment handling routines
// Ok, we are changing the way we handle these now...It used to be that we output
// HTML to make a clickable link, etc... but now, this should just be informational
// and only show up during printing
// XXX should they also show up during quoting?
nsresult
nsMimeHtmlDisplayEmitter::StartAttachmentInBody(const nsACString &name,
const char *contentType,
const char *url)
{
mSkipAttachment = false;
bool p7mExternal = false;
nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (prefs)
prefs->GetBoolPref("mailnews.p7m_external", &p7mExternal);
if ( (contentType) &&
((!p7mExternal && !strcmp(contentType, APPLICATION_XPKCS7_MIME)) ||
(!p7mExternal && !strcmp(contentType, APPLICATION_PKCS7_MIME)) ||
(!strcmp(contentType, APPLICATION_XPKCS7_SIGNATURE)) ||
(!strcmp(contentType, APPLICATION_PKCS7_SIGNATURE)) ||
(!strcmp(contentType, TEXT_VCARD)))
)
{
mSkipAttachment = true;
return NS_OK;
}
if (mFirst)
{
UtilityWrite("<br><fieldset class=\"mimeAttachmentHeader\">");
if (!name.IsEmpty())
{
nsresult rv;
nsCOMPtr<nsIStringBundleService> bundleSvc =
mozilla::services::GetStringBundleService();
NS_ENSURE_TRUE(bundleSvc, NS_ERROR_UNEXPECTED);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleSvc->CreateBundle("chrome://messenger/locale/messenger.properties",
getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
nsString attachmentsHeader;
bundle->GetStringFromName(MOZ_UTF16("attachmentsPrintHeader"),
getter_Copies(attachmentsHeader));
UtilityWrite("<legend class=\"mimeAttachmentHeaderName\">");
nsCString escapedName;
escapedName.Adopt(MsgEscapeHTML(NS_ConvertUTF16toUTF8(attachmentsHeader).get()));
UtilityWrite(escapedName.get());
UtilityWrite("</legend>");
}
UtilityWrite("</fieldset>");
UtilityWrite("<div class=\"mimeAttachmentWrap\">");
UtilityWrite("<table class=\"mimeAttachmentTable\">");
}
UtilityWrite("<tr>");
UtilityWrite("<td class=\"mimeAttachmentFile\">");
UtilityWrite(name);
UtilityWrite("</td>");
mFirst = false;
return NS_OK;
}
static int
MimeExternalBody_parse_eof (MimeObject *obj, bool abort_p)
{
int status = 0;
MimeExternalBody *bod = (MimeExternalBody *) obj;
if (obj->closed_p) return 0;
/* Run parent method first, to flush out any buffered data. */
status = ((MimeObjectClass*)&MIME_SUPERCLASS)->parse_eof(obj, abort_p);
if (status < 0) return status;
#ifdef XP_MACOSX
if (obj->parent && mime_typep(obj->parent,
(MimeObjectClass*) &mimeMultipartAppleDoubleClass))
goto done;
#endif /* XP_MACOSX */
if (!abort_p &&
obj->output_p &&
obj->options &&
obj->options->write_html_p)
{
bool all_headers_p = obj->options->headers == MimeHeadersAll;
MimeDisplayOptions *newopt = obj->options; /* copy it */
char *ct = MimeHeaders_get(obj->headers, HEADER_CONTENT_TYPE,
PR_FALSE, PR_FALSE);
char *at, *lexp, *size, *perm;
char *url, *dir, *mode, *name, *site, *svr, *subj;
char *h = 0, *lname = 0, *lurl = 0, *body = 0;
MimeHeaders *hdrs = 0;
if (!ct) return MIME_OUT_OF_MEMORY;
at = MimeHeaders_get_parameter(ct, "access-type", NULL, NULL);
lexp = MimeHeaders_get_parameter(ct, "expiration", NULL, NULL);
size = MimeHeaders_get_parameter(ct, "size", NULL, NULL);
perm = MimeHeaders_get_parameter(ct, "permission", NULL, NULL);
dir = MimeHeaders_get_parameter(ct, "directory", NULL, NULL);
mode = MimeHeaders_get_parameter(ct, "mode", NULL, NULL);
name = MimeHeaders_get_parameter(ct, "name", NULL, NULL);
site = MimeHeaders_get_parameter(ct, "site", NULL, NULL);
svr = MimeHeaders_get_parameter(ct, "server", NULL, NULL);
subj = MimeHeaders_get_parameter(ct, "subject", NULL, NULL);
url = MimeHeaders_get_parameter(ct, "url", NULL, NULL);
PR_FREEIF(ct);
/* the *internal* content-type */
ct = MimeHeaders_get(bod->hdrs, HEADER_CONTENT_TYPE,
PR_TRUE, PR_FALSE);
PRUint32 hlen = ((at ? strlen(at) : 0) +
(lexp ? strlen(lexp) : 0) +
(size ? strlen(size) : 0) +
(perm ? strlen(perm) : 0) +
(dir ? strlen(dir) : 0) +
(mode ? strlen(mode) : 0) +
(name ? strlen(name) : 0) +
(site ? strlen(site) : 0) +
(svr ? strlen(svr) : 0) +
(subj ? strlen(subj) : 0) +
(ct ? strlen(ct) : 0) +
(url ? strlen(url) : 0) + 100);
h = (char *) PR_MALLOC(hlen);
if (!h)
{
status = MIME_OUT_OF_MEMORY;
goto FAIL;
}
/* If there's a URL parameter, remove all whitespace from it.
(The URL parameter to one of these headers is stored with
lines broken every 40 characters or less; it's assumed that
all significant whitespace was URL-hex-encoded, and all the
rest of it was inserted just to keep the lines short.)
*/
if (url)
{
char *in, *out;
for (in = url, out = url; *in; in++)
if (!IS_SPACE(*in))
*out++ = *in;
*out = 0;
}
hdrs = MimeHeaders_new();
if (!hdrs)
{
status = MIME_OUT_OF_MEMORY;
goto FAIL;
}
# define FROB(STR,VAR) \
if (VAR) \
{ \
PL_strncpyz(h, STR ": ", hlen); \
PL_strcatn(h, hlen, VAR); \
PL_strcatn(h, hlen, MSG_LINEBREAK); \
status = MimeHeaders_parse_line(h, strlen(h), hdrs); \
if (status < 0) goto FAIL; \
}
FROB("Access-Type", at);
FROB("URL", url);
FROB("Site", site);
FROB("Server", svr);
FROB("Directory", dir);
FROB("Name", name);
FROB("Type", ct);
FROB("Size", size);
FROB("Mode", mode);
FROB("Permission", perm);
FROB("Expiration", lexp);
FROB("Subject", subj);
# undef FROB
PL_strncpyz(h, MSG_LINEBREAK, hlen);
status = MimeHeaders_parse_line(h, strlen(h), hdrs);
if (status < 0) goto FAIL;
lurl = MimeExternalBody_make_url(ct, at, lexp, size, perm, dir, mode,
name, url, site, svr, subj, bod->body);
if (lurl)
{
lname = MimeGetStringByID(MIME_MSG_LINK_TO_DOCUMENT);
}
else
{
lname = MimeGetStringByID(MIME_MSG_DOCUMENT_INFO);
all_headers_p = PR_TRUE;
}
all_headers_p = PR_TRUE; /* #### just do this all the time? */
if (bod->body && all_headers_p)
{
char *s = bod->body;
while (IS_SPACE(*s)) s++;
if (*s)
{
char *s2;
const char *pre = "<P><PRE>";
const char *suf = "</PRE>";
PRInt32 i;
for(i = strlen(s)-1; i >= 0 && IS_SPACE(s[i]); i--)
s[i] = 0;
s2 = MsgEscapeHTML(s);
if (!s2) goto FAIL;
body = (char *) PR_MALLOC(strlen(pre) + strlen(s2) +
strlen(suf) + 1);
if (!body)
{
NS_Free(s2);
goto FAIL;
}
PL_strcpy(body, pre);
PL_strcat(body, s2);
PL_strcat(body, suf);
}
}
newopt->fancy_headers_p = PR_TRUE;
newopt->headers = (all_headers_p ? MimeHeadersAll : MimeHeadersSome);
FAIL:
if (hdrs)
MimeHeaders_free(hdrs);
PR_FREEIF(h);
PR_FREEIF(lname);
PR_FREEIF(lurl);
PR_FREEIF(body);
PR_FREEIF(ct);
PR_FREEIF(at);
PR_FREEIF(lexp);
PR_FREEIF(size);
PR_FREEIF(perm);
PR_FREEIF(dir);
PR_FREEIF(mode);
PR_FREEIF(name);
PR_FREEIF(url);
PR_FREEIF(site);
PR_FREEIF(svr);
PR_FREEIF(subj);
}
#ifdef XP_MACOSX
done:
#endif
return status;
}
