4f11210b21
* src/debug.c (_gpgme_debug_buffer): Switch between two output formats. -- The new format is much more practical than the bunch of hex digits followed by just 16 ascii chars. To get the old behaviour use a debug level of 10. Signed-off-by: Werner Koch <wk@gnupg.org>
468 lines
11 KiB
C
468 lines
11 KiB
C
/* 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);
|
||
}
|
||
}
|
||
}
|