void IPC_GetDefaultSocketPath(char *buf, PRUint32 bufLen)
{
const char *logName;
int len;
PL_strncpyz(buf, kDefaultSocketPrefix, bufLen);
buf += (sizeof(kDefaultSocketPrefix) - 1);
bufLen -= (sizeof(kDefaultSocketPrefix) - 1);
logName = PR_GetEnv("LOGNAME");
if (!logName || !logName[0]) {
logName = PR_GetEnv("USER");
if (!logName || !logName[0]) {
LOG(("could not determine username from environment\n"));
goto end;
}
}
PL_strncpyz(buf, logName, bufLen);
len = strlen(logName);
buf += len;
bufLen -= len;
end:
PL_strncpyz(buf, kDefaultSocketSuffix, bufLen);
}
void
IPC_InitLog(const char *prefix)
{
#ifdef VBOX
// initialize VBox Runtime
RTR3InitDll(0);
PL_strncpyz(ipcLogPrefix, prefix, sizeof(ipcLogPrefix));
#else
if (PR_GetEnv("IPC_LOG_ENABLE")) {
ipcLogEnabled = PR_TRUE;
PL_strncpyz(ipcLogPrefix, prefix, sizeof(ipcLogPrefix));
}
#endif
}
/*
* loadConfigStats()
*
* Reads the header table SNMP settings and sets them in the mmap'd stats
* file. This should be done only when the semaphore is held.
*/
static void
loadConfigStats() {
Slapi_Entry *entry = NULL;
char *name = NULL;
char *desc = NULL;
char *org = NULL;
char *loc = NULL;
char *contact = NULL;
/* Read attributes from SNMP config entry */
getConfigEntry( &entry );
if ( entry != NULL ) {
name = slapi_entry_attr_get_charptr( entry, SNMP_NAME_ATTR );
desc = slapi_entry_attr_get_charptr( entry, SNMP_DESC_ATTR );
org = slapi_entry_attr_get_charptr( entry, SNMP_ORG_ATTR );
loc = slapi_entry_attr_get_charptr( entry, SNMP_LOC_ATTR );
contact = slapi_entry_attr_get_charptr( entry, SNMP_CONTACT_ATTR );
freeConfigEntry( &entry );
}
/* Load stats into table */
if ( name != NULL) {
PL_strncpyz(stats->hdr_stats.dsName, name, SNMP_FIELD_LENGTH);
}
if ( desc != NULL) {
PL_strncpyz(stats->hdr_stats.dsDescription, desc, SNMP_FIELD_LENGTH);
}
if ( org != NULL) {
PL_strncpyz(stats->hdr_stats.dsOrganization, org, SNMP_FIELD_LENGTH);
}
if ( loc != NULL) {
PL_strncpyz(stats->hdr_stats.dsLocation, loc, SNMP_FIELD_LENGTH);
}
if ( contact != NULL) {
PL_strncpyz(stats->hdr_stats.dsContact, contact, SNMP_FIELD_LENGTH);
}
/* Free strings */
slapi_ch_free((void **) &name);
slapi_ch_free((void **) &desc);
slapi_ch_free((void **) &org);
slapi_ch_free((void **) &loc);
slapi_ch_free((void **) &contact);
}
static nsresult GetMimeExtensions(const char *mimeType, char *extensions, int extLen)
{
// check variables
if (!mimeType || !extensions || extLen < 1) return NS_ERROR_FAILURE;
extensions[0] = '\0';
// make mime object
BMimeType mime(mimeType) ;
if (mime.InitCheck() != B_OK)
return NS_ERROR_FAILURE;
// get extensions : comma separated (if multiple extensions in a mime-type)
// ex) "jpg,jpeg"
BString extStr("");
BMessage extMsg;
mime.GetFileExtensions(&extMsg);
uint32 type;
int32 types_num;
if (extMsg.GetInfo("extensions", &type, &types_num) != B_OK
|| type != B_STRING_TYPE || types_num == 0)
return NS_ERROR_FAILURE;
for (int i = 0 ; i < types_num ; i ++) {
const char *ext;
if (extMsg.FindString("extensions", i, &ext) != B_OK) {
break;
}
if (i > 0)
extStr.Append(",");
extStr.Append(ext);
}
PL_strncpyz(extensions, extStr.String(), extLen) ;
return NS_OK;
}
nsresult NrIceStunServer::ToNicerStunStruct(nr_ice_stun_server *server) const {
int r;
memset(server, 0, sizeof(nr_ice_stun_server));
if (transport_ == kNrIceTransportUdp) {
server->transport = IPPROTO_UDP;
} else if (transport_ == kNrIceTransportTcp) {
server->transport = IPPROTO_TCP;
} else {
MOZ_ASSERT(false);
return NS_ERROR_FAILURE;
}
if (has_addr_) {
r = nr_praddr_to_transport_addr(&addr_, &server->u.addr,
server->transport, 0);
if (r) {
return NS_ERROR_FAILURE;
}
server->type=NR_ICE_STUN_SERVER_TYPE_ADDR;
}
else {
MOZ_ASSERT(sizeof(server->u.dnsname.host) > host_.size());
PL_strncpyz(server->u.dnsname.host, host_.c_str(),
sizeof(server->u.dnsname.host));
server->u.dnsname.port = port_;
server->type=NR_ICE_STUN_SERVER_TYPE_DNSNAME;
}
return NS_OK;
}
void nsIDNService::prefsChanged(nsIPrefBranch *prefBranch, const PRUnichar *pref)
{
if (!pref || NS_LITERAL_STRING(NS_NET_PREF_IDNTESTBED).Equals(pref)) {
PRBool val;
if (NS_SUCCEEDED(prefBranch->GetBoolPref(NS_NET_PREF_IDNTESTBED, &val)))
mMultilingualTestBed = val;
}
if (!pref || NS_LITERAL_STRING(NS_NET_PREF_IDNPREFIX).Equals(pref)) {
nsXPIDLCString prefix;
nsresult rv = prefBranch->GetCharPref(NS_NET_PREF_IDNPREFIX, getter_Copies(prefix));
if (NS_SUCCEEDED(rv) && prefix.Length() <= kACEPrefixLen)
PL_strncpyz(nsIDNService::mACEPrefix, prefix.get(), kACEPrefixLen + 1);
}
if (!pref || NS_LITERAL_STRING(NS_NET_PREF_IDNBLACKLIST).Equals(pref)) {
nsCOMPtr<nsISupportsString> blacklist;
nsresult rv = prefBranch->GetComplexValue(NS_NET_PREF_IDNBLACKLIST,
NS_GET_IID(nsISupportsString),
getter_AddRefs(blacklist));
if (NS_SUCCEEDED(rv))
blacklist->ToString(getter_Copies(mIDNBlacklist));
else
mIDNBlacklist.Truncate();
}
if (!pref || NS_LITERAL_STRING(NS_NET_PREF_SHOWPUNYCODE).Equals(pref)) {
PRBool val;
if (NS_SUCCEEDED(prefBranch->GetBoolPref(NS_NET_PREF_SHOWPUNYCODE, &val)))
mShowPunycode = val;
}
}
void
IPC_InitLog(const char *prefix)
{
if (PR_GetEnv("IPC_LOG_ENABLE")) {
ipcLogEnabled = PR_TRUE;
PL_strncpyz(ipcLogPrefix, prefix, sizeof(ipcLogPrefix));
}
}
/* msg_make_full_address
*
* Given an e-mail address and a person's name, cons them together into a
* single string of the form "name <address>", doing all the necessary quoting.
* A new string is returned, which you must free when you're done with it.
*/
static char *
msg_make_full_address(const char* name, const char* addr)
{
int nl = name ? strlen (name) : 0;
int al = addr ? strlen (addr) : 0;
char *buf, *s;
PRUint32 buflen, slen;
int L;
if (al == 0)
return 0;
buflen = (nl * 2) + (al * 2) + 25;
buf = (char *)PR_Malloc(buflen);
if (!buf)
return 0;
if (nl > 0)
{
PL_strncpyz(buf, name, buflen);
L = msg_quote_phrase_or_addr(buf, nl, PR_FALSE);
s = buf + L;
slen = buflen - L;
if ( slen > 2 ) {
*s++ = ' ';
*s++ = '<';
slen -= 2; // for ' ' and '<'
}
}
else
{
s = buf;
slen = buflen;
}
PL_strncpyz(s, addr, slen);
L = msg_quote_phrase_or_addr(s, al, PR_TRUE);
s += L;
if (nl > 0)
*s++ = '>';
*s = 0;
L = (s - buf) + 1;
buf = (char *)PR_Realloc (buf, L);
return buf;
}
PL_strcatn(char *dest, PRUint32 max, const char *src)
{
char *rv;
PRUint32 dl;
if( ((char *)0 == dest) || ((const char *)0 == src) )
return dest;
for( rv = dest, dl = 0; *dest; dest++, dl++ )
;
if( max <= dl ) return rv;
(void)PL_strncpyz(dest, src, max-dl);
return rv;
}
/* dir_ValidateAndAddNewServer
*
* This function verifies that the position, serverName and description values
* are set for the given prefName. If they are then it adds the server to the
* unified server list.
*/
static PRBool dir_ValidateAndAddNewServer(nsVoidArray *wholeList, const char *fullprefname)
{
PRBool rc = PR_FALSE;
const char *endname = PL_strchr(&fullprefname[PL_strlen(PREF_LDAP_SERVER_TREE_NAME) + 1], '.');
if (endname)
{
char *prefname = (char *)PR_Malloc(endname - fullprefname + 1);
if (prefname)
{
PRInt32 dirType;
char *t1 = nsnull, *t2 = nsnull;
PL_strncpyz(prefname, fullprefname, endname - fullprefname + 1);
dirType = DIR_GetIntPref(prefname, "dirType", -1);
if (dirType != -1 &&
DIR_GetIntPref(prefname, "position", 0) != 0 &&
(t1 = DIR_GetStringPref(prefname, "description", nsnull)) != nsnull)
{
if (dirType == PABDirectory || dirType == IMDirectory ||
(t2 = DIR_GetStringPref(prefname, "serverName", nsnull)) != nsnull)
{
DIR_Server *server = (DIR_Server *)PR_Malloc(sizeof(DIR_Server));
if (server)
{
DIR_InitServer(server, (DirectoryType)dirType);
server->prefName = prefname;
DIR_GetPrefsForOneServer(server);
DIR_SetServerPosition(wholeList, server, server->position);
rc = PR_TRUE;
}
PR_FREEIF(t2);
}
PR_Free(t1);
}
else
PR_Free(prefname);
}
}
return rc;
}
nsresult NrIceStunServer::ToNicerStruct(nr_ice_stun_server *server) const {
int r;
if (has_addr_) {
r = nr_praddr_to_transport_addr(&addr_, &server->u.addr, 0);
if (r) {
return NS_ERROR_FAILURE;
}
server->type=NR_ICE_STUN_SERVER_TYPE_ADDR;
}
else {
MOZ_ASSERT(sizeof(server->u.dnsname.host) > host_.size());
PL_strncpyz(server->u.dnsname.host, host_.c_str(),
sizeof(server->u.dnsname.host));
server->u.dnsname.port = port_;
server->type=NR_ICE_STUN_SERVER_TYPE_DNSNAME;
}
return NS_OK;
}
NS_IMETHODIMP mozXMLTermStream::Read(char* buf, PRUint32 count,
PRUint32* _retval)
{
XMLT_LOG(mozXMLTermStream::Read,60,("count=%d\n", count));
if (!_retval)
return NS_ERROR_NULL_POINTER;
PR_ASSERT(mUTF8Buffer.Length() >= mUTF8Offset);
PRUint32 remCount = mUTF8Buffer.Length() - mUTF8Offset;
if (remCount == 0) {
// Empty buffer
*_retval = 0;
return NS_OK;
}
if (count >= remCount) {
// Return entire remaining buffer
*_retval = remCount;
} else {
// Return only portion of buffer
*_retval = count;
}
// Copy portion of string
PL_strncpyz(buf, mUTF8Buffer.get() + mUTF8Offset, *_retval);
mUTF8Offset += *_retval;
XMLT_LOG(mozXMLTermStream::Read,61,("*retval=%d\n", *_retval));
return NS_OK;
}
static int
MimeMessage_parse_line (const char *aLine, PRInt32 aLength, MimeObject *obj)
{
const char * line = aLine;
PRInt32 length = aLength;
MimeMessage *msg = (MimeMessage *) obj;
int status = 0;
PR_ASSERT(line && *line);
if (!line || !*line) return -1;
#ifdef MOZ_SECURITY
HG11013
#endif /* MOZ_SECURITY */
if (msg->grabSubject)
{
if ( (!PL_strncasecmp(line, "Subject: ", 9)) && (obj->parent) )
{
if ( (obj->headers) && (!obj->headers->munged_subject) )
{
obj->headers->munged_subject = (char *) PL_strndup(line + 9, length - 9);
char *tPtr = obj->headers->munged_subject;
while (*tPtr)
{
if ( (*tPtr == '\r') || (*tPtr == '\n') )
{
*tPtr = '\0';
break;
}
tPtr++;
}
}
}
}
/* If we already have a child object, then we're done parsing headers,
and all subsequent lines get passed to the inferior object without
further processing by us. (Our parent will stop feeding us lines
when this MimeMessage part is out of data.)
*/
if (msg->container.nchildren)
{
MimeObject *kid = msg->container.children[0];
PRBool nl;
PR_ASSERT(kid);
if (!kid) return -1;
msg->bodyLength += length;
/* Don't allow MimeMessage objects to not end in a newline, since it
would be inappropriate for any following part to appear on the same
line as the last line of the message.
#### This assumes that the only time the `parse_line' method is
called with a line that doesn't end in a newline is when that line
is the last line.
*/
nl = (length > 0 && (line[length-1] == '\r' || line[length-1] == '\n'));
#ifdef MIME_DRAFTS
if ( !mime_typep (kid, (MimeObjectClass*) &mimeMessageClass) &&
obj->options &&
obj->options->decompose_file_p &&
! obj->options->is_multipart_msg &&
obj->options->decompose_file_output_fn )
{
if (!obj->options->decrypt_p) {
//if we are processing a flowed plain text line, we need to remove any stuffed space
if (length > 0 && ' ' == *line && mime_typep(kid, (MimeObjectClass *)&mimeInlineTextPlainFlowedClass))
{
line ++;
length --;
}
status = obj->options->decompose_file_output_fn (line,
length,
obj->options->stream_closure);
if (status < 0) return status;
if (!nl) {
status = obj->options->decompose_file_output_fn (MSG_LINEBREAK,
MSG_LINEBREAK_LEN,
obj->options->stream_closure);
if (status < 0) return status;
}
return status;
}
}
#endif /* MIME_DRAFTS */
if (nl)
return kid->clazz->parse_buffer (line, length, kid);
else
{
/* Hack a newline onto the end. */
char *s = (char *)PR_MALLOC(length + MSG_LINEBREAK_LEN + 1);
if (!s) return MIME_OUT_OF_MEMORY;
memcpy(s, line, length);
PL_strncpyz(s + length, MSG_LINEBREAK, MSG_LINEBREAK_LEN);
status = kid->clazz->parse_buffer (s, length + MSG_LINEBREAK_LEN, kid);
PR_Free(s);
return status;
}
}
/* Otherwise we don't yet have a child object, which means we're not
done parsing our headers yet.
*/
if (!msg->hdrs)
{
msg->hdrs = MimeHeaders_new();
if (!msg->hdrs) return MIME_OUT_OF_MEMORY;
}
#ifdef MIME_DRAFTS
if ( obj->options &&
obj->options->decompose_file_p &&
! obj->options->is_multipart_msg &&
obj->options->done_parsing_outer_headers &&
obj->options->decompose_file_output_fn )
{
status = obj->options->decompose_file_output_fn( line, length,
obj->options->stream_closure );
if (status < 0)
return status;
}
#endif /* MIME_DRAFTS */
status = MimeHeaders_parse_line(line, length, msg->hdrs);
if (status < 0) return status;
/* If this line is blank, we're now done parsing headers, and should
examine our content-type to create our "body" part.
*/
if (*line == '\r' || *line == '\n')
{
status = MimeMessage_close_headers(obj);
if (status < 0) return status;
}
return 0;
}
static int MimeUntypedText_open_subpart(MimeObject *obj,
MimeUntypedTextSubpartType ttype,
const char *type, const char *enc,
const char *name, const char *desc) {
MimeUntypedText *uty = (MimeUntypedText *)obj;
int status = 0;
char *h = 0;
if (!type || !*type || !PL_strcasecmp(type, UNKNOWN_CONTENT_TYPE))
type = APPLICATION_OCTET_STREAM;
if (enc && !*enc) enc = 0;
if (desc && !*desc) desc = 0;
if (name && !*name) name = 0;
if (uty->open_subpart) {
status = MimeUntypedText_close_subpart(obj);
if (status < 0) return status;
}
NS_ASSERTION(!uty->open_subpart, "no open subpart");
NS_ASSERTION(!uty->open_hdrs, "no open headers");
/* To make one of these implicitly-typed sub-objects, we make up a fake
header block, containing only the minimum number of MIME headers needed.
We could do most of this (Type and Encoding) by making a null header
block, and simply setting obj->content_type and obj->encoding; but making
a fake header block is better for two reasons: first, it means that
something will actually be displayed when in `Show All Headers' mode;
and second, it's the only way to communicate the filename parameter,
aside from adding a new slot to MimeObject (which is something to be
avoided when possible.)
*/
uty->open_hdrs = MimeHeaders_new();
if (!uty->open_hdrs) return MIME_OUT_OF_MEMORY;
uint32_t hlen = strlen(type) + (enc ? strlen(enc) : 0) +
(desc ? strlen(desc) : 0) + (name ? strlen(name) : 0) + 100;
h = (char *)PR_MALLOC(hlen);
if (!h) return MIME_OUT_OF_MEMORY;
PL_strncpyz(h, HEADER_CONTENT_TYPE ": ", hlen);
PL_strcatn(h, hlen, type);
PL_strcatn(h, hlen, MSG_LINEBREAK);
status = MimeHeaders_parse_line(h, strlen(h), uty->open_hdrs);
if (status < 0) goto FAIL;
if (enc) {
PL_strncpyz(h, HEADER_CONTENT_TRANSFER_ENCODING ": ", hlen);
PL_strcatn(h, hlen, enc);
PL_strcatn(h, hlen, MSG_LINEBREAK);
status = MimeHeaders_parse_line(h, strlen(h), uty->open_hdrs);
if (status < 0) goto FAIL;
}
if (desc) {
PL_strncpyz(h, HEADER_CONTENT_DESCRIPTION ": ", hlen);
PL_strcatn(h, hlen, desc);
PL_strcatn(h, hlen, MSG_LINEBREAK);
status = MimeHeaders_parse_line(h, strlen(h), uty->open_hdrs);
if (status < 0) goto FAIL;
}
if (name) {
PL_strncpyz(h, HEADER_CONTENT_DISPOSITION ": inline; filename=\"", hlen);
PL_strcatn(h, hlen, name);
PL_strcatn(h, hlen, "\"" MSG_LINEBREAK);
status = MimeHeaders_parse_line(h, strlen(h), uty->open_hdrs);
if (status < 0) goto FAIL;
}
/* push out a blank line. */
PL_strncpyz(h, MSG_LINEBREAK, hlen);
status = MimeHeaders_parse_line(h, strlen(h), uty->open_hdrs);
if (status < 0) goto FAIL;
/* Create a child... */
{
bool horrid_kludge = (obj->options && obj->options->state &&
obj->options->state->first_part_written_p);
if (horrid_kludge) obj->options->state->first_part_written_p = false;
uty->open_subpart = mime_create(type, uty->open_hdrs, obj->options);
if (horrid_kludge) obj->options->state->first_part_written_p = true;
if (!uty->open_subpart) {
status = MIME_OUT_OF_MEMORY;
goto FAIL;
}
}
/* Add it to the list... */
status =
((MimeContainerClass *)obj->clazz)->add_child(obj, uty->open_subpart);
if (status < 0) {
mime_free(uty->open_subpart);
uty->open_subpart = 0;
goto FAIL;
}
/* And start its parser going. */
status = uty->open_subpart->clazz->parse_begin(uty->open_subpart);
if (status < 0) {
/* MimeContainer->finalize will take care of shutting it down now. */
uty->open_subpart = 0;
goto FAIL;
}
uty->type = ttype;
FAIL:
PR_FREEIF(h);
if (status < 0 && uty->open_hdrs) {
MimeHeaders_free(uty->open_hdrs);
uty->open_hdrs = 0;
}
return status;
}
/* This function has this clunky interface because it needs to be called
from outside this module (no MimeObject, etc.)
*/
int
MimeRichtextConvert (const char *line, PRInt32 length,
int (*output_fn) (const char *buf, PRInt32 size, void *closure),
void *closure,
char **obufferP,
PRInt32 *obuffer_sizeP,
PRBool enriched_p)
{
/* RFC 1341 (the original MIME spec) defined text/richtext.
RFC 1563 superceded text/richtext with text/enriched.
The changes from text/richtext to text/enriched are:
- CRLF semantics are different
- << maps to <
- These tags were added:
<VERBATIM>, <NOFILL>, <PARAM>, <FLUSHBOTH>
- These tags were removed:
<COMMENT>, <OUTDENT>, <OUTDENTRIGHT>, <SAMEPAGE>, <SUBSCRIPT>,
<SUPERSCRIPT>, <HEADING>, <FOOTING>, <PARAGRAPH>, <SIGNATURE>,
<LT>, <NL>, <NP>
This method implements them both.
draft-resnick-text-enriched-03.txt is a proposed update to 1563.
- These tags were added:
<FONTFAMILY>, <COLOR>, <PARAINDENT>, <LANG>.
However, all of these rely on the magic <PARAM> tag, which we
don't implement, so we're ignoring all of these.
Interesting fact: it's by Peter W. Resnick from Qualcomm (Eudora).
And it also says "It is fully expected that other text formatting
standards like HTML and SGML will supplant text/enriched in
Internet mail."
*/
int status = 0;
char *out;
const char *data_end;
const char *last_end;
const char *this_start;
const char *this_end;
unsigned int desired_size;
// The code below must never expand the input by more than 5x;
// if it does, the desired_size multiplier (5) below must be changed too
#define BGROWTH 5
if ( (PRUint32)length >= ( (PRUint32) 0xfffffffe)/BGROWTH )
return -1;
desired_size = (length * BGROWTH) + 1;
#undef BGROWTH
if (desired_size >= (PRUint32) *obuffer_sizeP)
status = mime_GrowBuffer (desired_size, sizeof(char), 1024,
obufferP, obuffer_sizeP);
if (status < 0) return status;
if (enriched_p)
{
for (this_start = line; this_start < line + length; this_start++)
if (!IS_SPACE (*this_start)) break;
if (this_start >= line + length) /* blank line */
{
PL_strncpyz (*obufferP, "<BR>", *obuffer_sizeP);
return output_fn (*obufferP, strlen(*obufferP), closure);
}
}
PRUint32 outlen = (PRUint32) *obuffer_sizeP;
out = *obufferP;
*out = 0;
data_end = line + length;
last_end = line;
this_start = last_end;
this_end = this_start;
PRUint32 addedlen = 0;
while (this_end < data_end)
{
/* Skip forward to next special character. */
while (this_start < data_end &&
*this_start != '<' && *this_start != '>' &&
*this_start != '&')
this_start++;
this_end = this_start;
/* Skip to the end of the tag. */
if (this_start < data_end && *this_start == '<')
{
this_end++;
while (this_end < data_end &&
!IS_SPACE(*this_end) &&
*this_end != '<' && *this_end != '>' &&
*this_end != '&')
this_end++;
}
this_end++;
/* Push out the text preceeding the tag. */
if (last_end && last_end != this_start)
{
memcpy (out, last_end, this_start - last_end);
out += this_start - last_end;
*out = 0;
outlen -= (this_start - last_end);
}
if (this_start >= data_end)
break;
else if (*this_start == '&')
{
PL_strncpyz (out, "&", outlen);
addedlen = strlen(out);
outlen -= addedlen;
out += addedlen;
}
else if (*this_start == '>')
{
PL_strncpyz (out, ">", outlen);
addedlen = strlen(out);
outlen -= addedlen;
out += addedlen;
}
else if (enriched_p &&
this_start < data_end + 1 &&
this_start[0] == '<' &&
this_start[1] == '<')
{
PL_strncpyz (out, "<", outlen);
addedlen = strlen(out);
outlen -= addedlen;
out += addedlen;
}
else if (this_start != this_end)
{
/* Push out this ID. */
const char *old = this_start + 1;
const char *tag_open = 0;
const char *tag_close = 0;
if (*old == '/')
{
/* This is </tag> */
old++;
}
switch (*old)
{
case 'b': case 'B':
if (!PL_strncasecmp ("BIGGER>", old, 7))
tag_open = "<FONT SIZE=\"+1\">", tag_close = "</FONT>";
else if (!PL_strncasecmp ("BLINK>", old, 5))
/* Of course, both text/richtext and text/enriched must be
enhanced *somehow*... Or else what would people think. */
tag_open = "<BLINK>", tag_close = "</BLINK>";
else if (!PL_strncasecmp ("BOLD>", old, 5))
tag_open = "<B>", tag_close = "</B>";
break;
case 'c': case 'C':
if (!PL_strncasecmp ("CENTER>", old, 7))
tag_open = "<CENTER>", tag_close = "</CENTER>";
else if (!enriched_p &&
!PL_strncasecmp ("COMMENT>", old, 8))
tag_open = "<!-- ", tag_close = " -->";
break;
case 'e': case 'E':
if (!PL_strncasecmp ("EXCERPT>", old, 8))
tag_open = "<BLOCKQUOTE>", tag_close = "</BLOCKQUOTE>";
break;
case 'f': case 'F':
if (!PL_strncasecmp ("FIXED>", old, 6))
tag_open = "<TT>", tag_close = "</TT>";
else if (enriched_p &&
!PL_strncasecmp ("FLUSHBOTH>", old, 10))
tag_open = "<P ALIGN=LEFT>", tag_close = "</P>";
else if (!PL_strncasecmp ("FLUSHLEFT>", old, 10))
tag_open = "<P ALIGN=LEFT>", tag_close = "</P>";
else if (!PL_strncasecmp ("FLUSHRIGHT>", old, 11))
tag_open = "<P ALIGN=RIGHT>", tag_close = "</P>";
else if (!enriched_p &&
!PL_strncasecmp ("FOOTING>", old, 8))
tag_open = "<H6>", tag_close = "</H6>";
break;
case 'h': case 'H':
if (!enriched_p &&
!PL_strncasecmp ("HEADING>", old, 8))
tag_open = "<H6>", tag_close = "</H6>";
break;
case 'i': case 'I':
if (!PL_strncasecmp ("INDENT>", old, 7))
tag_open = "<UL>", tag_close = "</UL>";
else if (!PL_strncasecmp ("INDENTRIGHT>", old, 12))
tag_open = 0, tag_close = 0;
/* else if (!enriched_p &&
!PL_strncasecmp ("ISO-8859-", old, 9))
tag_open = 0, tag_close = 0; */
else if (!PL_strncasecmp ("ITALIC>", old, 7))
tag_open = "<I>", tag_close = "</I>";
break;
case 'l': case 'L':
if (!enriched_p &&
!PL_strncasecmp ("LT>", old, 3))
tag_open = "<", tag_close = 0;
break;
case 'n': case 'N':
if (!enriched_p &&
!PL_strncasecmp ("NL>", old, 3))
tag_open = "<BR>", tag_close = 0;
if (enriched_p &&
!PL_strncasecmp ("NOFILL>", old, 7))
tag_open = "<NOBR>", tag_close = "</NOBR>";
/* else if (!enriched_p &&
!PL_strncasecmp ("NO-OP>", old, 6))
tag_open = 0, tag_close = 0; */
/* else if (!enriched_p &&
!PL_strncasecmp ("NP>", old, 3))
tag_open = 0, tag_close = 0; */
break;
case 'o': case 'O':
if (!enriched_p &&
!PL_strncasecmp ("OUTDENT>", old, 8))
tag_open = 0, tag_close = 0;
else if (!enriched_p &&
!PL_strncasecmp ("OUTDENTRIGHT>", old, 13))
tag_open = 0, tag_close = 0;
break;
case 'p': case 'P':
if (enriched_p &&
!PL_strncasecmp ("PARAM>", old, 6))
tag_open = "<!-- ", tag_close = " -->";
else if (!enriched_p &&
!PL_strncasecmp ("PARAGRAPH>", old, 10))
tag_open = "<P>", tag_close = 0;
break;
case 's': case 'S':
if (!enriched_p &&
!PL_strncasecmp ("SAMEPAGE>", old, 9))
tag_open = 0, tag_close = 0;
else if (!enriched_p &&
!PL_strncasecmp ("SIGNATURE>", old, 10))
tag_open = "<I><FONT SIZE=\"-1\">", tag_close = "</FONT></I>";
else if (!PL_strncasecmp ("SMALLER>", old, 8))
tag_open = "<FONT SIZE=\"-1\">", tag_close = "</FONT>";
else if (!enriched_p &&
!PL_strncasecmp ("SUBSCRIPT>", old, 10))
tag_open = "<SUB>", tag_close = "</SUB>";
else if (!enriched_p &&
!PL_strncasecmp ("SUPERSCRIPT>", old, 12))
tag_open = "<SUP>", tag_close = "</SUP>";
break;
case 'u': case 'U':
if (!PL_strncasecmp ("UNDERLINE>", old, 10))
tag_open = "<U>", tag_close = "</U>";
/* else if (!enriched_p &&
!PL_strncasecmp ("US-ASCII>", old, 10))
tag_open = 0, tag_close = 0; */
break;
case 'v': case 'V':
if (enriched_p &&
!PL_strncasecmp ("VERBATIM>", old, 9))
tag_open = "<PRE>", tag_close = "</PRE>";
break;
}
if (this_start[1] == '/')
{
if (tag_close) PL_strncpyz (out, tag_close, outlen);
addedlen = strlen (out);
outlen -= addedlen;
out += addedlen;
}
else
{
if (tag_open) PL_strncpyz (out, tag_open, outlen);
addedlen = strlen (out);
outlen -= addedlen;
out += addedlen;
}
}
/* now go around again */
last_end = this_end;
this_start = last_end;
}
*out = 0;
return output_fn (*obufferP, out - *obufferP, closure);
}
//-------------------------------------------------------------------------
//
// Show - Display the file dialog
//
//-------------------------------------------------------------------------
NS_IMETHODIMP nsFilePicker::Show(PRInt16 *retval)
{
NS_ENSURE_ARG_POINTER(retval);
PRBool result = PR_FALSE;
nsCAutoString fileBuffer;
char *converted = ConvertToFileSystemCharset(mDefault);
if (nsnull == converted) {
LossyCopyUTF16toASCII(mDefault, fileBuffer);
}
else {
fileBuffer.Assign(converted);
nsMemory::Free( converted );
}
char *title = ConvertToFileSystemCharset(mTitle);
if (nsnull == title)
title = ToNewCString(mTitle);
nsCAutoString initialDir;
if (mDisplayDirectory)
mDisplayDirectory->GetNativePath(initialDir);
// If no display directory, re-use the last one.
if(initialDir.IsEmpty())
initialDir = mLastUsedDirectory;
mFile.Truncate();
FILEDLG filedlg;
memset(&filedlg, 0, sizeof(FILEDLG));
filedlg.cbSize = sizeof(FILEDLG);
filedlg.pszTitle = title;
if (mMode == modeGetFolder) {
PL_strncat(filedlg.szFullFile, initialDir.get(), MAX_PATH);
PL_strncat(filedlg.szFullFile, "\\", 1);
PL_strncat(filedlg.szFullFile, "^", 1);
filedlg.fl = FDS_OPEN_DIALOG | FDS_CENTER;
filedlg.pfnDlgProc = DirDialogProc;
DosError(FERR_DISABLEHARDERR);
WinFileDlg(HWND_DESKTOP, mWnd, &filedlg);
DosError(FERR_ENABLEHARDERR);
char* tempptr = strstr(filedlg.szFullFile, "^");
if (tempptr)
*tempptr = '\0';
if (filedlg.lReturn == DID_OK) {
result = PR_TRUE;
if (!mDisplayDirectory)
mDisplayDirectory = do_CreateInstance("@mozilla.org/file/local;1");
if (mDisplayDirectory)
mDisplayDirectory->InitWithNativePath(nsDependentCString(filedlg.szFullFile));
mFile.Assign(filedlg.szFullFile);
}
}
else {
PL_strncpy(filedlg.szFullFile, initialDir.get(), MAX_PATH);
PL_strncat(filedlg.szFullFile, "\\", 1);
PL_strncat(filedlg.szFullFile, fileBuffer.get(), MAX_PATH);
filedlg.fl = FDS_CENTER;
if (mMode == modeSave) {
filedlg.fl |= FDS_SAVEAS_DIALOG | FDS_ENABLEFILELB;
} else if (mMode == modeOpenMultiple) {
filedlg.fl |= FDS_MULTIPLESEL | FDS_OPEN_DIALOG;
} else {
filedlg.fl |= FDS_OPEN_DIALOG;
}
PMYDATA pmydata;
pmydata = (PMYDATA)calloc(1, sizeof(MYDATA));
filedlg.ulUser = (ULONG)pmydata;
filedlg.pfnDlgProc = FileDialogProc;
PRUint32 i;
PSZ *apszTypeList;
apszTypeList = (PSZ *)malloc(mTitles.Length()*sizeof(PSZ)+1);
for (i = 0; i < mTitles.Length(); i++)
{
const nsString& typeWide = mTitles[i];
nsAutoCharBuffer buffer;
PRInt32 bufLength;
WideCharToMultiByte(0, typeWide.get(), typeWide.Length(),
buffer, bufLength);
apszTypeList[i] = ToNewCString(nsDependentCString(buffer.Elements()));
}
apszTypeList[i] = 0;
filedlg.papszITypeList = (PAPSZ)apszTypeList;
PSZ *apszFilterList;
apszFilterList = (PSZ *)malloc(mFilters.Length()*sizeof(PSZ)+1);
for (i = 0; i < mFilters.Length(); i++)
{
const nsString& filterWide = mFilters[i];
apszFilterList[i] = ToNewCString(filterWide);
}
apszFilterList[i] = 0;
pmydata->papszIFilterList = (PAPSZ)apszFilterList;
pmydata->ulCurExt = mSelectedType;
PRBool fileExists;
do {
DosError(FERR_DISABLEHARDERR);
WinFileDlg(HWND_DESKTOP, mWnd, &filedlg);
DosError(FERR_ENABLEHARDERR);
if ((filedlg.lReturn == DID_OK) && (mMode == modeSave)) {
PRFileInfo64 fileinfo64;
PRStatus status = PR_GetFileInfo64(filedlg.szFullFile, &fileinfo64);
if (status == PR_SUCCESS) {
fileExists = PR_TRUE;
} else {
fileExists = PR_FALSE;
}
if (fileExists) {
if (!gpszFDSaveCaption) {
HMODULE hmod;
char LoadError[CCHMAXPATH];
char loadedString[256];
int length;
DosLoadModule(LoadError, CCHMAXPATH, "PMSDMRI", &hmod);
length = WinLoadString((HAB)0, hmod, 1110, 256, loadedString);
gpszFDSaveCaption = (char*)malloc(length+1);
strcpy(gpszFDSaveCaption, loadedString);
length = WinLoadString((HAB)0, hmod, 1135, 256, loadedString);
gpszFDFileExists = (char*)malloc(length+1);
strcpy(gpszFDFileExists, loadedString);
length = WinLoadString((HAB)0, hmod, 1136, 256, loadedString);
gpszFDFileReadOnly = (char*)malloc(length+1);
strcpy(gpszFDFileReadOnly, loadedString);
int i;
for (i=0;i<256 && gpszFDFileExists[i];i++ ) {
if (gpszFDFileExists[i] == '%') {
gpszFDFileExists[i+1] = 's';
break;
}
}
for (i=0;i<256 && gpszFDFileReadOnly[i];i++ ) {
if (gpszFDFileReadOnly[i] == '%') {
gpszFDFileReadOnly[i+1] = 's';
break;
}
}
DosFreeModule(hmod);
}
char pszFullText[256+CCHMAXPATH];
FILESTATUS3 fsts3;
ULONG ulResponse;
DosQueryPathInfo( filedlg.szFullFile, FIL_STANDARD, &fsts3, sizeof(FILESTATUS3));
if (fsts3.attrFile & FILE_READONLY) {
sprintf(pszFullText, gpszFDFileReadOnly, filedlg.szFullFile);
ulResponse = WinMessageBox(HWND_DESKTOP, mWnd, pszFullText,
gpszFDSaveCaption, 0,
MB_OK | MB_MOVEABLE | MB_WARNING);
} else {
sprintf(pszFullText, gpszFDFileExists, filedlg.szFullFile);
ulResponse = WinMessageBox(HWND_DESKTOP, mWnd, pszFullText,
gpszFDSaveCaption, 0,
MB_YESNO | MB_MOVEABLE | MB_WARNING);
}
if (ulResponse == MBID_YES) {
fileExists = PR_FALSE;
}
}
}
} while (mMode == modeSave && fileExists && filedlg.lReturn == DID_OK);
if (filedlg.lReturn == DID_OK) {
result = PR_TRUE;
if (mMode == modeOpenMultiple) {
nsresult rv;
if (filedlg.papszFQFilename) {
for (ULONG i=0;i<filedlg.ulFQFCount;i++) {
nsCOMPtr<nsILocalFile> file = do_CreateInstance("@mozilla.org/file/local;1", &rv);
NS_ENSURE_SUCCESS(rv,rv);
rv = file->InitWithNativePath(nsDependentCString(*(filedlg.papszFQFilename)[i]));
NS_ENSURE_SUCCESS(rv,rv);
rv = mFiles.AppendObject(file);
NS_ENSURE_SUCCESS(rv,rv);
}
WinFreeFileDlgList(filedlg.papszFQFilename);
} else {
nsCOMPtr<nsILocalFile> file = do_CreateInstance("@mozilla.org/file/local;1", &rv);
NS_ENSURE_SUCCESS(rv,rv);
rv = file->InitWithNativePath(nsDependentCString(filedlg.szFullFile));
NS_ENSURE_SUCCESS(rv,rv);
rv = mFiles.AppendObject(file);
NS_ENSURE_SUCCESS(rv,rv);
}
} else {
mFile.Assign(filedlg.szFullFile);
}
mSelectedType = (PRInt16)pmydata->ulCurExt;
}
for (i = 0; i < mTitles.Length(); i++)
{
nsMemory::Free(*(filedlg.papszITypeList[i]));
}
free(filedlg.papszITypeList);
for (i = 0; i < mFilters.Length(); i++)
{
nsMemory::Free(*(pmydata->papszIFilterList[i]));
}
free(pmydata->papszIFilterList);
free(pmydata);
}
if (title)
nsMemory::Free( title );
if (result) {
PRInt16 returnOKorReplace = returnOK;
nsresult rv;
// Remember last used directory.
nsCOMPtr<nsILocalFile> file(do_CreateInstance("@mozilla.org/file/local;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
file->InitWithNativePath(mFile);
nsCOMPtr<nsIFile> dir;
if (NS_SUCCEEDED(file->GetParent(getter_AddRefs(dir)))) {
nsCOMPtr<nsILocalFile> localDir(do_QueryInterface(dir));
if (localDir) {
nsCAutoString newDir;
localDir->GetNativePath(newDir);
if(!newDir.IsEmpty())
PL_strncpyz(mLastUsedDirectory, newDir.get(), MAX_PATH+1);
// Update mDisplayDirectory with this directory, also.
// Some callers rely on this.
if (!mDisplayDirectory)
mDisplayDirectory = do_CreateInstance("@mozilla.org/file/local;1");
if (mDisplayDirectory)
mDisplayDirectory->InitWithNativePath( nsDependentCString(mLastUsedDirectory) );
}
}
if (mMode == modeSave) {
// Windows does not return resultReplace,
// we must check if file already exists
PRBool exists = PR_FALSE;
file->Exists(&exists);
if (exists)
returnOKorReplace = returnReplace;
}
*retval = returnOKorReplace;
}
else {
*retval = returnCancel;
}
return NS_OK;
}
int
collation_config (size_t cargc, char** cargv,
const char* fname, size_t lineno)
/* Process one line from a configuration file.
Return 0 if it's OK, -1 if it's not recognized.
Any other return value is a process exit code.
*/
{
if (cargc <= 0) { /* Bizarre. Oh, well... */
} else if (!strcasecmp (cargv[0], "NLS")) {
/* ignore - not needed anymore with ICU - was used to get path for NLS_Initialize */
} else if (!strcasecmp (cargv[0], "collation")) {
if ( cargc < 7 ) {
slapi_log_err(SLAPI_LOG_ERR, COLLATE_PLUGIN_SUBSYSTEM,
"collation_config - %s: line %lu ignored: only %lu arguments (expected "
"collation language country variant strength decomposition oid ...)\n",
fname, (unsigned long)lineno, (unsigned long)cargc );
} else {
auto size_t arg;
auto coll_profile_t* profile = (coll_profile_t*) slapi_ch_calloc (1, sizeof (coll_profile_t));
if (*cargv[1]) profile->language = slapi_ch_strdup (cargv[1]);
if (*cargv[2]) profile->country = slapi_ch_strdup (cargv[2]);
if (*cargv[3]) profile->variant = slapi_ch_strdup (cargv[3]);
switch (atoi(cargv[4])) {
case 1: profile->strength = UCOL_PRIMARY; break;
case 2: profile->strength = UCOL_SECONDARY; /* no break here? fall through? wtf? */
case 3: profile->strength = UCOL_TERTIARY; break;
case 4: profile->strength = UCOL_IDENTICAL; break;
default: profile->strength = UCOL_SECONDARY;
slapi_log_err(SLAPI_LOG_ERR, COLLATE_PLUGIN_SUBSYSTEM,
"collation_config - %s: line %lu: strength \"%s\" not supported (will use 2)\n",
fname, (unsigned long)lineno, cargv[4]);
break;
}
switch (atoi(cargv[5])) {
case 1: profile->decomposition = UCOL_OFF; break;
case 2: profile->decomposition = UCOL_DEFAULT; /* no break here? fall through? wtf? */
case 3: profile->decomposition = UCOL_ON; break;
default: profile->decomposition = UCOL_DEFAULT;
slapi_log_err(SLAPI_LOG_ERR, COLLATE_PLUGIN_SUBSYSTEM,
"collation_config - %s: line %lu: decomposition \"%s\" not supported (will use 2)\n",
fname, (unsigned long)lineno, cargv[5]);
break;
}
{
char descStr[256];
char nameOrder[256];
char nameSubstring[256];
char oidString[256];
char *tmpStr=NULL;
Slapi_MatchingRuleEntry *mrentry=slapi_matchingrule_new();
if(UCOL_PRIMARY == profile->strength) {
strcpy(nameOrder,"caseIgnoreOrderingMatch");
strcpy(nameSubstring,"caseIgnoreSubstringMatch");
}
else {
strcpy(nameOrder,"caseExactOrderingMatch");
strcpy(nameSubstring,"caseExactSubstringMatch");
}
/* PAR: this looks broken
the "extra" text based oids that are actually used
to form the name and description are always derived
from the language and country fields so there should
be no need to have two separate code paths to
set the name and description fields of the schema
as language is always available, and if country is
not, it is not in the name anyway.
Is it safe to assume all matching rules will follow
this convention? The answer, or lack of it, probably
explains the reasoning for doing things the way they
are currently.
*/
if(cargc > 7) {
PL_strcatn(nameOrder,sizeof(nameOrder),"-");
PL_strcatn(nameOrder,sizeof(nameOrder),cargv[7]);
PL_strcatn(nameSubstring,sizeof(nameSubstring),"-");
PL_strcatn(nameSubstring,sizeof(nameSubstring),cargv[7]);
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_NAME,
(void *)slapi_ch_strdup(nameOrder));
}
else {
if(0 != cargv[1][0]) {
PL_strcatn(nameOrder,sizeof(nameOrder),"-");
PL_strcatn(nameSubstring,sizeof(nameSubstring),"-");
} else {
nameOrder[0] = 0;
nameSubstring[0] = 0;
}
PL_strcatn(nameOrder,sizeof(nameOrder),cargv[1]);
PL_strcatn(nameSubstring,sizeof(nameSubstring),cargv[1]);
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_NAME,
(void *)slapi_ch_strdup(nameOrder));
}
PL_strncpyz(oidString,cargv[6], sizeof(oidString));
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_OID,
(void *)slapi_ch_strdup(oidString));
if(0 != cargv[2][0]) {
PR_snprintf(descStr, sizeof(descStr), "%s-%s",cargv[1],cargv[2]);
}
else {
PL_strncpyz(descStr,cargv[1], sizeof(descStr));
}
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_DESC,
(void *)slapi_ch_strdup(descStr));
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_SYNTAX,
(void *)slapi_ch_strdup(DIRSTRING_SYNTAX_OID));
slapi_matchingrule_register(mrentry);
slapi_matchingrule_get(mrentry,SLAPI_MATCHINGRULE_NAME,
(void *)&tmpStr);
slapi_ch_free((void **)&tmpStr);
slapi_matchingrule_get(mrentry,SLAPI_MATCHINGRULE_OID,
(void *)&tmpStr);
slapi_ch_free((void **)&tmpStr);
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_NAME,
(void *)slapi_ch_strdup(nameSubstring));
PL_strcatn(oidString,sizeof(oidString),".6");
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_OID,
(void *)slapi_ch_strdup(oidString));
slapi_matchingrule_register(mrentry);
slapi_matchingrule_free(&mrentry,1);
}
for (arg = 6; arg < cargc; ++arg) {
auto coll_id_t* id = (coll_id_t*) slapi_ch_malloc (sizeof (coll_id_t));
id->oid = slapi_ch_strdup (cargv[arg]);
id->profile = profile;
if (collation_ids <= 0) {
collation_id = (const coll_id_t**) slapi_ch_malloc (2 * sizeof (coll_id_t*));
} else {
collation_id = (const coll_id_t**) slapi_ch_realloc
((void*)collation_id, (collation_ids + 2) * sizeof (coll_id_t*));
}
collation_id [collation_ids++] = id;
collation_id [collation_ids] = NULL;
}
}
} else {
return -1; /* unrecognized */
}
return 0; /* success */
}
NS_IMETHODIMP
nsLocaleService::GetLocaleFromAcceptLanguage(const char *acceptLanguage, nsILocale **_retval)
{
char* input;
char* cPtr;
char* cPtr1;
char* cPtr2;
int i;
int j;
int countLang = 0;
char acceptLanguageList[NSILOCALE_MAX_ACCEPT_LANGUAGE][NSILOCALE_MAX_ACCEPT_LENGTH];
nsresult result;
input = new char[strlen(acceptLanguage)+1];
NS_ASSERTION(input!=nsnull,"nsLocaleFactory::GetLocaleFromAcceptLanguage: memory allocation failed.");
if (input == (char*)NULL){ return NS_ERROR_OUT_OF_MEMORY; }
strcpy(input, acceptLanguage);
cPtr1 = input-1;
cPtr2 = input;
/* put in standard form */
while (*(++cPtr1)) {
if (isalpha(*cPtr1)) *cPtr2++ = tolower(*cPtr1); /* force lower case */
else if (isspace(*cPtr1)) ; /* ignore any space */
else if (*cPtr1=='-') *cPtr2++ = '_'; /* "-" -> "_" */
else if (*cPtr1=='*') ; /* ignore "*" */
else *cPtr2++ = *cPtr1; /* else unchanged */
}
*cPtr2 = '\0';
countLang = 0;
if (strchr(input,';')) {
/* deal with the quality values */
float qvalue[NSILOCALE_MAX_ACCEPT_LANGUAGE];
float qSwap;
float bias = 0.0f;
char* ptrLanguage[NSILOCALE_MAX_ACCEPT_LANGUAGE];
char* ptrSwap;
cPtr = nsCRT::strtok(input,",",&cPtr2);
while (cPtr) {
qvalue[countLang] = 1.0f;
/* add extra parens to get rid of warning */
if ((cPtr1 = strchr(cPtr,';')) != nsnull) {
PR_sscanf(cPtr1,";q=%f",&qvalue[countLang]);
*cPtr1 = '\0';
}
if (strlen(cPtr)<NSILOCALE_MAX_ACCEPT_LANGUAGE) { /* ignore if too long */
qvalue[countLang] -= (bias += 0.0001f); /* to insure original order */
ptrLanguage[countLang++] = cPtr;
if (countLang>=NSILOCALE_MAX_ACCEPT_LANGUAGE) break; /* quit if too many */
}
cPtr = nsCRT::strtok(cPtr2,",",&cPtr2);
}
/* sort according to decending qvalue */
/* not a very good algorithm, but count is not likely large */
for ( i=0 ; i<countLang-1 ; i++ ) {
for ( j=i+1 ; j<countLang ; j++ ) {
if (qvalue[i]<qvalue[j]) {
qSwap = qvalue[i];
qvalue[i] = qvalue[j];
qvalue[j] = qSwap;
ptrSwap = ptrLanguage[i];
ptrLanguage[i] = ptrLanguage[j];
ptrLanguage[j] = ptrSwap;
}
}
}
for ( i=0 ; i<countLang ; i++ ) {
PL_strncpyz(acceptLanguageList[i],ptrLanguage[i],NSILOCALE_MAX_ACCEPT_LENGTH);
}
} else {
/* simple case: no quality values */
cPtr = nsCRT::strtok(input,",",&cPtr2);
while (cPtr) {
if (strlen(cPtr)<NSILOCALE_MAX_ACCEPT_LENGTH) { /* ignore if too long */
PL_strncpyz(acceptLanguageList[countLang++],cPtr,NSILOCALE_MAX_ACCEPT_LENGTH);
if (countLang>=NSILOCALE_MAX_ACCEPT_LENGTH) break; /* quit if too many */
}
cPtr = nsCRT::strtok(cPtr2,",",&cPtr2);
}
}
//
// now create the locale
//
result = NS_ERROR_FAILURE;
if (countLang>0) {
result = NewLocale(NS_ConvertASCIItoUTF16(acceptLanguageList[0]), _retval);
}
//
// clean up
//
delete[] input;
return result;
}
/* LASDNSBuild
* Builds a hash table of all the hostnames provided (plus their aliases
* if aliasflg is true). Wildcards are only permitted in the leftmost
* field. They're represented in the hash table by a leading period.
* E.g. ".mcom.com".
*
* RETURNS Zero on success, else LAS_EVAL_INVALID
*/
int
LASDnsBuild(NSErr_t *errp, char *attr_pattern, LASDnsContext_t *context, int aliasflg)
{
size_t delimiter; /* length of valid tokeni */
char token[256]; /* max length dns name */
int i;
char **p;
pool_handle_t *pool;
PRStatus error=PR_SUCCESS;
char buffer[PR_NETDB_BUF_SIZE];
#ifdef UTEST
struct hostent *he, host;
#else
PRHostEnt *he, host;
#endif
char *end_attr_pattern;
if (attr_pattern == NULL) {
nserrGenerate(errp, ACLERRINVAL, ACLERR4770, ACL_Program, 1,
XP_GetAdminStr(DBT_lasdnsbuildInvalidAttributePattern_));
return LAS_EVAL_INVALID;
}
context->Table = PR_NewHashTable(0,
PR_HashCaseString,
PR_CompareCaseStrings,
PR_CompareValues,
&ACLPermAllocOps,
NULL);
pool = pool_create();
context->pool = pool;
if ((!context->Table) || (!context->pool)) {
nserrGenerate(errp, ACLERRNOMEM, ACLERR4700, ACL_Program, 1,
XP_GetAdminStr(DBT_lasdnsbuildUnableToAllocateHashT_));
return LAS_EVAL_INVALID;
}
end_attr_pattern = attr_pattern + strlen(attr_pattern);
do {
size_t maxsize = sizeof(token);
/* Get a single hostname from the pattern string */
delimiter = strcspn(attr_pattern, ", \t");
if (delimiter >= maxsize) {
delimiter = maxsize-1;
}
PL_strncpyz(token, attr_pattern, delimiter + 1);
token[delimiter] = '\0';
/* Skip any white space after the token */
attr_pattern += delimiter;
if (attr_pattern < end_attr_pattern) {
attr_pattern += strspn(attr_pattern, ", \t");
}
/* If there's a wildcard, strip it off but leave the "."
* Can't have aliases for a wildcard pattern.
* Treat "*" as a special case. If so, go ahead and hash it.
*/
if (token[0] == '*') {
if (token[1] != '\0') {
if (!PR_HashTableAdd(context->Table, pool_strdup(pool, &token[1]), (void *)-1)) {
nserrGenerate(errp, ACLERRFAIL, ACLERR4710, ACL_Program, 2,
XP_GetAdminStr(DBT_lasdnsbuildUnableToAddKeySN_), token);
return LAS_EVAL_INVALID;
}
} else {
if (!PR_HashTableAdd(context->Table, pool_strdup(pool, token), (void *)-1)) {
nserrGenerate(errp, ACLERRFAIL, ACLERR4720, ACL_Program, 2, XP_GetAdminStr(DBT_lasdnsbuildUnableToAddKeySN_), token);
return LAS_EVAL_INVALID;
}
}
} else {
/* This is a single hostname add it to the hash table */
if (!PR_HashTableAdd(context->Table, pool_strdup(pool, &token[0]), (void *)-1)) {
nserrGenerate(errp, ACLERRFAIL, ACLERR4730, ACL_Program, 2, XP_GetAdminStr(DBT_lasdnsbuildUnableToAddKeySN_), token);
return LAS_EVAL_INVALID;
}
if (aliasflg) {
void *iter = NULL;
int addrcnt = 0;
PRNetAddr *netaddr = (PRNetAddr *)PERM_CALLOC(sizeof(PRNetAddr));
PRAddrInfo *infop = PR_GetAddrInfoByName(token,
PR_AF_UNSPEC, (PR_AI_ADDRCONFIG|PR_AI_NOCANONNAME));
if (!netaddr) {
if (infop) {
PR_FreeAddrInfo(infop);
}
return LAS_EVAL_NEED_MORE_INFO; /* hostname not known to dns? */
}
if (!infop) {
if (netaddr) {
PERM_FREE(netaddr);
}
return LAS_EVAL_NEED_MORE_INFO; /* hostname not known to dns? */
}
/* need to count the address, first */
while ((iter = PR_EnumerateAddrInfo(iter, infop, 0, netaddr))) {
addrcnt++;
}
if (0 == addrcnt) {
PERM_FREE(netaddr);
PR_FreeAddrInfo(infop);
return LAS_EVAL_NEED_MORE_INFO; /* hostname not known to dns? */
}
iter = NULL; /* from the beginning */
memset(netaddr, 0, sizeof(PRNetAddr));
for (i = 0; i < addrcnt; i++) {
iter = PR_EnumerateAddrInfo( iter, infop, 0, netaddr );
if (NULL == iter) {
break;
}
error = PR_GetHostByAddr(netaddr, buffer,
PR_NETDB_BUF_SIZE, &host);
if (error == PR_SUCCESS) {
he = &host;
} else {
continue;
}
if (he->h_name) {
/* Add it to the hash table */
if (!PR_HashTableAdd(context->Table,
pool_strdup(pool, he->h_name),
(void *)-1)) {
nserrGenerate(errp, ACLERRFAIL, ACLERR4750,
ACL_Program, 2,
XP_GetAdminStr(DBT_lasdnsbuildUnableToAddKeySN_),
he->h_name);
PERM_FREE(netaddr);
PR_FreeAddrInfo(infop);
return LAS_EVAL_INVALID;
}
}
if (he->h_aliases && he->h_aliases[0]) {
for (p = he->h_aliases; *p; ++p) {
/* Add it to the hash table */
if (!PR_HashTableAdd(context->Table,
pool_strdup(pool, *p),
(void *)-1)) {
nserrGenerate(errp, ACLERRFAIL, ACLERR4760,
ACL_Program, 2,
XP_GetAdminStr(DBT_lasdnsbuildUnableToAddKeySN_),
*p);
PERM_FREE(netaddr);
PR_FreeAddrInfo(infop);
return LAS_EVAL_INVALID;
}
}
}
} /* for (i = 0; i < addrcnt; i++) */
PERM_FREE(netaddr);
PR_FreeAddrInfo(infop);
} /* if aliasflg */
} /* else - single hostname */
} while ((attr_pattern != NULL) &&
(attr_pattern[0] != '\0') &&
(delimiter != 0));
return 0;
}
/* msg_remove_duplicate_addresses
*
* Returns a copy of ADDRS which may have had some addresses removed.
* Addresses are removed if they are already in either ADDRS or OTHER_ADDRS.
* (If OTHER_ADDRS contain addresses which are not in ADDRS, they are not
* added. That argument is for passing in addresses that were already
* mentioned in other header fields.)
*
* Addresses are considered to be the same if they contain the same mailbox
* part (case-insensitive.) Real names and other comments are not compared.
*/
static char *
msg_remove_duplicate_addresses(const nsACString &addrs,
const nsACString &other_addrs)
{
/* This is probably way more complicated than it should be... */
char *s1 = 0, *s2 = 0;
char *output = 0, *out = 0;
char *result = 0;
int count1 = 0, count2 = 0, count3 = 0;
int size3 = 0;
char *names1 = 0, *names2 = 0;
char *addrs1 = 0, *addrs2 = 0;
char **a_array1 = 0, **a_array2 = 0, **a_array3 = 0;
char **n_array1 = 0, **n_array3 = 0;
int i, j;
PRUint32 addedlen = 0;
count1 = msg_parse_Header_addresses(nsCString(addrs).get(), &names1, &addrs1);
if (count1 < 0) goto FAIL;
if (count1 == 0)
{
result = strdup("");
goto FAIL;
}
count2 = msg_parse_Header_addresses(nsCString(other_addrs).get(), &names2, &addrs2);
if (count2 < 0) goto FAIL;
a_array1 = (char **)PR_Malloc(count1 * sizeof(char *));
if (!a_array1) goto FAIL;
n_array1 = (char **)PR_Malloc(count1 * sizeof(char *));
if (!n_array1) goto FAIL;
if (count2 > 0)
{
a_array2 = (char **)PR_Malloc(count2 * sizeof(char *));
if (!a_array2) goto FAIL;
/* don't need an n_array2 */
}
a_array3 = (char **)PR_Malloc(count1 * sizeof(char *));
if (!a_array3) goto FAIL;
n_array3 = (char **)PR_Malloc(count1 * sizeof(char *));
if (!n_array3) goto FAIL;
/* fill in the input arrays */
s1 = names1;
s2 = addrs1;
for (i = 0; i < count1; i++)
{
n_array1[i] = s1;
a_array1[i] = s2;
s1 += strlen(s1) + 1;
s2 += strlen(s2) + 1;
}
s2 = addrs2;
for (i = 0; i < count2; i++)
{
a_array2[i] = s2;
s2 += strlen(s2) + 1;
}
/* Iterate over all addrs in the "1" arrays.
* If those addrs are not present in "3" or "2", add them to "3".
*/
for (i = 0; i < count1; i++)
{
PRBool found = PR_FALSE;
for (j = 0; j < count2; j++)
if (!PL_strcasecmp (a_array1[i], a_array2[j]))
{
found = PR_TRUE;
break;
}
if (!found)
for (j = 0; j < count3; j++)
if (!PL_strcasecmp(a_array1[i], a_array3[j]))
{
found = PR_TRUE;
break;
}
if (!found)
{
n_array3[count3] = n_array1[i];
a_array3[count3] = a_array1[i];
size3 += (strlen(n_array3[count3]) + strlen(a_array3[count3]) + 10);
count3++;
NS_ASSERTION (count3 <= count1, "");
if (count3 > count1) break;
}
}
PRUint32 outlen;
outlen = size3 + 1;
output = (char *)PR_Malloc(outlen);
if (!output) goto FAIL;
*output = 0;
out = output;
s2 = output;
for (i = 0; i < count3; i++)
{
PL_strncpyz(out, a_array3[i], outlen);
addedlen = strlen(out);
outlen -= addedlen;
out += addedlen;
*out++ = 0;
}
s1 = out;
for (i = 0; i < count3; i++)
{
PL_strncpyz(out, n_array3[i], outlen);
addedlen = strlen(out);
outlen -= addedlen;
out += addedlen;
*out++ = 0;
}
result = msg_format_Header_addresses(s1, s2, count3, PR_FALSE);
FAIL:
FREEIF(a_array1);
FREEIF(a_array2);
FREEIF(a_array3);
FREEIF(n_array1);
FREEIF(n_array3);
FREEIF(names1);
FREEIF(names2);
FREEIF(addrs1);
FREEIF(addrs2);
FREEIF(output);
return result;
}
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;
}
char *
MimeExternalBody_make_url(const char *ct,
const char *at, const char *lexp, const char *size,
const char *perm, const char *dir, const char *mode,
const char *name, const char *url, const char *site,
const char *svr, const char *subj, const char *body)
{
char *s;
PRUint32 slen;
if (!at)
{
return 0;
}
else if (!PL_strcasecmp(at, "ftp") || !PL_strcasecmp(at, "anon-ftp"))
{
if (!site || !name)
return 0;
slen = strlen(name) + strlen(site) + (dir ? strlen(dir) : 0) + 20;
s = (char *) PR_MALLOC(slen);
if (!s) return 0;
PL_strncpyz(s, "ftp://", slen);
PL_strcatn(s, slen, site);
PL_strcatn(s, slen, "/");
if (dir) PL_strcatn(s, slen, (dir[0] == '/' ? dir+1 : dir));
if (s[strlen(s)-1] != '/')
PL_strcatn(s, slen, "/");
PL_strcatn(s, slen, name);
return s;
}
else if (!PL_strcasecmp(at, "local-file") || !PL_strcasecmp(at, "afs"))
{
if (!name)
return 0;
#ifdef XP_UNIX
if (!PL_strcasecmp(at, "afs")) /* only if there is a /afs/ directory */
{
nsCOMPtr <nsILocalFile> fs = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID);
bool exists = false;
if (fs)
{
fs->InitWithNativePath(NS_LITERAL_CSTRING("/afs/."));
fs->Exists(&exists);
}
if (!exists)
return 0;
}
#else /* !XP_UNIX */
return 0; /* never, if not Unix. */
#endif /* !XP_UNIX */
slen = (strlen(name) * 3 + 20);
s = (char *) PR_MALLOC(slen);
if (!s) return 0;
PL_strncpyz(s, "file:", slen);
nsCString s2;
MsgEscapeString(nsDependentCString(name), nsINetUtil::ESCAPE_URL_PATH, s2);
PL_strcatn(s, slen, s2.get());
return s;
}
else if (!PL_strcasecmp(at, "mail-server"))
{
if (!svr)
return 0;
slen = (strlen(svr)*4 + (subj ? strlen(subj)*4 : 0) +
(body ? strlen(body)*4 : 0) + 25); // dpv xxx: why 4x? %xx escaping should be 3x
s = (char *) PR_MALLOC(slen);
if (!s) return 0;
PL_strncpyz(s, "mailto:", slen);
nsCString s2;
MsgEscapeString(nsDependentCString(svr), nsINetUtil::ESCAPE_XALPHAS, s2);
PL_strcatn(s, slen, s2.get());
if (subj)
{
MsgEscapeString(nsDependentCString(subj), nsINetUtil::ESCAPE_XALPHAS, s2);
PL_strcatn(s, slen, "?subject=");
PL_strcatn(s, slen, s2.get());
}
if (body)
{
MsgEscapeString(nsDependentCString(body), nsINetUtil::ESCAPE_XALPHAS, s2);
PL_strcatn(s, slen, (subj ? "&body=" : "?body="));
PL_strcatn(s, slen, s2.get());
}
return s;
}
else if (!PL_strcasecmp(at, "url")) /* RFC 2017 */
{
if (url)
return strdup(url); /* it's already quoted and everything */
else
return 0;
}
else
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;
}
//
// FUNCTION: SaveWebPage()
//
// PURPOSE: Saves the contents of the web page to a file
//
void SaveWebPage(nsIWebBrowser *aWebBrowser)
{
// Use the browser window title as the initial file name
nsCOMPtr<nsIBaseWindow> webBrowserAsWin = do_QueryInterface(aWebBrowser);
nsXPIDLString windowTitle;
webBrowserAsWin->GetTitle(getter_Copies(windowTitle));
nsCString fileName; fileName.AssignWithConversion(windowTitle);
// Sanitize the title of all illegal characters
fileName.CompressWhitespace(); // Remove whitespace from the ends
fileName.StripChars("\\*|:\"><?"); // Strip illegal characters
fileName.ReplaceChar('.', L'_'); // Dots become underscores
fileName.ReplaceChar('/', L'-'); // Forward slashes become hyphens
// Copy filename to a character buffer
char szFile[_MAX_PATH];
memset(szFile, 0, sizeof(szFile));
PL_strncpyz(szFile, fileName.get(), sizeof(szFile) - 1); // XXXldb probably should be just sizeof(szfile)
// Initialize the file save as information structure
OPENFILENAME saveFileNameInfo;
memset(&saveFileNameInfo, 0, sizeof(saveFileNameInfo));
saveFileNameInfo.lStructSize = sizeof(saveFileNameInfo);
saveFileNameInfo.hwndOwner = NULL;
saveFileNameInfo.hInstance = NULL;
saveFileNameInfo.lpstrFilter =
"Web Page, HTML Only (*.htm;*.html)\0*.htm;*.html\0"
"Web Page, Complete (*.htm;*.html)\0*.htm;*.html\0"
"Text File (*.txt)\0*.txt\0";
saveFileNameInfo.lpstrCustomFilter = NULL;
saveFileNameInfo.nMaxCustFilter = NULL;
saveFileNameInfo.nFilterIndex = 1;
saveFileNameInfo.lpstrFile = szFile;
saveFileNameInfo.nMaxFile = sizeof(szFile);
saveFileNameInfo.lpstrFileTitle = NULL;
saveFileNameInfo.nMaxFileTitle = 0;
saveFileNameInfo.lpstrInitialDir = NULL;
saveFileNameInfo.lpstrTitle = NULL;
saveFileNameInfo.Flags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
saveFileNameInfo.nFileOffset = NULL;
saveFileNameInfo.nFileExtension = NULL;
saveFileNameInfo.lpstrDefExt = "htm";
saveFileNameInfo.lCustData = NULL;
saveFileNameInfo.lpfnHook = NULL;
saveFileNameInfo.lpTemplateName = NULL;
if (GetSaveFileName(&saveFileNameInfo))
{
// Does the user want to save the complete document including
// all frames, images, scripts, stylesheets etc. ?
char *pszDataPath = NULL;
if (saveFileNameInfo.nFilterIndex == 2) // 2nd choice means save everything
{
static char szDataFile[_MAX_PATH];
char szDataPath[_MAX_PATH];
char drive[_MAX_DRIVE];
char dir[_MAX_DIR];
char fname[_MAX_FNAME];
char ext[_MAX_EXT];
_splitpath(szFile, drive, dir, fname, ext);
sprintf(szDataFile, "%s_files", fname);
_makepath(szDataPath, drive, dir, szDataFile, "");
pszDataPath = szDataPath;
}
// Save away
nsCOMPtr<nsIWebBrowserPersist> persist(do_QueryInterface(aWebBrowser));
nsCOMPtr<nsILocalFile> file;
NS_NewNativeLocalFile(nsDependentCString(szFile), TRUE, getter_AddRefs(file));
nsCOMPtr<nsILocalFile> dataPath;
if (pszDataPath)
{
NS_NewNativeLocalFile(nsDependentCString(pszDataPath), TRUE, getter_AddRefs(dataPath));
}
persist->SaveDocument(nsnull, file, dataPath, nsnull, 0, 0);
}
}
//-------------------------------------------------------------------------
//
// Show - Display the file dialog
//
//-------------------------------------------------------------------------
NS_IMETHODIMP nsFilePicker::Show(PRInt16 *aReturnVal)
{
PRInt32 flags = 0;
char *btn1;
NS_ENSURE_ARG_POINTER(aReturnVal);
if (mMode == modeGetFolder) {
flags |= Pt_FSR_SELECT_DIRS|Pt_FSR_NO_SELECT_FILES;
btn1 = "&Select";
}
else if (mMode == modeOpen) {
btn1 = "&Open";
}
else if (mMode == modeSave) {
flags |= Pt_FSR_NO_FCHECK;
btn1 = "&Save";
}
else if( mMode == modeOpenMultiple ) {
flags |= Pt_FSR_MULTIPLE;
btn1 = "&Select";
}
else {
printf("nsFilePicker::Show() wrong mode");
return PR_FALSE;
}
char *title = ToNewUTF8String( mTitle );
nsCAutoString initialDir;
if (mDisplayDirectory)
mDisplayDirectory->GetNativePath(initialDir);
// If no display directory, re-use the last one.
if(initialDir.IsEmpty()) {
// Allocate copy of last used dir.
initialDir = mLastUsedDirectory;
}
if( !mDefault.IsEmpty() ) {
initialDir.AppendWithConversion( NS_LITERAL_STRING( "/" ) );
initialDir.AppendWithConversion( mDefault );
}
char extensionBuffer[MAX_EXTENSION_LENGTH+1] = "*";
if( !mFilterList.IsEmpty() ) {
char *text = ToNewUTF8String( mFilterList );
if( text ) {
extensionBuffer[0] = 0;
/* eliminate the ';' and the duplicates */
char buffer[MAX_EXTENSION_LENGTH+1], buf[MAX_EXTENSION_LENGTH+1], *q, *delims = "; ", *dummy;
strcpy( buffer, text );
q = strtok_r( buffer, delims, &dummy );
while( q ) {
sprintf( buf, "%s ", q );
if( !strstr( extensionBuffer, buf ) )
strcat( extensionBuffer, buf );
q = strtok_r( NULL, delims, &dummy );
}
nsMemory::Free( text );
}
}
else if (!mDefaultExtension.IsEmpty()) {
// Someone was cool and told us what to do
char *convertedExt = ToNewUTF8String( mDefaultExtension );
if (!convertedExt) {
mDefaultExtension.ToCString(extensionBuffer, MAX_EXTENSION_LENGTH);
}
else {
PL_strncpyz(extensionBuffer, convertedExt, MAX_EXTENSION_LENGTH+1);
nsMemory::Free( convertedExt );
}
}
PtFileSelectionInfo_t info;
memset( &info, 0, sizeof( info ) );
if( PtFileSelection( mParentWidget, NULL, title, initialDir.get(),
extensionBuffer, btn1, "&Cancel", "nsd", &info, flags ) ) {
if (title) nsMemory::Free( title );
return NS_ERROR_FAILURE;
}
*aReturnVal = returnOK;
if( info.ret == Pt_FSDIALOG_BTN2 ) {
*aReturnVal = returnCancel;
}
else if( mMode != modeOpenMultiple ) {
mFile.SetLength(0);
mFile.Append( info.path );
if( mMode == modeSave ) {
nsCOMPtr<nsILocalFile> file(do_CreateInstance("@mozilla.org/file/local;1"));
NS_ENSURE_TRUE(file, NS_ERROR_FAILURE);
file->InitWithNativePath( mFile );
PRBool exists = PR_FALSE;
file->Exists(&exists);
if (exists)
*aReturnVal = returnReplace;
}
}
else { /* here mMode is modeOpenMultiple */
PtFileSelectorInfo_t *minfo = info.minfo;
if( minfo ) {
nsresult rv = NS_NewISupportsArray(getter_AddRefs(mFiles));
NS_ENSURE_SUCCESS(rv,rv);
for( int i=0; i<minfo->nitems; i++ ) {
nsCOMPtr<nsILocalFile> file = do_CreateInstance("@mozilla.org/file/local;1", &rv);
NS_ENSURE_SUCCESS(rv,rv);
nsCString s ( minfo->multipath[i] );
rv = file->InitWithNativePath( s );
NS_ENSURE_SUCCESS(rv,rv);
rv = mFiles->AppendElement(file);
NS_ENSURE_SUCCESS(rv,rv);
}
PtFSFreeInfo( &info ); /* clean the info structure if the multiple mode is set */
}
}
PL_strncpyz( mLastUsedDirectory, info.path, PATH_MAX+1 );
if (!mDisplayDirectory)
mDisplayDirectory = do_CreateInstance("@mozilla.org/file/local;1");
if (mDisplayDirectory)
mDisplayDirectory->InitWithNativePath( nsDependentCString(mLastUsedDirectory) );
if( title ) nsMemory::Free( title );
return NS_OK;
// TODO: implement filters
}
