Quelle  prlog.c   Sprache: C

/* -*- 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();
}