ncurses/trace/lib_trace.c

   1 /****************************************************************************
   2  * Copyright 2018-2021,2022 Thomas E. Dickey                                *
   3  * Copyright 1998-2016,2017 Free Software Foundation, Inc.                  *
   4  *                                                                          *
   5  * Permission is hereby granted, free of charge, to any person obtaining a  *
   6  * copy of this software and associated documentation files (the            *
   7  * "Software"), to deal in the Software without restriction, including      *
   8  * without limitation the rights to use, copy, modify, merge, publish,      *
   9  * distribute, distribute with modifications, sublicense, and/or sell       *
  10  * copies of the Software, and to permit persons to whom the Software is    *
  11  * furnished to do so, subject to the following conditions:                 *
  12  *                                                                          *
  13  * The above copyright notice and this permission notice shall be included  *
  14  * in all copies or substantial portions of the Software.                   *
  15  *                                                                          *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  23  *                                                                          *
  24  * Except as contained in this notice, the name(s) of the above copyright   *
  25  * holders shall not be used in advertising or otherwise to promote the     *
  26  * sale, use or other dealings in this Software without prior written       *
  27  * authorization.                                                           *
  28  ****************************************************************************/
  29
  30 /****************************************************************************
  31  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  32  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
  33  *     and: Thomas E. Dickey                        1996-on                 *
  34  *     and: Juergen Pfeifer                                                 *
  35  ****************************************************************************/
  36
  37 /*
  38  *      lib_trace.c - Tracing/Debugging routines
  39  *
  40  * The _tracef() function is originally from pcurses (by Pavel Curtis) in 1982.
  41  * pcurses allowed one to enable/disable tracing using traceon() and traceoff()
  42  * functions.  ncurses provides a trace() function which allows one to
  43  * selectively enable or disable several tracing features.
  44  */
  45
  46 #include <curses.priv.h>
  47 #include <tic.h>
  48
  49 #include <ctype.h>
  50
  51 MODULE_ID("$Id: lib_trace.c,v 1.101 2022/09/17 14:57:02 tom Exp $")
  52
  53 NCURSES_EXPORT_VAR(unsigned) _nc_tracing = 0; /* always define this */
  54
  55 #ifdef TRACE
  56
  57 #if USE_REENTRANT
  58 NCURSES_EXPORT(const char *)
  59 NCURSES_PUBLIC_VAR(_nc_tputs_trace) (void)
  60 {
  61     return CURRENT_SCREEN ? CURRENT_SCREEN->_tputs_trace : _nc_prescreen._tputs_trace;
  62 }
  63 NCURSES_EXPORT(long)
  64 NCURSES_PUBLIC_VAR(_nc_outchars) (void)
  65 {
  66     return CURRENT_SCREEN ? CURRENT_SCREEN->_outchars : _nc_prescreen._outchars;
  67 }
  68 NCURSES_EXPORT(void)
  69 _nc_set_tputs_trace(const char *s)
  70 {
  71     if (CURRENT_SCREEN)
  72         CURRENT_SCREEN->_tputs_trace = s;
  73     else
  74         _nc_prescreen._tputs_trace = s;
  75 }
  76 NCURSES_EXPORT(void)
  77 _nc_count_outchars(long increment)
  78 {
  79     if (CURRENT_SCREEN)
  80         CURRENT_SCREEN->_outchars += increment;
  81     else
  82         _nc_prescreen._outchars += increment;
  83 }
  84 #else
  85 NCURSES_EXPORT_VAR(const char *) _nc_tputs_trace = "";
  86 NCURSES_EXPORT_VAR(long) _nc_outchars = 0;
  87 #endif
  88
  89 #define MyFP            _nc_globals.trace_fp
  90 #define MyFD            _nc_globals.trace_fd
  91 #define MyInit          _nc_globals.trace_opened
  92 #define MyPath          _nc_globals.trace_fname
  93 #define MyLevel         _nc_globals.trace_level
  94 #define MyNested        _nc_globals.nested_tracef
  95 #endif /* TRACE */
  96
  97 #if USE_REENTRANT
  98 #define Locked(statement) { \
  99         _nc_lock_global(tst_tracef); \
 100         statement; \
 101         _nc_unlock_global(tst_tracef); \
 102     }
 103 #else
 104 #define Locked(statement) statement
 105 #endif
 106
 107 NCURSES_EXPORT(unsigned)
 108 curses_trace(unsigned tracelevel)
 109 {
 110     unsigned result;
 111
 112 #if defined(TRACE)
 113     int bit;
 114
 115 #define DATA(name) { name, #name }
 116     static struct {
 117         unsigned mask;
 118         const char *name;
 119     } trace_names[] = {
 120         DATA(TRACE_TIMES),
 121             DATA(TRACE_TPUTS),
 122             DATA(TRACE_UPDATE),
 123             DATA(TRACE_MOVE),
 124             DATA(TRACE_CHARPUT),
 125             DATA(TRACE_CALLS),
 126             DATA(TRACE_VIRTPUT),
 127             DATA(TRACE_IEVENT),
 128             DATA(TRACE_BITS),
 129             DATA(TRACE_ICALLS),
 130             DATA(TRACE_CCALLS),
 131             DATA(TRACE_DATABASE),
 132             DATA(TRACE_ATTRS)
 133     };
 134 #undef DATA
 135
 136     Locked(result = _nc_tracing);
 137
 138     if ((MyFP == 0) && tracelevel) {
 139         MyInit = TRUE;
 140         if (MyFD >= 0) {
 141             MyFP = fdopen(MyFD, BIN_W);
 142         } else {
 143             if (MyPath[0] == '\0') {
 144                 size_t size = sizeof(MyPath) - 12;
 145                 if (getcwd(MyPath, size) == 0) {
 146                     perror("curses: Can't get working directory");
 147                     exit(EXIT_FAILURE);
 148                 }
 149                 MyPath[size] = '\0';
 150                 assert(strlen(MyPath) <= size);
 151                 _nc_STRCAT(MyPath, "/trace", sizeof(MyPath));
 152                 if (_nc_is_dir_path(MyPath)) {
 153                     _nc_STRCAT(MyPath, ".log", sizeof(MyPath));
 154                 }
 155             }
 156 #define SAFE_MODE (O_CREAT | O_EXCL | O_RDWR)
 157             if (_nc_access(MyPath, W_OK) < 0
 158                 || (MyFD = safe_open3(MyPath, SAFE_MODE, 0600)) < 0
 159                 || (MyFP = fdopen(MyFD, BIN_W)) == 0) {
 160                 ;               /* EMPTY */
 161             }
 162         }
 163         Locked(_nc_tracing = tracelevel);
 164         /* Try to set line-buffered mode, or (failing that) unbuffered,
 165          * so that the trace-output gets flushed automatically at the
 166          * end of each line.  This is useful in case the program dies.
 167          */
 168         if (MyFP != 0) {
 169 #if HAVE_SETVBUF                /* ANSI */
 170             (void) setvbuf(MyFP, (char *) 0, _IOLBF, (size_t) 0);
 171 #elif HAVE_SETBUF /* POSIX */
 172             (void) setbuffer(MyFP, (char *) 0);
 173 #endif
 174         }
 175         _tracef("TRACING NCURSES version %s.%d (tracelevel=%#x)",
 176                 NCURSES_VERSION,
 177                 NCURSES_VERSION_PATCH,
 178                 tracelevel);
 179
 180 #define SPECIAL_MASK(mask) \
 181             if ((tracelevel & mask) == mask) \
 182                 _tracef("- %s (%u)", #mask, mask)
 183
 184         for (bit = 0; bit < TRACE_SHIFT; ++bit) {
 185             unsigned mask = (1U << bit) & tracelevel;
 186             if ((mask & trace_names[bit].mask) != 0) {
 187                 _tracef("- %s (%u)", trace_names[bit].name, mask);
 188             }
 189         }
 190         SPECIAL_MASK(TRACE_MAXIMUM);
 191         else
 192         SPECIAL_MASK(TRACE_ORDINARY);
 193
 194         if (tracelevel > TRACE_MAXIMUM) {
 195             _tracef("- DEBUG_LEVEL(%u)", tracelevel >> TRACE_SHIFT);
 196         }
 197     } else if (tracelevel == 0) {
 198         if (MyFP != 0) {
 199             MyFD = dup(MyFD);   /* allow reopen of same file */
 200             fclose(MyFP);
 201             MyFP = 0;
 202         }
 203         Locked(_nc_tracing = tracelevel);
 204     } else if (_nc_tracing != tracelevel) {
 205         Locked(_nc_tracing = tracelevel);
 206         _tracef("tracelevel=%#x", tracelevel);
 207     }
 208 #else
 209     (void) tracelevel;
 210     result = 0;
 211 #endif
 212     return result;
 213 }
 214
 215 #if defined(TRACE)
 216 NCURSES_EXPORT(void)
 217 trace(const unsigned int tracelevel)
 218 {
 219     curses_trace(tracelevel);
 220 }
 221
 222 static void
 223 _nc_va_tracef(const char *fmt, va_list ap)
 224 {
 225     static const char Called[] = T_CALLED("");
 226     static const char Return[] = T_RETURN("");
 227
 228     bool before = FALSE;
 229     bool after = FALSE;
 230     unsigned doit = _nc_tracing;
 231     int save_err = errno;
 232     FILE *fp = MyFP;
 233
 234 #ifdef TRACE
 235     /* verbose-trace in the command-line utilities relies on this */
 236     if (fp == 0 && !MyInit && _nc_tracing >= DEBUG_LEVEL(1))
 237         fp = stderr;
 238 #endif
 239
 240     if (strlen(fmt) >= sizeof(Called) - 1) {
 241         if (!strncmp(fmt, Called, sizeof(Called) - 1)) {
 242             before = TRUE;
 243             MyLevel++;
 244         } else if (!strncmp(fmt, Return, sizeof(Return) - 1)) {
 245             after = TRUE;
 246         }
 247         if (before || after) {
 248             if ((MyLevel <= 1)
 249                 || (doit & TRACE_ICALLS) != 0)
 250                 doit &= (TRACE_CALLS | TRACE_CCALLS);
 251             else
 252                 doit = 0;
 253         }
 254     }
 255
 256     if (doit != 0 && fp != 0) {
 257 #ifdef USE_PTHREADS
 258         /*
 259          * TRACE_ICALLS is "really" needed to show normal use with threaded
 260          * applications, since anything can be running during a napms(),
 261          * making it appear in the hierarchical trace as it other functions
 262          * are being called.
 263          *
 264          * Rather than add the complication of a per-thread stack, just
 265          * show the thread-id in each line of the trace.
 266          */
 267 # if USE_WEAK_SYMBOLS
 268         if ((pthread_self))
 269 # endif
 270 #ifdef _NC_WINDOWS
 271             fprintf(fp, "%#lx:", (long) (intptr_t) pthread_self().p);
 272 #else
 273             fprintf(fp, "%#lx:", (long) (intptr_t) pthread_self());
 274 #endif
 275 #endif
 276         if (before || after) {
 277             int n;
 278             for (n = 1; n < MyLevel; n++)
 279                 fputs("+ ", fp);
 280         }
 281         vfprintf(fp, fmt, ap);
 282         fputc('\n', fp);
 283         fflush(fp);
 284     }
 285
 286     if (after && MyLevel)
 287         MyLevel--;
 288
 289     errno = save_err;
 290 }
 291
 292 NCURSES_EXPORT(void)
 293 _tracef(const char *fmt, ...)
 294 {
 295     va_list ap;
 296
 297     va_start(ap, fmt);
 298     _nc_va_tracef(fmt, ap);
 299     va_end(ap);
 300 }
 301
 302 /* Trace 'bool' return-values */
 303 NCURSES_EXPORT(NCURSES_BOOL)
 304 _nc_retrace_bool(int code)
 305 {
 306     T((T_RETURN("%s"), code ? "TRUE" : "FALSE"));
 307     return code;
 308 }
 309
 310 /* Trace 'char' return-values */
 311 NCURSES_EXPORT(char)
 312 _nc_retrace_char(int code)
 313 {
 314     T((T_RETURN("%c"), code));
 315     return (char) code;
 316 }
 317
 318 /* Trace 'int' return-values */
 319 NCURSES_EXPORT(int)
 320 _nc_retrace_int(int code)
 321 {
 322     T((T_RETURN("%d"), code));
 323     return code;
 324 }
 325
 326 /* Trace 'unsigned' return-values */
 327 NCURSES_EXPORT(unsigned)
 328 _nc_retrace_unsigned(unsigned code)
 329 {
 330     T((T_RETURN("%#x"), code));
 331     return code;
 332 }
 333
 334 /* Trace 'char*' return-values */
 335 NCURSES_EXPORT(char *)
 336 _nc_retrace_ptr(char *code)
 337 {
 338     T((T_RETURN("%s"), _nc_visbuf(code)));
 339     return code;
 340 }
 341
 342 /* Trace 'const char*' return-values */
 343 NCURSES_EXPORT(const char *)
 344 _nc_retrace_cptr(const char *code)
 345 {
 346     T((T_RETURN("%s"), _nc_visbuf(code)));
 347     return code;
 348 }
 349
 350 /* Trace 'NCURSES_CONST void*' return-values */
 351 NCURSES_EXPORT(NCURSES_CONST void *)
 352 _nc_retrace_cvoid_ptr(NCURSES_CONST void *code)
 353 {
 354     T((T_RETURN("%p"), code));
 355     return code;
 356 }
 357
 358 /* Trace 'void*' return-values */
 359 NCURSES_EXPORT(void *)
 360 _nc_retrace_void_ptr(void *code)
 361 {
 362     T((T_RETURN("%p"), code));
 363     return code;
 364 }
 365
 366 /* Trace 'SCREEN *' return-values */
 367 NCURSES_EXPORT(SCREEN *)
 368 _nc_retrace_sp(SCREEN *code)
 369 {
 370     T((T_RETURN("%p"), (void *) code));
 371     return code;
 372 }
 373
 374 /* Trace 'WINDOW *' return-values */
 375 NCURSES_EXPORT(WINDOW *)
 376 _nc_retrace_win(WINDOW *code)
 377 {
 378     T((T_RETURN("%p"), (void *) code));
 379     return code;
 380 }
 381
 382 NCURSES_EXPORT(char *)
 383 _nc_fmt_funcptr(char *target, const char *source, size_t size)
 384 {
 385     size_t n;
 386     char *dst = target;
 387     bool leading = TRUE;
 388
 389     union {
 390         int value;
 391         char bytes[sizeof(int)];
 392     } byteorder;
 393
 394     byteorder.value = 0x1234;
 395
 396     *dst++ = '0';
 397     *dst++ = 'x';
 398
 399     for (n = 0; n < size; ++n) {
 400         unsigned ch = ((byteorder.bytes[0] == 0x34)
 401                        ? UChar(source[size - n - 1])
 402                        : UChar(source[n]));
 403         if (ch != 0 || (n + 1) >= size)
 404             leading = FALSE;
 405         if (!leading) {
 406             _nc_SPRINTF(dst, _nc_SLIMIT(TR_FUNC_LEN - (size_t) (dst - target))
 407                         "%02x", ch & 0xff);
 408             dst += 2;
 409         }
 410     }
 411     *dst = '\0';
 412     return target;
 413 }
 414
 415 #if USE_REENTRANT
 416 /*
 417  * Check if the given trace-mask is enabled.
 418  *
 419  * This function may be called from within one of the functions that fills
 420  * in parameters for _tracef(), but in that case we do not want to lock the
 421  * mutex, since it is already locked.
 422  */
 423 NCURSES_EXPORT(int)
 424 _nc_use_tracef(unsigned mask)
 425 {
 426     bool result = FALSE;
 427
 428     _nc_lock_global(tst_tracef);
 429     if (!MyNested++) {
 430         if ((result = (_nc_tracing & (mask))) != 0
 431             && _nc_try_global(tracef) == 0) {
 432             /* we will call _nc_locked_tracef(), no nesting so far */
 433         } else {
 434             /* we will not call _nc_locked_tracef() */
 435             MyNested = 0;
 436         }
 437     } else {
 438         /* we may call _nc_locked_tracef(), but with nested_tracef > 0 */
 439         result = (_nc_tracing & (mask));
 440     }
 441     _nc_unlock_global(tst_tracef);
 442     return result;
 443 }
 444
 445 /*
 446  * We call this if _nc_use_tracef() returns true, which means we must unlock
 447  * the tracef mutex.
 448  */
 449 NCURSES_EXPORT(void)
 450 _nc_locked_tracef(const char *fmt, ...)
 451 {
 452     va_list ap;
 453
 454     va_start(ap, fmt);
 455     _nc_va_tracef(fmt, ap);
 456     va_end(ap);
 457
 458     if (--(MyNested) == 0) {
 459         _nc_unlock_global(tracef);
 460     }
 461 }
 462 #endif /* USE_REENTRANT */
 463
 464 #endif /* TRACE */