Layout.c

 
#include <winpr/config.h>
 
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
 
#include <winpr/crt.h>
#include <winpr/assert.h>
#include <winpr/print.h>
#include <winpr/sysinfo.h>
#include <winpr/environment.h>
 
#include "wlog.h"
 
#include "Layout.h"
 
#if defined __linux__ && !defined ANDROID
#include <unistd.h>
#include <sys/syscall.h>
#endif
 
#ifndef MIN
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif
 
struct format_option_recurse;
 
struct format_tid_arg
{
  char tid[32];
};
 
struct format_option
{
  const char* fmt;
  size_t fmtlen;
  const char* replace;
  size_t replacelen;
  const char* (*fkt)(void*);
  union
  {
    void* pv;
    const void* cpv;
    size_t s;
  } arg;
  const char* (*ext)(const struct format_option* opt, const char* str, size_t* preplacelen,
                     size_t* pskiplen);
  struct format_option_recurse* recurse;
};
 
struct format_option_recurse
{
  struct format_option* options;
  size_t nroptions;
  wLog* log;
  wLogLayout* layout;
  const wLogMessage* message;
  char buffer[WLOG_MAX_PREFIX_SIZE];
};
 
WINPR_ATTR_FORMAT_ARG(3, 0)
static void WLog_PrintMessagePrefixVA(char* prefix, size_t prefixlen,
                                      WINPR_FORMAT_ARG const char* format, va_list args)
{
  (void)vsnprintf(prefix, prefixlen, format, args);
}
 
WINPR_ATTR_FORMAT_ARG(3, 4)
static void WLog_PrintMessagePrefix(char* prefix, size_t prefixlen,
                                    WINPR_FORMAT_ARG const char* format, ...)
{
  va_list args = WINPR_C_ARRAY_INIT;
  va_start(args, format);
  WLog_PrintMessagePrefixVA(prefix, prefixlen, format, args);
  va_end(args);
}
 
static const char* get_tid(void* arg)
{
  struct format_tid_arg* targ = arg;
  WINPR_ASSERT(targ);
 
  size_t tid = 0;
#if defined __linux__ && !defined ANDROID
  /* On Linux we prefer to see the LWP id */
  tid = (size_t)syscall(SYS_gettid);
#else
  tid = (size_t)GetCurrentThreadId();
#endif
  (void)_snprintf(targ->tid, sizeof(targ->tid), "%08" PRIxz, tid);
  return targ->tid;
}
 
static BOOL log_invalid_fmt(const char* what)
{
  (void)fprintf(stderr, "Invalid format string '%s'\n", what);
  return FALSE;
}
 
static BOOL check_and_log_format_size(char* format, size_t size, size_t index, size_t add)
{
  /* format string must be '\0' terminated, so abort at size - 1 */
  if (index + add + 1 >= size)
  {
    (void)fprintf(stderr,
                  "Format string too long ['%s', max %" PRIuz ", used %" PRIuz
                  ", adding %" PRIuz "]\n",
                  format, size, index, add);
    return FALSE;
  }
  return TRUE;
}
 
static int opt_compare_fn(const void* a, const void* b)
{
  const char* what = a;
  const struct format_option* opt = b;
  if (!opt)
    return -1;
  return strncmp(what, opt->fmt, opt->fmtlen);
}
 
static BOOL replace_format_string(const char* FormatString, struct format_option_recurse* recurse,
                                  char* format, size_t formatlen);
 
static const char* skip_if_null(const struct format_option* opt, const char* fmt,
                                size_t* preplacelen, size_t* pskiplen)
{
  WINPR_ASSERT(opt);
  WINPR_ASSERT(fmt);
  WINPR_ASSERT(preplacelen);
  WINPR_ASSERT(pskiplen);
 
  *preplacelen = 0;
  *pskiplen = 0;
 
  const char* str = &fmt[opt->fmtlen]; /* Skip first %{ from string */
  const char* end = strstr(str, opt->replace);
  if (!end)
    return nullptr;
  *pskiplen = WINPR_ASSERTING_INT_CAST(size_t, end - fmt) + opt->replacelen;
 
  if (!opt->arg.cpv)
    return nullptr;
 
  const size_t replacelen = WINPR_ASSERTING_INT_CAST(size_t, end - str);
 
  char buffer[WLOG_MAX_PREFIX_SIZE] = WINPR_C_ARRAY_INIT;
  memcpy(buffer, str, MIN(replacelen, ARRAYSIZE(buffer) - 1));
 
  if (!replace_format_string(buffer, opt->recurse, opt->recurse->buffer,
                             ARRAYSIZE(opt->recurse->buffer)))
    return nullptr;
 
  *preplacelen = strnlen(opt->recurse->buffer, ARRAYSIZE(opt->recurse->buffer));
  return opt->recurse->buffer;
}
 
static BOOL replace_format_string(const char* FormatString, struct format_option_recurse* recurse,
                                  char* format, size_t formatlen)
{
  WINPR_ASSERT(FormatString);
  WINPR_ASSERT(recurse);
 
  size_t index = 0;
  const char* prefix = WLog_GetGlobalPrefix();
  if (prefix)
  {
    const int res = _snprintf(format, formatlen, "{%s}", prefix);
    if (res < 0)
      return FALSE;
    index = (size_t)res;
  }
 
  while (*FormatString)
  {
    const struct format_option* opt =
        bsearch(FormatString, recurse->options, recurse->nroptions,
                sizeof(struct format_option), opt_compare_fn);
    if (opt)
    {
      size_t replacelen = opt->replacelen;
      size_t fmtlen = opt->fmtlen;
      const char* replace = opt->replace;
      const void* arg = opt->arg.cpv;
 
      if (opt->ext)
        replace = opt->ext(opt, FormatString, &replacelen, &fmtlen);
      if (opt->fkt)
        arg = opt->fkt(opt->arg.pv);
 
      if (replace && (replacelen > 0))
      {
        WINPR_PRAGMA_DIAG_PUSH
        WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL
        const int rc = _snprintf(&format[index], formatlen - index, replace, arg);
        WINPR_PRAGMA_DIAG_POP
        if (rc < 0)
          return FALSE;
        if (!check_and_log_format_size(format, formatlen, index,
                                       WINPR_ASSERTING_INT_CAST(size_t, rc)))
          return FALSE;
        index += WINPR_ASSERTING_INT_CAST(size_t, rc);
      }
      FormatString += fmtlen;
    }
    else
    {
      /* Unknown format string */
      if (*FormatString == '%')
        return log_invalid_fmt(FormatString);
 
      if (!check_and_log_format_size(format, formatlen, index, 1))
        return FALSE;
      format[index++] = *FormatString++;
    }
  }
 
  return check_and_log_format_size(format, formatlen, index, 0);
}
 
BOOL WLog_Layout_GetMessagePrefix(wLog* log, wLogLayout* layout, const wLogMessage* message,
                                  char* prefix, size_t prefixlen)
{
  char format[WLOG_MAX_PREFIX_SIZE] = WINPR_C_ARRAY_INIT;
 
  WINPR_ASSERT(layout);
  WINPR_ASSERT(message);
  WINPR_ASSERT(prefix);
 
  struct format_tid_arg targ = WINPR_C_ARRAY_INIT;
 
  SYSTEMTIME localTime = WINPR_C_ARRAY_INIT;
  GetLocalTime(&localTime);
 
  struct format_option_recurse recurse = {
    .options = nullptr, .nroptions = 0, .log = log, .layout = layout, .message = message
  };
 
#define ENTRY(x) x, sizeof(x) - 1
  struct format_option options[] = {
    { ENTRY("%ctx"),
      ENTRY("%s"),
      log->custom,
      { .pv = log->context },
      nullptr,
      &recurse }, /* log context */
    { ENTRY("%dw"),
      ENTRY("%u"),
      nullptr,
      { .s = localTime.wDayOfWeek },
      nullptr,
      &recurse }, /* day of week */
    { ENTRY("%dy"),
      ENTRY("%u"),
      nullptr,
      { .s = localTime.wDay },
      nullptr,
      &recurse }, /* day of year
                   */
    { ENTRY("%fl"),
      ENTRY("%s"),
      nullptr,
      { .cpv = message->FileName },
      nullptr,
      &recurse }, /* file
                   */
    { ENTRY("%fn"),
      ENTRY("%s"),
      nullptr,
      { .cpv = message->FunctionName },
      nullptr,
      &recurse }, /* function
                   */
    { ENTRY("%hr"),
      ENTRY("%02u"),
      nullptr,
      { .s = localTime.wHour },
      nullptr,
      &recurse }, /* hours
                   */
    { ENTRY("%ln"),
      ENTRY("%" PRIuz),
      nullptr,
      { .s = message->LineNumber },
      nullptr,
      &recurse }, /* line number */
    { ENTRY("%lv"),
      ENTRY("%s"),
      nullptr,
      { .cpv = WLOG_LEVELS[message->Level] },
      nullptr,
      &recurse }, /* log level */
    { ENTRY("%mi"),
      ENTRY("%02u"),
      nullptr,
      { .s = localTime.wMinute },
      nullptr,
      &recurse }, /* minutes
                   */
    { ENTRY("%ml"),
      ENTRY("%03u"),
      nullptr,
      { .s = localTime.wMilliseconds },
      nullptr,
      &recurse }, /* milliseconds */
    { ENTRY("%mn"), ENTRY("%s"), nullptr, { .cpv = log->Name }, nullptr, &recurse }, /* module
                                                                                        name */
    { ENTRY("%mo"),
      ENTRY("%u"),
      nullptr,
      { .s = localTime.wMonth },
      nullptr,
      &recurse }, /* month
                   */
    { ENTRY("%pid"),
      ENTRY("%u"),
      nullptr,
      { .s = GetCurrentProcessId() },
      nullptr,
      &recurse }, /* process id */
    { ENTRY("%se"),
      ENTRY("%02u"),
      nullptr,
      { .s = localTime.wSecond },
      nullptr,
      &recurse },                                                                /* seconds
                                                                                  */
    { ENTRY("%tid"), ENTRY("%s"), get_tid, { .pv = &targ }, nullptr, &recurse }, /* thread id */
    { ENTRY("%yr"), ENTRY("%u"), nullptr, { .s = localTime.wYear }, nullptr, &recurse }, /* year
                                                                                          */
    { ENTRY("%{"),
      ENTRY("%}"),
      nullptr,
      { .pv = log->context },
      skip_if_null,
      &recurse }, /* skip if no context */
  };
 
  recurse.options = options;
  recurse.nroptions = ARRAYSIZE(options);
 
  if (!replace_format_string(layout->FormatString, &recurse, format, ARRAYSIZE(format)))
    return FALSE;
 
  WINPR_PRAGMA_DIAG_PUSH
  WINPR_PRAGMA_DIAG_IGNORED_FORMAT_SECURITY
 
  WLog_PrintMessagePrefix(prefix, prefixlen, format);
 
  WINPR_PRAGMA_DIAG_POP
 
  return TRUE;
}
 
wLogLayout* WLog_GetLogLayout(wLog* log)
{
  wLogAppender* appender = nullptr;
  appender = WLog_GetLogAppender(log);
  return appender->Layout;
}
 
BOOL WLog_Layout_SetPrefixFormat(WINPR_ATTR_UNUSED wLog* log, wLogLayout* layout,
                                 const char* format)
{
  free(layout->FormatString);
  layout->FormatString = nullptr;
 
  if (format)
  {
    layout->FormatString = _strdup(format);
 
    if (!layout->FormatString)
      return FALSE;
  }
 
  return TRUE;
}
 
wLogLayout* WLog_Layout_New(WINPR_ATTR_UNUSED wLog* log)
{
  LPCSTR prefix = "WLOG_PREFIX";
  DWORD nSize = 0;
  char* env = nullptr;
  wLogLayout* layout = nullptr;
  layout = (wLogLayout*)calloc(1, sizeof(wLogLayout));
 
  if (!layout)
    return nullptr;
 
  nSize = GetEnvironmentVariableA(prefix, nullptr, 0);
 
  if (nSize)
  {
    env = (LPSTR)malloc(nSize);
 
    if (!env)
    {
      free(layout);
      return nullptr;
    }
 
    if (GetEnvironmentVariableA(prefix, env, nSize) != nSize - 1)
    {
      free(env);
      free(layout);
      return nullptr;
    }
  }
 
  if (env)
    layout->FormatString = env;
  else
  {
#ifdef ANDROID
    layout->FormatString = _strdup("[pid=%pid:tid=%tid] - [%fn]%{[%ctx]%}: ");
#else
    layout->FormatString =
        _strdup("[%hr:%mi:%se:%ml] [%pid:%tid] [%lv][%mn] - [%fn]%{[%ctx]%}: ");
#endif
 
    if (!layout->FormatString)
    {
      free(layout);
      return nullptr;
    }
  }
 
  return layout;
}
 
void WLog_Layout_Free(WINPR_ATTR_UNUSED wLog* log, wLogLayout* layout)
{
  if (layout)
  {
    if (layout->FormatString)
    {
      free(layout->FormatString);
      layout->FormatString = nullptr;
    }
 
    free(layout);
  }
}