/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "primpl.h"
#include "prenv.h"
#include "prprf.h"
#include <string.h>
#ifdef ANDROID
# include <android/log.h>
#endif
/*
* Lock used to lock the log.
*
* We can't define _PR_LOCK_LOG simply as PR_Lock because PR_Lock may
* contain assertions. We have to avoid assertions in _PR_LOCK_LOG
* because PR_ASSERT calls PR_LogPrint, which in turn calls _PR_LOCK_LOG.
* This can lead to infinite recursion.
*/
static PRLock* _pr_logLock;
#if defined(_PR_PTHREADS) ||
defined(_PR_BTHREADS)
# define _PR_LOCK_LOG() PR_Lock(_pr_logLock);
# define _PR_UNLOCK_LOG() PR_Unlock(_pr_logLock);
#elif defined(_PR_GLOBAL_THREADS_ONLY)
# define _PR_LOCK_LOG() \
{ \
_PR_LOCK_LOCK(_pr_logLock)
# define _PR_UNLOCK_LOG() \
_PR_LOCK_UNLOCK(_pr_logLock); \
}
#else
# define _PR_LOCK_LOG() \
{ \
PRIntn _is; \
PRThread* _me = _PR_MD_CURRENT_THREAD(); \
if (!_PR_IS_NATIVE_THREAD(_me)) _PR_INTSOFF(_is); \
_PR_LOCK_LOCK(_pr_logLock)
# define _PR_UNLOCK_LOG() \
_PR_LOCK_UNLOCK(_pr_logLock); \
PR_ASSERT(_me == _PR_MD_CURRENT_THREAD()); \
if (!_PR_IS_NATIVE_THREAD(_me)) _PR_INTSON(_is); \
}
#endif
#if defined(XP_PC)
# define strcasecmp stricmp
#endif
/*
* On NT, we can't define _PUT_LOG as PR_Write or _PR_MD_WRITE,
* because every asynchronous file io operation leads to a fiber context
* switch. So we define _PUT_LOG as fputs (from stdio.h). A side
* benefit is that fputs handles the LF->CRLF translation. This
* code can also be used on other platforms with file stream io.
*/
#if defined(WIN32)
# define _PR_USE_STDIO_FOR_LOGGING
#endif
/*
** Coerce Win32 log output to use OutputDebugString() when
** NSPR_LOG_FILE is set to "WinDebug".
*/
#if defined(XP_PC)
# define WIN32_DEBUG_FILE (FILE*)-2
#endif
#ifdef WINCE
static void OutputDebugStringA(
const char* msg) {
int len = MultiByteToWideChar(CP_ACP, 0, msg, -1, 0, 0);
WCHAR* wMsg = (WCHAR*)PR_Malloc(len *
sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, msg, -1, wMsg, len);
OutputDebugStringW(wMsg);
PR_Free(wMsg);
}
#endif
/* Macros used to reduce #ifdef pollution */
#if defined(_PR_USE_STDIO_FOR_LOGGING) &&
defined(XP_PC)
# define _PUT_LOG(fd, buf, nb) \
PR_BEGIN_MACRO \
if (logFile == WIN32_DEBUG_FILE) { \
char savebyte = buf[nb]; \
buf[nb] =
'\0'; \
OutputDebugStringA(buf); \
buf[nb] = savebyte; \
}
else { \
fwrite(buf, 1, nb, fd); \
fflush(fd); \
} \
PR_END_MACRO
#elif defined(_PR_USE_STDIO_FOR_LOGGING)
# define _PUT_LOG(fd, buf, nb) \
{ \
fwrite(buf, 1, nb, fd); \
fflush(fd); \
}
#elif defined(ANDROID)
# define _PUT_LOG(fd, buf, nb) \
PR_BEGIN_MACRO \
if (fd == _pr_stderr) { \
char savebyte = buf[nb]; \
buf[nb] =
'\0'; \
__android_log_write(ANDROID_LOG_INFO,
"PRLog", buf); \
buf[nb] = savebyte; \
}
else { \
PR_Write(fd, buf, nb); \
} \
PR_END_MACRO
#elif defined(_PR_PTHREADS)
# define _PUT_LOG(fd, buf, nb) PR_Write(fd, buf, nb)
#else
# define _PUT_LOG(fd, buf, nb) _PR_MD_WRITE(fd, buf, nb)
#endif
/************************************************************************/
static PRLogModuleInfo* logModules;
static char* logBuf = NULL;
static char* logp;
static char* logEndp;
#ifdef _PR_USE_STDIO_FOR_LOGGING
static FILE* logFile = NULL;
#else
static PRFileDesc* logFile = 0;
#endif
static PRBool outputTimeStamp = PR_FALSE;
static PRBool appendToLog = PR_FALSE;
#define LINE_BUF_SIZE 512
#define DEFAULT_BUF_SIZE 16384
#ifdef _PR_NEED_STRCASECMP
/*
* strcasecmp is defined in /usr/ucblib/libucb.a on some platforms
* such as NCR. Linking with both libc and libucb
* may cause some problem, so I just provide our own implementation
* of strcasecmp here.
*/
static const unsigned char uc[] = {
'\000',
'\001',
'\002',
'\003',
'\004',
'\005',
'\006',
'\007',
'\010',
'\011',
'\012',
'\013',
'\014',
'\015',
'\016',
'\017',
'\020',
'\021',
'\022',
'\023',
'\024',
'\025',
'\026',
'\027',
'\030',
'\031',
'\032',
'\033',
'\034',
'\035',
'\036',
'\037',
' ',
'!',
'"',
'#',
'$',
'%',
'&',
'\'', '(
', ')
', '*
', '+
', ',
',
'-',
'.',
'/',
'0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9',
':',
';',
'<',
'=',
'>',
'?',
'@',
'A',
'B',
'C',
'D',
'E',
'F',
'G',
'H',
'I',
'J',
'K',
'L',
'M',
'N',
'O',
'P',
'Q',
'R',
'S',
'T',
'U',
'V',
'W',
'X',
'Y',
'Z',
'[',
'\\',
']',
'^',
'_',
'`',
'A',
'B',
'C',
'D',
'E',
'F',
'G',
'H',
'I',
'J',
'K',
'L',
'M',
'N',
'O',
'P',
'Q',
'R',
'S',
'T',
'U',
'V',
'W',
'X',
'Y',
'Z',
'{',
'|',
'}',
'~',
'\177'};
PRIntn strcasecmp(
const char* a,
const char* b) {
const unsigned char* ua = (
const unsigned char*)a;
const unsigned char* ub = (
const unsigned char*)b;
if (((
const char*)0 == a) || (
const char*)0 == b) {
return (PRIntn)(a - b);
}
while ((uc[*ua] == uc[*ub]) && (
'\0' != *a)) {
a++;
ua++;
ub++;
}
return (PRIntn)(uc[*ua] - uc[*ub]);
}
#endif /* _PR_NEED_STRCASECMP */
void _PR_InitLog(
void) {
char* ev;
_pr_logLock = PR_NewLock();
ev = PR_GetEnv(
"NSPR_LOG_MODULES");
if (ev && ev[0]) {
char module[64];
/* Security-Critical: If you change this
* size, you must also change the sscanf
* format string to be size-1.
*/
PRBool isSync = PR_FALSE;
PRIntn evlen = strlen(ev), pos = 0;
PRInt32 bufSize = DEFAULT_BUF_SIZE;
while (pos < evlen) {
PRIntn level = 1, count = 0, delta = 0;
count = sscanf(
&ev[pos],
"%63[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-"
"]%n:%d%n",
module, &delta, &level, &delta);
pos += delta;
if (count == 0) {
break;
}
/*
** If count == 2, then we got module and level. If count
** == 1, then level defaults to 1 (module enabled).
*/
if (strcasecmp(module,
"sync") == 0) {
isSync = PR_TRUE;
}
else if (strcasecmp(module,
"bufsize") == 0) {
if (level >= LINE_BUF_SIZE) {
bufSize = level;
}
}
else if (strcasecmp(module,
"timestamp") == 0) {
outputTimeStamp = PR_TRUE;
}
else if (strcasecmp(module,
"append") == 0) {
appendToLog = PR_TRUE;
}
else {
PRLogModuleInfo* lm = logModules;
PRBool skip_modcheck =
(0 == strcasecmp(module,
"all")) ? PR_TRUE : PR_FALSE;
while (lm != NULL) {
if (skip_modcheck) {
lm->level = (PRLogModuleLevel)level;
}
else if (strcasecmp(module, lm->name) == 0) {
lm->level = (PRLogModuleLevel)level;
break;
}
lm = lm->next;
}
}
/*found:*/
count = sscanf(&ev[pos],
" , %n", &delta);
pos += delta;
if (count == EOF) {
break;
}
}
PR_SetLogBuffering(isSync ? 0 : bufSize);
ev = PR_GetEnvSecure(
"NSPR_LOG_FILE");
if (ev && ev[0]) {
if (!PR_SetLogFile(ev)) {
#ifdef XP_PC
char* str = PR_smprintf(
"Unable to create nspr log file '%s'\n", ev);
if (str) {
OutputDebugStringA(str);
PR_smprintf_free(str);
}
#else
fprintf(stderr,
"Unable to create nspr log file '%s'\n", ev);
#endif
}
}
else {
#ifdef _PR_USE_STDIO_FOR_LOGGING
logFile = stderr;
#else
logFile = _pr_stderr;
#endif
}
}
}
void _PR_LogCleanup(
void) {
PRLogModuleInfo* lm = logModules;
PR_LogFlush();
#ifdef _PR_USE_STDIO_FOR_LOGGING
if (logFile && logFile != stdout && logFile != stderr
# ifdef XP_PC
&& logFile != WIN32_DEBUG_FILE
# endif
) {
fclose(logFile);
}
#else
if (logFile && logFile != _pr_stdout && logFile != _pr_stderr) {
PR_Close(logFile);
}
#endif
logFile = NULL;
if (logBuf) {
PR_DELETE(logBuf);
}
while (lm != NULL) {
PRLogModuleInfo* next = lm->next;
free((
/*const*/ char*)lm->name);
PR_Free(lm);
lm = next;
}
logModules = NULL;
if (_pr_logLock) {
PR_DestroyLock(_pr_logLock);
_pr_logLock = NULL;
}
}
static void _PR_SetLogModuleLevel(PRLogModuleInfo* lm) {
char* ev;
ev = PR_GetEnv(
"NSPR_LOG_MODULES");
if (ev && ev[0]) {
char module[64];
/* Security-Critical: If you change this
* size, you must also change the sscanf
* format string to be size-1.
*/
PRIntn evlen = strlen(ev), pos = 0;
while (pos < evlen) {
PRIntn level = 1, count = 0, delta = 0;
count = sscanf(
&ev[pos],
"%63[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-"
"]%n:%d%n",
module, &delta, &level, &delta);
pos += delta;
if (count == 0) {
break;
}
/*
** If count == 2, then we got module and level. If count
** == 1, then level defaults to 1 (module enabled).
*/
if (lm != NULL) {
if ((strcasecmp(module,
"all") == 0) ||
(strcasecmp(module, lm->name) == 0)) {
lm->level = (PRLogModuleLevel)level;
}
}
count = sscanf(&ev[pos],
" , %n", &delta);
pos += delta;
if (count == EOF) {
break;
}
}
}
}
/* end _PR_SetLogModuleLevel() */
PR_IMPLEMENT(PRLogModuleInfo*) PR_NewLogModule(
const char* name) {
PRLogModuleInfo* lm;
if (!_pr_initialized) {
_PR_ImplicitInitialization();
}
lm = PR_NEWZAP(PRLogModuleInfo);
if (lm) {
lm->name = strdup(name);
lm->level = PR_LOG_NONE;
lm->next = logModules;
logModules = lm;
_PR_SetLogModuleLevel(lm);
}
return lm;
}
PR_IMPLEMENT(PRBool) PR_SetLogFile(
const char* file) {
#ifdef _PR_USE_STDIO_FOR_LOGGING
FILE* newLogFile;
# ifdef XP_PC
if (strcmp(file,
"WinDebug") == 0) {
newLogFile = WIN32_DEBUG_FILE;
}
else
# endif
{
const char* mode = appendToLog ?
"a" :
"w";
newLogFile = fopen(file, mode);
if (!newLogFile) {
return PR_FALSE;
}
# ifndef WINCE
/* _IONBF does not exist in the Windows Mobile 6 SDK. */
/* We do buffering ourselves. */
setvbuf(newLogFile, NULL, _IONBF, 0);
# endif
}
if (logFile && logFile != stdout && logFile != stderr
# ifdef XP_PC
&& logFile != WIN32_DEBUG_FILE
# endif
) {
fclose(logFile);
}
logFile = newLogFile;
return PR_TRUE;
#else
PRFileDesc* newLogFile;
PRIntn flags = PR_WRONLY | PR_CREATE_FILE;
if (appendToLog) {
flags |= PR_APPEND;
}
else {
flags |= PR_TRUNCATE;
}
newLogFile = PR_Open(file, flags, 0666);
if (newLogFile) {
if (logFile && logFile != _pr_stdout && logFile != _pr_stderr) {
PR_Close(logFile);
}
logFile = newLogFile;
}
return (PRBool)(newLogFile != 0);
#endif /* _PR_USE_STDIO_FOR_LOGGING */
}
PR_IMPLEMENT(
void) PR_SetLogBuffering(PRIntn buffer_size) {
PR_LogFlush();
if (logBuf) {
PR_DELETE(logBuf);
}
if (buffer_size >= LINE_BUF_SIZE) {
logp = logBuf = (
char*)PR_MALLOC(buffer_size);
logEndp = logp + buffer_size;
}
}
PR_IMPLEMENT(
void) PR_LogPrint(
const char* fmt, ...) {
va_list ap;
char line[LINE_BUF_SIZE];
char* line_long = NULL;
PRUint32 nb_tid = 0, nb;
PRThread* me;
PRExplodedTime now;
if (!_pr_initialized) {
_PR_ImplicitInitialization();
}
if (!logFile) {
return;
}
if (outputTimeStamp) {
PR_ExplodeTime(PR_Now(), PR_GMTParameters, &now);
nb_tid = PR_snprintf(line,
sizeof(line) - 1,
"%04d-%02d-%02d %02d:%02d:%02d.%06d UTC - ",
now.tm_year, now.tm_month + 1, now.tm_mday,
now.tm_hour, now.tm_min, now.tm_sec, now.tm_usec);
}
me = PR_GetCurrentThread();
nb_tid += PR_snprintf(line + nb_tid,
sizeof(line) - nb_tid - 1,
"%ld[%p]: ",
#if defined(_PR_BTHREADS)
me, me);
#else
me ? me->id : 0L, me);
#endif
va_start(ap, fmt);
nb = nb_tid + PR_vsnprintf(line + nb_tid,
sizeof(line) - nb_tid - 1, fmt, ap);
va_end(ap);
/*
* Check if we might have run out of buffer space (in case we have a
* long line), and malloc a buffer just this once.
*/
if (nb ==
sizeof(line) - 2) {
va_start(ap, fmt);
line_long = PR_vsmprintf(fmt, ap);
va_end(ap);
/* If this failed, we'll fall back to writing the truncated line. */
}
if (line_long) {
nb = strlen(line_long);
_PR_LOCK_LOG();
if (logBuf != 0) {
_PUT_LOG(logFile, logBuf, logp - logBuf);
logp = logBuf;
}
/*
* Write out the thread id (with an optional timestamp) and the
* malloc'ed buffer.
*/
_PUT_LOG(logFile, line, nb_tid);
_PUT_LOG(logFile, line_long, nb);
/* Ensure there is a trailing newline. */
if (!nb || (line_long[nb - 1] !=
'\n')) {
char eol[2];
eol[0] =
'\n';
eol[1] =
'\0';
_PUT_LOG(logFile, eol, 1);
}
_PR_UNLOCK_LOG();
PR_smprintf_free(line_long);
}
else {
/* Ensure there is a trailing newline. */
if (nb && (line[nb - 1] !=
'\n')) {
line[nb++] =
'\n';
line[nb] =
'\0';
}
_PR_LOCK_LOG();
if (logBuf == 0) {
_PUT_LOG(logFile, line, nb);
}
else {
/* If nb can't fit into logBuf, write out logBuf first. */
if (logp + nb > logEndp) {
_PUT_LOG(logFile, logBuf, logp - logBuf);
logp = logBuf;
}
/* nb is guaranteed to fit into logBuf. */
memcpy(logp, line, nb);
logp += nb;
}
_PR_UNLOCK_LOG();
}
PR_LogFlush();
}
PR_IMPLEMENT(
void) PR_LogFlush(
void) {
if (logBuf && logFile) {
_PR_LOCK_LOG();
if (logp > logBuf) {
_PUT_LOG(logFile, logBuf, logp - logBuf);
logp = logBuf;
}
_PR_UNLOCK_LOG();
}
}
PR_IMPLEMENT(
void) PR_Abort(
void) {
PR_LogPrint(
"Aborting");
#ifdef ANDROID
__android_log_write(ANDROID_LOG_ERROR,
"PRLog",
"Aborting");
#endif
abort();
}
PR_IMPLEMENT(
void) PR_Assert(
const char* s,
const char* file, PRIntn ln) {
PR_LogPrint(
"Assertion failure: %s, at %s:%d\n", s, file, ln);
fprintf(stderr,
"Assertion failure: %s, at %s:%d\n", s, file, ln);
fflush(stderr);
#ifdef WIN32
DebugBreak();
#elif defined(ANDROID)
__android_log_assert(NULL,
"PRLog",
"Assertion failure: %s, at %s:%d\n", s,
file, ln);
#endif
abort();
}
