/* debug.c - helpful output in desperate situations
 * Copyright (C) 2000 Werner Koch (dd9jn)
 * Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2009, 2019 g10 Code GmbH
 *
 * This file is part of GPGME.
 *
 * GPGME is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * GPGME is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, see <https://gnu.org/licenses/>.
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#if HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <ctype.h>
#include <errno.h>
#include <time.h>
#ifndef HAVE_DOSISH_SYSTEM
# ifdef HAVE_SYS_TYPES_H
#  include <sys/types.h>
# endif
# ifdef HAVE_SYS_STAT_H
#  include <sys/stat.h>
# endif
# include <fcntl.h>
#endif
#include <assert.h>

#include "util.h"
#include "ath.h"
#include "sema.h"
#include "sys-util.h"
#include "debug.h"


/* The amount of detail requested by the user, per environment
   variable GPGME_DEBUG.  */
static int debug_level;

/* The output stream for the debug messages.  */
static FILE *errfp;

/* If not NULL, this malloced string is used instead of the
   GPGME_DEBUG envvar.  It must have been set before the debug
   subsystem has been initialized.  Using it later may or may not have
   any effect.  */
static char *envvar_override;


#ifdef HAVE_TLS
#define FRAME_NR
static __thread int frame_nr = 0;
#endif

void
_gpgme_debug_frame_begin (void)
{
#ifdef FRAME_NR
  frame_nr++;
#endif
}

int _gpgme_debug_frame_end (void)
{
#ifdef FRAME_NR
  frame_nr--;
#endif
  return 0;
}



/* Remove leading and trailing white spaces.  */
static char *
trim_spaces (char *str)
{
  char *string, *p, *mark;

  string = str;
  /* Find first non space character.  */
  for (p = string; *p && isspace (*(unsigned char *) p); p++)
    ;
  /* Move characters.  */
  for (mark = NULL; (*string = *p); string++, p++)
    if (isspace (*(unsigned char *) p))
      {
	if (!mark)
	  mark = string;
      }
    else
      mark = NULL;
  if (mark)
    *mark = '\0';	/* Remove trailing spaces.  */

  return str;
}


/* This is an internal function to set debug info.  The caller must
   assure that this function is called only by one thread at a time.
   The function may have no effect if called after the debug system
   has been initialized.  Returns 0 on success.  */
int
_gpgme_debug_set_debug_envvar (const char *value)
{
  free (envvar_override);
  envvar_override = strdup (value);
  return !envvar_override;
}


static void
debug_init (void)
{
  static int initialized;

  if (!initialized)
    {
      gpgme_error_t err;
      char *e;
      const char *s1, *s2;;

      if (envvar_override)
        {
          e = strdup (envvar_override);
          free (envvar_override);
          envvar_override = NULL;
        }
      else
        {
          err = _gpgme_getenv ("GPGME_DEBUG", &e);
          if (err)
            return;
        }

      initialized = 1;
      errfp = stderr;
      if (e)
	{
	  debug_level = atoi (e);
	  s1 = strchr (e, PATHSEP_C);
	  if (s1)
	    {
#ifndef HAVE_DOSISH_SYSTEM
	      if (getuid () == geteuid ()
#if defined(HAVE_GETGID) && defined(HAVE_GETEGID)
                  && getgid () == getegid ()
#endif
                  )
		{
#endif
		  char *p;
		  FILE *fp;

		  s1++;
		  if (!(s2 = strchr (s1, PATHSEP_C)))
		    s2 = s1 + strlen (s1);
		  p = malloc (s2 - s1 + 1);
		  if (p)
		    {
		      memcpy (p, s1, s2 - s1);
		      p[s2-s1] = 0;
		      trim_spaces (p);
		      fp = fopen (p,"a");
		      if (fp)
			{
			  setvbuf (fp, NULL, _IOLBF, 0);
			  errfp = fp;
			}
		      free (p);
		    }
#ifndef HAVE_DOSISH_SYSTEM
		}
#endif
	    }
	  free (e);
        }
    }

  if (debug_level > 0)
    {
      _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                    "gpgme_debug: level=%d\n", debug_level);
#ifdef HAVE_W32_SYSTEM
      {
        const char *name = _gpgme_get_inst_dir ();
        _gpgme_debug (NULL, DEBUG_INIT, -1, NULL, NULL, NULL,
                      "gpgme_debug: gpgme='%s'\n", name? name: "?");
      }
#endif
    }
}



/* This should be called as soon as possible.  It is required so that
 * the assuan logging gets connected to the gpgme log stream as early
 * as possible.  */
void
_gpgme_debug_subsystem_init (void)
{
  debug_init ();
}




/* Log the formatted string FORMAT prefixed with additional info
 * depending on MODE:
 *
 * -1 = Do not print any additional args.
 *  0 = standalone (used by macro TRACE)
 *  1 = enter a function (used by macro TRACE_BEG)
 *  2 = debug a function (used by macro TRACE_LOG)
 *  3 = leave a function (used by macro TRACE_SUC)
 *
 * If LINE is not NULL the output will be stored in that variabale but
 * without a LF.  _gpgme_debug_add can be used to add more and
 * _gpgme_debug_end to finally output it.
 *
 * Returns: 0
 *
 * Note that we always return 0 because the old TRACE macro evaluated
 * to 0 which issues a warning with newer gcc version about an unused
 * values.  By using a return value of this function this can be
 * avoided.  Fixme: It might be useful to check whether the return
 * value from the TRACE macros are actually used somewhere.
 */
int
_gpgme_debug (void **line, int level, int mode,
              const char *func, const char *tagname,
              const char *tagvalue, const char *format, ...)
{
  va_list arg_ptr;
  int saved_errno;
  int need_lf;
  int indent;
  char *prefix, *stdinfo, *userinfo;
  const char *modestr;
  int no_userinfo = 0;

  if (debug_level < level)
    return 0;

#ifdef FRAME_NR
    indent = frame_nr > 0? (2 * (frame_nr - 1)):0;
#else
    indent = 0;
#endif

  saved_errno = errno;
  va_start (arg_ptr, format);
  {
    struct tm *tp;
    time_t atime = time (NULL);

    tp = localtime (&atime);
    prefix = gpgrt_bsprintf ("GPGME %04d%02d%02dT%02d%02d%02d %04llX  %*s",
                             1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
                             tp->tm_hour, tp->tm_min, tp->tm_sec,
                             (unsigned long long) ath_self (),
                             indent < 40? indent : 40, "");
  }

  switch (mode)
    {
    case -1: modestr = NULL; break; /* Do nothing.  */
    case 0: modestr = "call"; break;
    case 1: modestr = "enter"; break;
    case 2: modestr = "check"; break;
    case 3: modestr = "leave"; break;
    default: modestr = "mode?"; break;
    }

  if (!modestr)
    stdinfo = NULL;
  else if (tagname && strcmp (tagname, XSTRINGIFY (NULL)))
    stdinfo = gpgrt_bsprintf ("%s: %s: %s=%p ", func,modestr,tagname,tagvalue);
  else
    stdinfo = gpgrt_bsprintf ("%s: %s: ", func, modestr);

  if (format && *format)
    userinfo = gpgrt_vbsprintf (format, arg_ptr);
  else
    {
      userinfo = NULL;
      no_userinfo = 1;
    }
  va_end (arg_ptr);

  if (mode != -1 && (!format || !*format))
    need_lf = 1;
  else if (userinfo && *userinfo && userinfo[strlen (userinfo) - 1] != '\n')
    need_lf = 1;
  else
    need_lf = 0;

  if (line)
    *line = gpgrt_bsprintf ("%s%s%s",
                            prefix? prefix : "GPGME out-of-core ",
                            !modestr? "" : stdinfo? stdinfo :
                            (!format || !*format)? "" :"out-of-core ",
                            userinfo? userinfo : "out-of-core");
  else
    {
      fprintf (errfp, "%s%s%s%s",
               prefix? prefix : "GPGME out-of-core ",
               !modestr? "" : stdinfo? stdinfo :
               (!format || !*format)? "" :"out-of-core ",
               userinfo? userinfo : no_userinfo? "" : "out-of-core",
               need_lf? "\n":"");
      fflush (errfp);
    }

  gpgrt_free (userinfo);
  gpgrt_free (stdinfo);
  gpgrt_free (prefix);
  gpg_err_set_errno (saved_errno);
  return 0;
}


/* Add the formatted string FORMAT to the debug line *LINE.  */
void
_gpgme_debug_add (void **line, const char *format, ...)
{
  va_list arg_ptr;
  char *toadd;
  char *result;
  int res;

  if (!*line)
    return;

  va_start (arg_ptr, format);
  res = gpgrt_vasprintf (&toadd, format, arg_ptr);
  va_end (arg_ptr);
  if (res < 0)
    {
      gpgrt_free (*line);
      *line = NULL;
    }
  res = gpgrt_asprintf (&result, "%s%s", *(char **) line, toadd);
  gpgrt_free (toadd);
  gpgrt_free (*line);
  if (res < 0)
    *line = NULL;
  else
    *line = result;
}


/* Finish construction of *LINE and send it to the debug output
   stream.  */
void
_gpgme_debug_end (void **line)
{
  const char *string;

  if (!*line)
    return;
  string = *line;

  fprintf (errfp, "%s%s",
           string,
           (*string && string[strlen (string)-1] != '\n')? "\n":"");
  fflush (errfp);
  gpgrt_free (*line);
  *line = NULL;
}


#define TOHEX(val) (((val) < 10) ? ((val) + '0') : ((val) - 10 + 'a'))

void
_gpgme_debug_buffer (int lvl, const char *const fmt,
		     const char *const func, const char *const buffer,
		     size_t len)
{
  int idx = 0;
  int j;

  if (!_gpgme_debug_trace ())
    return;

  if (!buffer)
    return;

  if (lvl > 9)
    {
      while (idx < len)
        {
          char str[51];
          char *strp = str;
          char *strp2 = &str[34];

          for (j = 0; j < 16; j++)
            {
              unsigned char val;
              if (idx < len)
                {
                  val = buffer[idx++];
                  *(strp++) = TOHEX (val >> 4);
                  *(strp++) = TOHEX (val % 16);
                  *(strp2++) = isprint (val)? val : '.';
                }
              else
                {
                  *(strp++) = ' ';
                  *(strp++) = ' ';
                }
              if (j == 7)
                *(strp++) = ' ';
            }
          *(strp++) = ' ';
          *(strp2) = '\0';

          _gpgme_debug (NULL, lvl, -1, NULL, NULL, NULL, fmt, func, str);
        }
    }
  else
    {
      while (idx < len)
        {
          char str[48+4+1];
          char *strp = str;

          for (j = 0; j < 48; j++)
            {
              unsigned char val;
              if (idx < len)
                {
                  val = buffer[idx++];
                  if (val == '\n')
                    {
                      *strp++ = '<';
                      *strp++ = 'L';
                      *strp++ = 'F';
                      *strp++ = '>';
                      break;
                    }
                  *strp++ = (val > 31 && val < 127)? val : '.';
                }
            }
          *strp = 0;

          _gpgme_debug (NULL, lvl, -1, NULL, NULL, NULL, fmt, func, str);
        }
    }
}