mhd_panic_tripwire.h

Go to the documentation of this file.

/*
  This file is part of libmicrohttpd
  Copyright (C) 2026 Christian Grothoff
 
  This library 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.
 
  This library 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 library.
  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef MHD_PANIC_TRIPWIRE_H
#define MHD_PANIC_TRIPWIRE_H 1
 
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#ifdef _WIN32
#include <io.h>
#else  /* ! _WIN32 */
#include <unistd.h>
#endif /* ! _WIN32 */
 
#define MHD_PANIC_TRIPWIRE_MARKER "MHD-PANIC-TRIPWIRE"
 
#define MHD_PANIC_TRIPWIRE_EXIT_STATUS 99
 
/* Detect a usable backtrace() implementation.  This must not depend on
   configure, because this header is also used from test directories that do
   not run any dedicated check for it.  Degrade silently when absent. */
#if ! defined(MHD_PANIC_TRIPWIRE_BACKTRACE_)
#  if defined(__has_include )
#    if __has_include (<execinfo.h>)
#      define MHD_PANIC_TRIPWIRE_BACKTRACE_ 1
#    endif /* __has_include(<execinfo.h>) */
#  elif defined(HAVE_EXECINFO_H) || defined(__GLIBC__)
#    define MHD_PANIC_TRIPWIRE_BACKTRACE_ 1
#  endif /* HAVE_EXECINFO_H || __GLIBC__ */
#endif /* ! MHD_PANIC_TRIPWIRE_BACKTRACE_ */
#ifdef MHD_PANIC_TRIPWIRE_BACKTRACE_
#include <execinfo.h>
#endif /* MHD_PANIC_TRIPWIRE_BACKTRACE_ */
 
/* Weak references let this header be included by the unit tests that do not
   link libmicrohttpd (test_str*, test_md5, test_sha*, test_auth_parse, ...).
   Without weak-symbol support the MHD_PANIC() hook is simply not installed
   and only the abort() hook remains. */
#if defined(__GNUC__) && defined(__ELF__) && ! defined(_WIN32)
#  define MHD_PANIC_TRIPWIRE_WEAK_ __attribute__ ((weak))
#endif /* __GNUC__ && __ELF__ && ! _WIN32 */
 
#ifdef MHD_PANIC_TRIPWIRE_WEAK_
/* Deliberately declared here instead of pulling in <microhttpd.h>: the
   signature is identical to MHD_PanicCallback, so this declaration is
   compatible with the one in <microhttpd.h> when that header is also
   included, and it keeps this file usable in translation units that never
   see the public header. */
extern MHD_PANIC_TRIPWIRE_WEAK_ void
MHD_set_panic_func (void (*cb)(void *cls,
                               const char *file,
                               unsigned int line,
                               const char *reason),
                    void *cls);
 
#endif /* MHD_PANIC_TRIPWIRE_WEAK_ */
 
#if defined(__GNUC__) || defined(__clang__)
#  define MHD_PANIC_TRIPWIRE_UNUSED_ __attribute__ ((unused))
#  define MHD_PANIC_TRIPWIRE_NORETURN_ __attribute__ ((noreturn))
#else  /* ! __GNUC__ */
#  define MHD_PANIC_TRIPWIRE_UNUSED_
#  define MHD_PANIC_TRIPWIRE_NORETURN_
#endif /* ! __GNUC__ */
 
static volatile sig_atomic_t mhd_panic_tripwire_reraise_ = 0;
 
static volatile sig_atomic_t mhd_panic_tripwire_status_ =
  MHD_PANIC_TRIPWIRE_EXIT_STATUS;
 
static volatile sig_atomic_t mhd_panic_tripwire_busy_ = 0;
 
 
#define MHD_PANIC_TRIPWIRE_WRS_(str) \
        mhd_panic_tripwire_wr_ (str, sizeof(str) - 1)
 
 
static void
mhd_panic_tripwire_wr_ (const char *buf,
                        size_t len)
{
  size_t off = 0;
 
  while (off < len)
  {
#ifdef _WIN32
    int res = _write (2, buf + off, (unsigned int) (len - off));
#else  /* ! _WIN32 */
    ssize_t res = write (STDERR_FILENO, buf + off, len - off);
#endif /* ! _WIN32 */
    if (0 >= res)
      return; /* Give up rather than spin. */
    off += (size_t) res;
  }
}
 
 
static void
mhd_panic_tripwire_wr_clean_ (const char *str)
{
  char chunk[256];
  size_t used = 0;
 
  if (NULL == str)
  {
    MHD_PANIC_TRIPWIRE_WRS_ ("(null)");
    return;
  }
  while (0 != *str)
  {
    const unsigned char chr = (unsigned char) *str++;
 
    chunk[used++] = (0x20 > chr) ? ' ' : (char) chr;
    if (sizeof(chunk) == used)
    {
      mhd_panic_tripwire_wr_ (chunk, used);
      used = 0;
    }
  }
  if (0 != used)
    mhd_panic_tripwire_wr_ (chunk, used);
}
 
 
static void
mhd_panic_tripwire_wr_num_ (unsigned long val)
{
  char buf[24];
  size_t pos = sizeof(buf);
 
  do
  {
    buf[--pos] = (char) ('0' + (val % 10));
    val /= 10;
  } while (0 != val);
  mhd_panic_tripwire_wr_ (buf + pos, sizeof(buf) - pos);
}
 
 
static void
mhd_panic_tripwire_backtrace_ (void)
{
#ifdef MHD_PANIC_TRIPWIRE_BACKTRACE_
  void *frames[64];
  int num;
 
  num = backtrace (frames, (int) (sizeof(frames) / sizeof(frames[0])));
  if (0 >= num)
    return;
  MHD_PANIC_TRIPWIRE_WRS_ (MHD_PANIC_TRIPWIRE_MARKER "-FRAMES: ");
  mhd_panic_tripwire_wr_num_ ((unsigned long) num);
  MHD_PANIC_TRIPWIRE_WRS_ (" frames follow\n");
  /* backtrace_symbols_fd() does not allocate, unlike backtrace_symbols(). */
  backtrace_symbols_fd (frames, num, 2);
#endif /* MHD_PANIC_TRIPWIRE_BACKTRACE_ */
}
 
 
MHD_PANIC_TRIPWIRE_NORETURN_ static void
mhd_panic_tripwire_report_ (const char *kind,
                            const char *file,
                            unsigned int line,
                            const char *reason)
{
  if (0 == mhd_panic_tripwire_busy_)
  {
    mhd_panic_tripwire_busy_ = 1;
    MHD_PANIC_TRIPWIRE_WRS_ ("\n" MHD_PANIC_TRIPWIRE_MARKER ": kind=");
    mhd_panic_tripwire_wr_clean_ (kind);
    MHD_PANIC_TRIPWIRE_WRS_ (" file=");
    mhd_panic_tripwire_wr_clean_ ((NULL != file) ? file : "(unknown)");
    MHD_PANIC_TRIPWIRE_WRS_ (" line=");
    mhd_panic_tripwire_wr_num_ ((unsigned long) line);
    MHD_PANIC_TRIPWIRE_WRS_ (" reason=");
    mhd_panic_tripwire_wr_clean_ ((NULL != reason) ? reason : "(none)");
    MHD_PANIC_TRIPWIRE_WRS_ ("\n");
    mhd_panic_tripwire_backtrace_ ();
    if (0 == mhd_panic_tripwire_reraise_)
    {
      MHD_PANIC_TRIPWIRE_WRS_ (MHD_PANIC_TRIPWIRE_MARKER
                               ": terminating with exit status ");
      mhd_panic_tripwire_wr_num_ ((unsigned long) mhd_panic_tripwire_status_);
      MHD_PANIC_TRIPWIRE_WRS_ ("\n");
    }
    else
      MHD_PANIC_TRIPWIRE_WRS_ (MHD_PANIC_TRIPWIRE_MARKER
                               ": re-raising SIGABRT for a core dump\n");
  }
  if (0 != mhd_panic_tripwire_reraise_)
  {
    signal (SIGABRT, SIG_DFL);
    raise (SIGABRT);
  }
  _exit ((int) mhd_panic_tripwire_status_);
}
 
 
static void
mhd_panic_tripwire_panic_cb_ (void *cls,
                              const char *file,
                              unsigned int line,
                              const char *reason)
{
  (void) cls; /* Mute compiler warning. */
  mhd_panic_tripwire_report_ ("MHD_PANIC",
                              file,
                              line,
                              reason);
}
 
 
static void
mhd_panic_tripwire_abrt_cb_ (int sig)
{
  (void) sig; /* Mute compiler warning. */
  mhd_panic_tripwire_report_ ("abort",
                              NULL,
                              0,
                              "abort() reached; see the line above for the "
                              "failed assertion, if any");
}
 
 
static int
mhd_panic_tripwire_is_off_ (const char *val)
{
  if (NULL == val)
    return 0;
  return (0 == strcmp (val, "0")) ||
         (0 == strcmp (val, "off")) ||
         (0 == strcmp (val, "no")) ||
         (0 == strcmp (val, "disable"));
}
 
 
MHD_PANIC_TRIPWIRE_UNUSED_ static void
mhd_panic_tripwire_install (void)
{
  const char *mode = getenv ("MHD_TEST_PANIC_TRIPWIRE");
 
  if (mhd_panic_tripwire_is_off_ (mode))
    return; /* Leave the stock behaviour completely untouched. */
  if ((NULL != mode) && (0 == strcmp (mode, "abort")))
    mhd_panic_tripwire_reraise_ = 1;
  else if ((NULL != mode) && (0 == strncmp (mode, "exit:", 5)))
  {
    const long status = strtol (mode + 5, NULL, 10);
 
    if ((0 <= status) && (255 >= status))
      mhd_panic_tripwire_status_ = (sig_atomic_t) status;
  }
#ifdef MHD_PANIC_TRIPWIRE_WEAK_
  if (NULL != MHD_set_panic_func)
    MHD_set_panic_func (&mhd_panic_tripwire_panic_cb_,
                        NULL);
#else  /* ! MHD_PANIC_TRIPWIRE_WEAK_ */
  MHD_set_panic_func (&mhd_panic_tripwire_panic_cb_,
                      NULL);
#endif /* ! MHD_PANIC_TRIPWIRE_WEAK_ */
  if (! mhd_panic_tripwire_is_off_ (getenv ("MHD_TEST_PANIC_TRIPWIRE_ABRT")))
    signal (SIGABRT,
            &mhd_panic_tripwire_abrt_cb_);
}
 
 
#if defined(__GNUC__) || defined(__clang__)
__attribute__ ((constructor)) static void
mhd_panic_tripwire_ctor_ (void)
{
  mhd_panic_tripwire_install ();
}
 
 
#endif /* __GNUC__ || __clang__ */
 
#endif /* ! MHD_PANIC_TRIPWIRE_H */