void
IPC_Log(const char *fmt, ... )
{
va_list ap;
va_start(ap, fmt);
PRUint32 nb = 0;
char buf[512];
#ifdef VBOX
if (ipcLogPrefix[0]) {
nb = strlen(ipcLogPrefix);
if (nb > sizeof(buf) - 2)
nb = sizeof(buf) - 2;
PL_strncpy(buf, ipcLogPrefix, nb);
buf[nb++] = ' ';
}
#else
if (ipcLogPrefix[0])
nb = WritePrefix(buf, sizeof(buf));
#endif
PR_vsnprintf(buf + nb, sizeof(buf) - nb, fmt, ap);
buf[sizeof(buf) - 1] = '\0';
#ifdef VBOX
LogFlow(("%s", buf));
#else
fwrite(buf, strlen(buf), 1, stdout);
#endif
va_end(ap);
}
nsresult PREF_GetCharPref(const char *pref_name, char * return_buffer, int * length, PRBool get_default)
{
if (!gHashTable.ops)
return NS_ERROR_NOT_INITIALIZED;
nsresult rv = NS_ERROR_UNEXPECTED;
char* stringVal;
PrefHashEntry* pref = pref_HashTableLookup(pref_name);
if (pref)
{
if (get_default || PREF_IS_LOCKED(pref) || !PREF_HAS_USER_VALUE(pref))
stringVal = pref->defaultPref.stringVal;
else
stringVal = pref->userPref.stringVal;
if (stringVal)
{
if (*length <= 0)
*length = PL_strlen(stringVal) + 1;
else
{
PL_strncpy(return_buffer, stringVal, NS_MIN<size_t>(*length - 1, PL_strlen(stringVal) + 1));
return_buffer[*length - 1] = '\0';
}
rv = NS_OK;
}
}
return rv;
}
nsMsgSendPart::nsMsgSendPart(nsIMsgSend* state, const char *part_charset)
{
m_state = nsnull;
PL_strncpy(m_charset_name, (part_charset ? part_charset : "us-ascii"), sizeof(m_charset_name)-1);
m_charset_name[sizeof(m_charset_name)-1] = '\0';
m_children = nsnull;
m_numchildren = 0;
SetMimeDeliveryState(state);
m_parent = nsnull;
m_filespec = nsnull;
m_buffer = nsnull;
m_type = nsnull;
m_other = nsnull;
m_strip_sensitive_headers = PR_FALSE;
m_encoder_data = nsnull;
m_firstBlock = PR_FALSE;
m_needIntlConversion = PR_FALSE;
m_mainpart = PR_FALSE;
m_just_hit_CR = PR_FALSE;
}
//
// FUNCTION: GetResourceStringByID()
//
// PURPOSE: Get the resource string for the ID
//
void WebBrowserChromeUI::GetResourceStringById(PRInt32 aID, char ** aReturn)
{
char resBuf[MAX_LOADSTRING];
int retval = LoadString( ghInstanceResources, aID, (LPTSTR)resBuf, sizeof(resBuf) );
if (retval != 0)
{
int resLen = strlen(resBuf);
*aReturn = (char *)calloc(resLen+1, sizeof(char *));
if (!*aReturn) return;
PL_strncpy(*aReturn, (char *) resBuf, resLen);
}
return;
}
PL_strncat(char *dest, const char *src, PRUint32 max)
{
char *rv;
if( ((char *)0 == dest) || ((const char *)0 == src) || (0 == max) )
return dest;
for( rv = dest; *dest; dest++ )
;
(void)PL_strncpy(dest, src, max);
return rv;
}
void
nsTopProgressManager::UpdateStatusMessage(AggregateTransferInfo& info)
{
// Compute how much time has elapsed
nsInt64 dt = nsTime(PR_Now()) - fActualStart;
PRUint32 elapsed = dt / nsInt64((PRUint32) PR_USEC_PER_SEC);
char buf[256];
*buf = 0;
if (info.ObjectCount == 1 || info.CompleteCount == 0) {
// If we only have one object that we're transferring, or if
// nothing has completed yet, show the default status message
PL_strncpy(buf, fDefaultStatus, sizeof(buf));
}
if (elapsed > TIME_UNTIL_DETAILS) {
char details[256];
*details = 0;
if (!info.UnknownLengthCount && info.ContentLength > 0) {
formatKnownContentLength(details, sizeof(details),
info.BytesReceived,
info.ContentLength,
elapsed);
}
else if (info.BytesReceived > 0) {
formatUnknownContentLength(details, sizeof(details),
info.BytesReceived,
elapsed);
}
if (*details) {
// XXX needs to go to allxpstr.h
if (*buf)
PL_strcatn(buf, sizeof(buf), ", ");
PL_strcatn(buf, sizeof(buf), details);
}
}
FE_Progress(fContext, buf);
}
const char *ConfigStore::GetConfig(const char *name)
{
char buf[256];
char *ret;
if (m_root->getSet() ==NULL) {
return NULL;
}
if (PL_strlen(m_substore_name) == 0) {
PL_strncpy(buf,name,256);
} else {
PR_snprintf(buf,256,"%s.%s",m_substore_name,name);
}
PR_Lock(m_lock);
ret = (char *)PL_HashTableLookupConst(m_root->getSet(), buf);
PR_Unlock(m_lock);
return ret;
}
nsMsgSendPart::nsMsgSendPart(nsIMsgSend* state, const char *part_charset)
{
PL_strncpy(m_charset_name, (part_charset ? part_charset : "us-ascii"), sizeof(m_charset_name)-1);
m_charset_name[sizeof(m_charset_name)-1] = '\0';
m_children = nsnull;
m_numchildren = 0;
// if we're not added as a child, the default part number will be "1".
m_partNum = "1";
SetMimeDeliveryState(state);
m_parent = nsnull;
m_buffer = nsnull;
m_type = nsnull;
m_other = nsnull;
m_strip_sensitive_headers = false;
m_encoder_data = nsnull;
m_firstBlock = false;
m_needIntlConversion = false;
m_mainpart = false;
m_just_hit_CR = false;
}
//-------------------------------------------------------------------------
//
// 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;
}
PRBool IniParser::readIniLine(char** pszSection, char** pszToken,
char** pszVal, PRUint32* piLine)
{
char *p, *q, *r;
// check for invalid parameters
if(!m_pTextFile || !pszSection || !pszToken || !pszVal)
return false;
// initialization
*pszSection = &m_pszCurrentSection[0];
*pszToken = NULL;
*pszVal = NULL;
char *pszLine = NULL;
SKERR err = noErr;
while(err == noErr)
{
err = m_pTextFile->GetLine(&pszLine);
if((err != noErr) || !pszLine)
break;
// increment line number if applicable
if(piLine != NULL)
++*piLine;
// strip comments
p = PL_strstr(pszLine, "//");
if(p)
*p = 0;
// right trim
for(p = pszLine + PL_strlen(pszLine); p >= pszLine && *p <= 0x20; p--)
*p = 0;
// left trim
for(p = pszLine; *p && *p <= 0x20; p++) {}
// section
if (*p == '[')
{
q = PL_strchr(p, ']');
if (q)
*q = 0;
p++;
PL_strncpy(m_pszCurrentSection, p, sizeof(m_pszCurrentSection) - 1);
m_pszCurrentSection[sizeof(m_pszCurrentSection) - 1] = '\0';
break;
}
// look for token = val pairs
q = PL_strchr(p, '=');
if (!q)
{
// skip ill-formed lines
continue;
}
// right trim
for (r = q ; r >= p && (*r <= 0x20 || *r == '=') ; r--)
*r = 0;
// found token
*pszToken = p;
// left trim
for (q++; *q <= 0x20; q++)
{
if (!*q)
break;
}
/*
if (!*q)
{
// skip ill-formed lines
SKError(err_invalid, "[IniParser] invalid line: %s", pszLine);
continue;
}
*/
// found value
*pszVal = q;
break;
}
// true on success
return (err == noErr) && pszLine;
}
// |decode_mime_part2_str| taken from comi18n.c
// Decode RFC2047-encoded words in the input and convert the result to UTF-8.
// If aOverrideCharset is true, charset in RFC2047-encoded words is
// ignored and aDefaultCharset is assumed, instead. aDefaultCharset
// is also used to convert raw octets (without RFC 2047 encoding) to UTF-8.
//static
nsresult DecodeRFC2047Str(const char *aHeader, const char *aDefaultCharset,
PRBool aOverrideCharset, nsACString &aResult)
{
const char *p, *q, *r;
char *decodedText;
const char *begin; // tracking pointer for where we are in the input buffer
PRInt32 isLastEncodedWord = 0;
const char *charsetStart, *charsetEnd;
char charset[80];
// initialize charset name to an empty string
charset[0] = '\0';
begin = aHeader;
// To avoid buffer realloc, if possible, set capacity in advance. No
// matter what, more than 3x expansion can never happen for all charsets
// supported by Mozilla. SCSU/BCSU with the sliding window set to a
// non-BMP block may be exceptions, but Mozilla does not support them.
// Neither any known mail/news program use them. Even if there's, we're
// safe because we don't use a raw *char any more.
aResult.SetCapacity(3 * strlen(aHeader));
while ((p = PL_strstr(begin, "=?")) != 0) {
if (isLastEncodedWord) {
// See if it's all whitespace.
for (q = begin; q < p; ++q) {
if (!PL_strchr(" \t\r\n", *q)) break;
}
}
if (!isLastEncodedWord || q < p) {
// copy the part before the encoded-word
CopyRawHeader(begin, p - begin, aDefaultCharset, aResult);
begin = p;
}
p += 2;
// Get charset info
charsetStart = p;
charsetEnd = 0;
for (q = p; *q != '?'; q++) {
if (*q <= ' ' || PL_strchr(especials, *q)) {
goto badsyntax;
}
// RFC 2231 section 5
if (!charsetEnd && *q == '*') {
charsetEnd = q;
}
}
if (!charsetEnd) {
charsetEnd = q;
}
// Check for too-long charset name
if (PRUint32(charsetEnd - charsetStart) >= sizeof(charset))
goto badsyntax;
memcpy(charset, charsetStart, charsetEnd - charsetStart);
charset[charsetEnd - charsetStart] = 0;
q++;
if (*q != 'Q' && *q != 'q' && *q != 'B' && *q != 'b')
goto badsyntax;
if (q[1] != '?')
goto badsyntax;
r = q;
for (r = q + 2; *r != '?'; r++) {
if (*r < ' ') goto badsyntax;
}
if (r[1] != '=')
goto badsyntax;
else if (r == q + 2) {
// it's empty, skip
begin = r + 2;
isLastEncodedWord = 1;
continue;
}
if(*q == 'Q' || *q == 'q')
decodedText = DecodeQ(q + 2, r - (q + 2));
else {
// bug 227290. ignore an extraneous '=' at the end.
// (# of characters in B-encoded part has to be a multiple of 4)
PRInt32 n = r - (q + 2);
n -= (n % 4 == 1 && !PL_strncmp(r - 3, "===", 3)) ? 1 : 0;
decodedText = PL_Base64Decode(q + 2, n, nsnull);
}
if (decodedText == nsnull)
goto badsyntax;
// Override charset if requested. Never override labeled UTF-8.
// Use default charset instead of UNKNOWN-8BIT
if ((aOverrideCharset && 0 != nsCRT::strcasecmp(charset, "UTF-8")) ||
(aDefaultCharset && 0 == nsCRT::strcasecmp(charset, "UNKNOWN-8BIT"))) {
PL_strncpy(charset, aDefaultCharset, sizeof(charset) - 1);
charset[sizeof(charset) - 1] = '\0';
}
{
nsCOMPtr<nsIUTF8ConverterService>
cvtUTF8(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID));
nsCAutoString utf8Text;
// skip ASCIIness/UTF8ness test if aCharset is 7bit non-ascii charset.
if (cvtUTF8 &&
NS_SUCCEEDED(
cvtUTF8->ConvertStringToUTF8(nsDependentCString(decodedText),
charset, IS_7BIT_NON_ASCII_CHARSET(charset), utf8Text))) {
aResult.Append(utf8Text);
} else {
aResult.Append(REPLACEMENT_CHAR);
}
}
PR_Free(decodedText);
begin = r + 2;
isLastEncodedWord = 1;
continue;
badsyntax:
// copy the part before the encoded-word
aResult.Append(begin, p - begin);
begin = p;
isLastEncodedWord = 0;
}
// put the tail back
CopyRawHeader(begin, strlen(begin), aDefaultCharset, aResult);
nsCAutoString tempStr(aResult);
tempStr.ReplaceChar('\t', ' ');
aResult = tempStr;
return NS_OK;
}
void InstallSignalHandlers(const char *ProgramName)
{
PL_strncpy(_progname,ProgramName, (sizeof(_progname)-1) );
const char *gdbSleep = PR_GetEnv("MOZ_GDB_SLEEP");
if (gdbSleep && *gdbSleep)
{
unsigned int s;
if (1 == sscanf(gdbSleep, "%u", &s)) {
_gdb_sleep_duration = s;
}
}
#if defined(CRAWL_STACK_ON_SIGSEGV)
if (!getenv("XRE_NO_WINDOWS_CRASH_DIALOG")) {
void (*crap_handler)(int) =
GeckoProcessType_Default != XRE_GetProcessType() ?
child_ah_crap_handler :
ah_crap_handler;
signal(SIGSEGV, crap_handler);
signal(SIGILL, crap_handler);
signal(SIGABRT, crap_handler);
}
#endif // CRAWL_STACK_ON_SIGSEGV
#ifdef SA_SIGINFO
/* Install a handler for floating point exceptions and disable them if they occur. */
struct sigaction sa, osa;
sa.sa_flags = SA_ONSTACK | SA_RESTART | SA_SIGINFO;
sa.sa_sigaction = fpehandler;
sigemptyset(&sa.sa_mask);
sigaction(SIGFPE, &sa, &osa);
#endif
#if defined(DEBUG) && defined(LINUX)
const char *memLimit = PR_GetEnv("MOZ_MEM_LIMIT");
if (memLimit && *memLimit)
{
long m = atoi(memLimit);
m *= (1024*1024);
struct rlimit r;
r.rlim_cur = m;
r.rlim_max = m;
setrlimit(RLIMIT_AS, &r);
}
#endif
#if defined(SOLARIS)
#define NOFILES 512
// Boost Solaris file descriptors
{
struct rlimit rl;
if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
if (rl.rlim_cur < NOFILES) {
rl.rlim_cur = NOFILES;
if (setrlimit(RLIMIT_NOFILE, &rl) < 0) {
perror("setrlimit(RLIMIT_NOFILE)");
fprintf(stderr, "Cannot exceed hard limit for open files");
}
#if defined(DEBUG)
if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
printf("File descriptors set to %d\n", rl.rlim_cur);
#endif //DEBUG
}
}
#endif //SOLARIS
#if defined(MOZ_WIDGET_GTK2) && (GLIB_MAJOR_VERSION > 2 || (GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION >= 6))
const char *assertString = PR_GetEnv("XPCOM_DEBUG_BREAK");
if (assertString &&
(!strcmp(assertString, "suspend") ||
!strcmp(assertString, "stack") ||
!strcmp(assertString, "abort") ||
!strcmp(assertString, "trap") ||
!strcmp(assertString, "break"))) {
// Override the default glib logging function so we get stacks for it too.
orig_log_func = g_log_set_default_handler(my_glib_log_func, NULL);
}
#endif
}
// Simple parser to parse META charset.
// It only supports the case when the description is within one line.
const char *
nsMsgI18NParseMetaCharset(nsIFile* file)
{
static char charset[nsIMimeConverter::MAX_CHARSET_NAME_LENGTH+1];
*charset = '\0';
bool isDirectory = false;
file->IsDirectory(&isDirectory);
if (isDirectory) {
NS_ERROR("file is a directory");
return charset;
}
nsresult rv;
nsCOMPtr <nsIFileInputStream> fileStream = do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, charset);
rv = fileStream->Init(file, PR_RDONLY, 0664, false);
nsCOMPtr <nsILineInputStream> lineStream = do_QueryInterface(fileStream, &rv);
nsCString curLine;
bool more = true;
while (NS_SUCCEEDED(rv) && more) {
rv = lineStream->ReadLine(curLine, &more);
if (curLine.IsEmpty())
continue;
ToUpperCase(curLine);
if (curLine.Find("/HEAD") != -1)
break;
if (curLine.Find("META") != -1 &&
curLine.Find("HTTP-EQUIV") != -1 &&
curLine.Find("CONTENT-TYPE") != -1 &&
curLine.Find("CHARSET") != -1) {
char *cp = (char *) PL_strchr(PL_strstr(curLine.get(), "CHARSET"), '=');
char *token = nullptr;
if (cp)
{
char *newStr = cp + 1;
token = NS_strtok(" \"\'", &newStr);
}
if (token) {
PL_strncpy(charset, token, sizeof(charset));
charset[sizeof(charset)-1] = '\0';
// this function cannot parse a file if it is really
// encoded by one of the following charsets
// so we can say that the charset label must be incorrect for
// the .html if we actually see those charsets parsed
// and we should ignore them
if (!PL_strncasecmp("UTF-16", charset, sizeof("UTF-16")-1) ||
!PL_strncasecmp("UTF-32", charset, sizeof("UTF-32")-1))
charset[0] = '\0';
break;
}
}
}
return charset;
}
// performs a locale sensitive date formatting operation on the struct tm parameter
nsresult nsDateTimeFormatUnix::FormatTMTime(nsILocale* locale,
const nsDateFormatSelector dateFormatSelector,
const nsTimeFormatSelector timeFormatSelector,
const struct tm* tmTime,
nsAString& stringOut)
{
#define NSDATETIME_FORMAT_BUFFER_LEN 80
char strOut[NSDATETIME_FORMAT_BUFFER_LEN*2]; // buffer for date and time
char fmtD[NSDATETIME_FORMAT_BUFFER_LEN], fmtT[NSDATETIME_FORMAT_BUFFER_LEN];
nsresult rv;
// set up locale data
(void) Initialize(locale);
NS_ENSURE_TRUE(mDecoder, NS_ERROR_NOT_INITIALIZED);
// set date format
if (dateFormatSelector == kDateFormatLong && timeFormatSelector == kTimeFormatSeconds) {
PL_strncpy(fmtD, "%c", NSDATETIME_FORMAT_BUFFER_LEN);
PL_strncpy(fmtT, "", NSDATETIME_FORMAT_BUFFER_LEN);
} else {
switch (dateFormatSelector) {
case kDateFormatNone:
PL_strncpy(fmtD, "", NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kDateFormatLong:
case kDateFormatShort:
PL_strncpy(fmtD, "%x", NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kDateFormatYearMonth:
PL_strncpy(fmtD, "%Y/%m", NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kDateFormatWeekday:
PL_strncpy(fmtD, "%a", NSDATETIME_FORMAT_BUFFER_LEN);
break;
default:
PL_strncpy(fmtD, "", NSDATETIME_FORMAT_BUFFER_LEN);
}
// set time format
switch (timeFormatSelector) {
case kTimeFormatNone:
PL_strncpy(fmtT, "", NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kTimeFormatSeconds:
PL_strncpy(fmtT, "%X", NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kTimeFormatNoSeconds:
PL_strncpy(fmtT,
mLocalePreferred24hour ? "%H:%M" : mLocaleAMPMfirst ? "%p %I:%M" : "%I:%M %p",
NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kTimeFormatSecondsForce24Hour:
PL_strncpy(fmtT, "%H:%M:%S", NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kTimeFormatNoSecondsForce24Hour:
PL_strncpy(fmtT, "%H:%M", NSDATETIME_FORMAT_BUFFER_LEN);
break;
default:
PL_strncpy(fmtT, "", NSDATETIME_FORMAT_BUFFER_LEN);
}
}
// generate data/time string
char *old_locale = setlocale(LC_TIME, nullptr);
(void) setlocale(LC_TIME, mPlatformLocale.get());
if (strlen(fmtD) && strlen(fmtT)) {
PL_strncat(fmtD, " ", NSDATETIME_FORMAT_BUFFER_LEN);
PL_strncat(fmtD, fmtT, NSDATETIME_FORMAT_BUFFER_LEN);
strftime(strOut, NSDATETIME_FORMAT_BUFFER_LEN, fmtD, tmTime);
}
else if (strlen(fmtD) && !strlen(fmtT)) {
strftime(strOut, NSDATETIME_FORMAT_BUFFER_LEN, fmtD, tmTime);
}
else if (!strlen(fmtD) && strlen(fmtT)) {
strftime(strOut, NSDATETIME_FORMAT_BUFFER_LEN, fmtT, tmTime);
}
else {
PL_strncpy(strOut, "", NSDATETIME_FORMAT_BUFFER_LEN);
}
(void) setlocale(LC_TIME, old_locale);
// convert result to unicode
int32_t srcLength = (int32_t) strlen(strOut);
int32_t unicharLength = NSDATETIME_FORMAT_BUFFER_LEN*2;
PRUnichar unichars[NSDATETIME_FORMAT_BUFFER_LEN*2]; // buffer for date and time
rv = mDecoder->Convert(strOut, &srcLength, unichars, &unicharLength);
if (NS_FAILED(rv))
return rv;
stringOut.Assign(unichars, unicharLength);
return rv;
}
/* msg_format_Header_addresses
*/
static char *
msg_format_Header_addresses (const char *names, const char *addrs,
int count, PRBool wrap_lines_p)
{
char *result, *out;
const char *s1, *s2;
PRUint32 i, size = 0;
PRUint32 column = 10;
PRUint32 len1, len2;
PRUint32 name_maxlen = 0;
PRUint32 addr_maxlen = 0;
if (count <= 0)
return 0;
s1 = names;
s2 = addrs;
for (i = 0; (int)i < count; i++)
{
len1 = strlen(s1);
len2 = strlen(s2);
s1 += len1 + 1;
s2 += len2 + 1;
len1 = (len1 * 2) + 2; //(N*2) + 2 in case we need to quote it
len2 = (len2 * 2) + 2;
name_maxlen = PR_MAX(name_maxlen, len1);
addr_maxlen = PR_MAX(addr_maxlen, len2);
size += len1 + len2 + 10;
}
result = (char *)PR_Malloc(size + 1);
char *aName = (char *)PR_Malloc(name_maxlen + 1);
char *anAddr = (char *)PR_Malloc(addr_maxlen + 1);
if (!result || !aName || !anAddr)
{
PR_FREEIF(result);
PR_FREEIF(aName);
PR_FREEIF(anAddr);
return 0;
}
out = result;
s1 = names;
s2 = addrs;
for (i = 0; (int)i < count; i++)
{
char *o;
PL_strncpy(aName, s1, name_maxlen);
PL_strncpy(anAddr, s2, addr_maxlen);
len1 = msg_quote_phrase_or_addr(aName, strlen(s1), PR_FALSE);
len2 = msg_quote_phrase_or_addr(anAddr, strlen(s2), PR_TRUE);
if ( wrap_lines_p && i > 0
&& (column + len1 + len2 + 3 + (((int)(i+1) < count) ? 2 : 0) > 76))
{
if (out > result && out[-1] == ' ')
out--;
*out++ = '\r';
*out++ = '\n';
*out++ = '\t';
column = 8;
}
o = out;
if (len1)
{
memcpy(out, aName, len1);
out += len1;
*out++ = ' ';
*out++ = '<';
}
memcpy(out, anAddr, len2);
out += len2;
if (len1)
*out++ = '>';
if ((int)(i+1) < count)
{
*out++ = ',';
*out++ = ' ';
}
s1 += strlen(s1) + 1;
s2 += strlen(s2) + 1;
column += (out - o);
}
*out = 0;
PR_FREEIF(aName);
PR_FREEIF(anAddr);
return result;
}
// parse condition like "(subject, contains, fred) AND (body, isn't, "foo)")"
// values with close parens will be quoted.
// what about values with close parens and quotes? e.g., (body, isn't, "foo")")
// I guess interior quotes will need to be escaped - ("foo\")")
// which will get written out as (\"foo\\")\") and read in as ("foo\")"
// ALL means match all messages.
NS_IMETHODIMP nsMsgFilterList::ParseCondition(nsIMsgFilter *aFilter, const char *aCondition)
{
NS_ENSURE_ARG_POINTER(aFilter);
bool done = false;
nsresult err = NS_OK;
const char *curPtr = aCondition;
if (!strcmp(aCondition, "ALL"))
{
nsMsgSearchTerm *newTerm = new nsMsgSearchTerm;
if (newTerm)
{
newTerm->m_matchAll = true;
aFilter->AppendTerm(newTerm);
}
return (newTerm) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
while (!done)
{
// insert code to save the boolean operator if there is one for this search term....
const char *openParen = PL_strchr(curPtr, '(');
const char *orTermPos = PL_strchr(curPtr, 'O'); // determine if an "OR" appears b4 the openParen...
bool ANDTerm = true;
if (orTermPos && orTermPos < openParen) // make sure OR term falls before the '('
ANDTerm = false;
char *termDup = nullptr;
if (openParen)
{
bool foundEndTerm = false;
bool inQuote = false;
for (curPtr = openParen +1; *curPtr; curPtr++)
{
if (*curPtr == '\\' && *(curPtr + 1) == '"')
curPtr++;
else if (*curPtr == ')' && !inQuote)
{
foundEndTerm = true;
break;
}
else if (*curPtr == '"')
inQuote = !inQuote;
}
if (foundEndTerm)
{
int termLen = curPtr - openParen - 1;
termDup = (char *) PR_Malloc(termLen + 1);
if (termDup)
{
PL_strncpy(termDup, openParen + 1, termLen + 1);
termDup[termLen] = '\0';
}
else
{
err = NS_ERROR_OUT_OF_MEMORY;
break;
}
}
}
else
break;
if (termDup)
{
nsMsgSearchTerm *newTerm = new nsMsgSearchTerm;
if (newTerm)
{
/* Invert nsMsgSearchTerm::EscapeQuotesInStr() */
for (char *to = termDup, *from = termDup;;)
{
if (*from == '\\' && from[1] == '"') from++;
if (!(*to++ = *from++)) break;
}
newTerm->m_booleanOp = (ANDTerm) ? nsMsgSearchBooleanOp::BooleanAND
: nsMsgSearchBooleanOp::BooleanOR;
err = newTerm->DeStreamNew(termDup, PL_strlen(termDup));
NS_ENSURE_SUCCESS(err, err);
aFilter->AppendTerm(newTerm);
}
PR_FREEIF(termDup);
}
else
break;
}
return err;
}
// performs a locale sensitive date formatting operation on the struct tm parameter
/*static*/ nsresult
DateTimeFormat::FormatTMTime(const nsDateFormatSelector aDateFormatSelector,
const nsTimeFormatSelector aTimeFormatSelector,
const struct tm* aTmTime,
nsAString& aStringOut)
{
#define NSDATETIME_FORMAT_BUFFER_LEN 80
char strOut[NSDATETIME_FORMAT_BUFFER_LEN*2]; // buffer for date and time
char fmtD[NSDATETIME_FORMAT_BUFFER_LEN], fmtT[NSDATETIME_FORMAT_BUFFER_LEN];
nsresult rv;
// set up locale data
(void) Initialize();
NS_ENSURE_TRUE(mDecoder, NS_ERROR_NOT_INITIALIZED);
// set date format
if (aDateFormatSelector == kDateFormatLong && aTimeFormatSelector == kTimeFormatSeconds) {
PL_strncpy(fmtD, "%c", NSDATETIME_FORMAT_BUFFER_LEN);
PL_strncpy(fmtT, "", NSDATETIME_FORMAT_BUFFER_LEN);
} else {
switch (aDateFormatSelector) {
case kDateFormatNone:
PL_strncpy(fmtD, "", NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kDateFormatLong:
case kDateFormatShort:
PL_strncpy(fmtD, "%x", NSDATETIME_FORMAT_BUFFER_LEN);
break;
default:
PL_strncpy(fmtD, "", NSDATETIME_FORMAT_BUFFER_LEN);
}
// set time format
switch (aTimeFormatSelector) {
case kTimeFormatNone:
PL_strncpy(fmtT, "", NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kTimeFormatSeconds:
PL_strncpy(fmtT, "%X", NSDATETIME_FORMAT_BUFFER_LEN);
break;
case kTimeFormatNoSeconds:
PL_strncpy(fmtT,
mLocalePreferred24hour ? "%H:%M" : mLocaleAMPMfirst ? "%p %I:%M" : "%I:%M %p",
NSDATETIME_FORMAT_BUFFER_LEN);
break;
default:
PL_strncpy(fmtT, "", NSDATETIME_FORMAT_BUFFER_LEN);
}
}
// generate date/time string
if (strlen(fmtD) && strlen(fmtT)) {
PL_strncat(fmtD, " ", NSDATETIME_FORMAT_BUFFER_LEN);
PL_strncat(fmtD, fmtT, NSDATETIME_FORMAT_BUFFER_LEN);
strftime(strOut, NSDATETIME_FORMAT_BUFFER_LEN, fmtD, aTmTime);
} else if (strlen(fmtD) && !strlen(fmtT)) {
strftime(strOut, NSDATETIME_FORMAT_BUFFER_LEN, fmtD, aTmTime);
} else if (!strlen(fmtD) && strlen(fmtT)) {
strftime(strOut, NSDATETIME_FORMAT_BUFFER_LEN, fmtT, aTmTime);
} else {
PL_strncpy(strOut, "", NSDATETIME_FORMAT_BUFFER_LEN);
}
// convert result to unicode
int32_t srcLength = (int32_t) strlen(strOut);
int32_t unicharLength = NSDATETIME_FORMAT_BUFFER_LEN*2;
char16_t unichars[NSDATETIME_FORMAT_BUFFER_LEN*2]; // buffer for date and time
rv = mDecoder->Convert(strOut, &srcLength, unichars, &unicharLength);
if (NS_FAILED(rv)) {
return rv;
}
aStringOut.Assign(unichars, unicharLength);
return rv;
}
