signal.c

 
#include <freerdp/config.h>
 
#include <string.h>
 
#include <winpr/crt.h>
#include <winpr/debug.h>
 
#include <freerdp/utils/signal.h>
#include <freerdp/log.h>
 
#include "platform_signal.h"
 
#define TAG FREERDP_TAG("utils.signal")
 
#if defined(_WIN32)
const char* strsignal(int signum);
#endif
 
BOOL fsig_handlers_registered = FALSE;
 
typedef struct
{
  void* context;
  freerdp_signal_handler_t handler;
} cleanup_handler_t;
 
static size_t cleanup_handler_count = 0;
static cleanup_handler_t cleanup_handlers[20] = WINPR_C_ARRAY_INIT;
 
void fsig_term_handler(int signum)
{
  static BOOL recursive = FALSE;
 
  if (!recursive)
  {
    recursive = TRUE;
    // NOLINTNEXTLINE(concurrency-mt-unsafe)
    WLog_ERR(TAG, "Caught signal '%s' [%d]", strsignal(signum), signum);
  }
 
  fsig_lock();
  for (size_t x = 0; x < cleanup_handler_count; x++)
  {
    const cleanup_handler_t empty = WINPR_C_ARRAY_INIT;
    cleanup_handler_t* cur = &cleanup_handlers[x];
    if (cur->handler)
    {
      // NOLINTNEXTLINE(concurrency-mt-unsafe)
      cur->handler(signum, strsignal(signum), cur->context);
    }
    *cur = empty;
  }
  cleanup_handler_count = 0;
  fsig_unlock();
}
 
BOOL freerdp_add_signal_cleanup_handler(void* context, freerdp_signal_handler_t handler)
{
  BOOL rc = FALSE;
  fsig_lock();
  if (fsig_handlers_registered)
  {
    if (cleanup_handler_count < ARRAYSIZE(cleanup_handlers))
    {
      cleanup_handler_t* cur = &cleanup_handlers[cleanup_handler_count++];
      cur->context = context;
      cur->handler = handler;
    }
    else
      WLog_WARN(TAG, "Failed to register cleanup handler, only %" PRIuz " handlers supported",
                ARRAYSIZE(cleanup_handlers));
  }
  rc = TRUE;
  fsig_unlock();
  return rc;
}
 
BOOL freerdp_del_signal_cleanup_handler(void* context, freerdp_signal_handler_t handler)
{
  BOOL rc = FALSE;
  fsig_lock();
  if (fsig_handlers_registered)
  {
    for (size_t x = 0; x < cleanup_handler_count; x++)
    {
      cleanup_handler_t* cur = &cleanup_handlers[x];
      if ((cur->context == context) && (cur->handler == handler))
      {
        const cleanup_handler_t empty = WINPR_C_ARRAY_INIT;
        for (size_t y = x + 1; y < cleanup_handler_count - 1; y++)
        {
          *cur++ = cleanup_handlers[y];
        }
 
        *cur = empty;
        cleanup_handler_count--;
        break;
      }
    }
  }
  rc = TRUE;
  fsig_unlock();
  return rc;
}