Exemplos de _sock_stop_timer em C++ (Cpp)

Exemplo n.º 1

Arquivo: signal.c Projeto: ya-mouse/dos-utils

/*
 * Unhook signal-handlers and raise() signals we caught.
 */
int _sock_sig_restore (void)
{
  int i;

  if (signal_depth == 0 ||
      --signal_depth > 0)
     return (0);

  _sock_stop_timer();

  for (i = 0; i < DIM(sig_tab); i++)
  {
    int sig = sig_tab[i].sig_num;

#if (USE_SIGMASK)
    sigset_t pending, new_set;

    if (sigpending(&pending) == 0 &&
        sigismember(&pending,sig))
    {
      /* The signal became pending while we blocked it.
       * I.e. ^C was pressed, so act on it.
       */
      sigemptyset (&new_set);
      sigaddset (&new_set, sig);

      SOCK_DEBUGF ((", raising %s", sig_tab[i].sig_name));
      SOCK_ENTER_SCOPE();
      sigprocmask (SIG_UNBLOCK, &new_set, NULL);
      SOCK_LEAVE_SCOPE();
    }
#else
    signal (sig, sig_tab[i].old);
    if (!sig_tab[i].caught)
       continue;

    sig_tab[i].caught = FALSE;
    if (sig_tab[i].exit &&
        (sig_tab[i].old == SIG_DFL ||
         sig_tab[i].old == SIG_IGN ||
         sig_tab[i].old == sig_handler_watt))
    {
      char buf[30];

      strcpy (buf, "\nTerminating on ");
      strcat (buf, sig_tab[i].sig_name);
      sock_sig_exit (buf, sig);
      /* no return */
    }
    SOCK_DEBUGF ((", raising %s", sig_tab[i].sig_name));
    SOCK_ENTER_SCOPE();
    raise (sig);
    SOCK_LEAVE_SCOPE();
    return (-1);
#endif
  }
  return (0);
}

Exemplo n.º 2

/*
 * Unhook signal-handlers and optionally chain to previous handlers
 * if we caught signals.
 */
void _sock_sig_restore (void)
{
    if (signal_depth == 0)
        return;

    if (--signal_depth > 0)
        return;

    _sock_stop_timer();
    watcbroke   = 0;
    wathndlcbrk = wat_brkmode;

#if defined(SIGALRM) && TRAP_SIGALRM
    signal (SIGALRM, old_sigalrm);
    unblock_sigalrm();

#if 0
    /* don't do this since a socket function might be called from an
     * alarm handler. This could cause serious recursion and stack fault.
     */
    if (sigalrm_caught && old_sigalrm != SIG_IGN && old_sigalrm != SIG_DFL)
    {
        sigalrm_caught = 0;
        (*old_sigalrm) (SIGALRM);
    }
#endif
#endif

#if defined(SIGBREAK)
    signal (SIGBREAK, old_sigbrk);
    if (sigbrk_caught && old_sigbrk != SIG_IGN && old_sigbrk != SIG_DFL)
    {
        sigbrk_caught = 0;
        (*old_sigbrk) (SIGBREAK);
    }
#endif

#if defined(SIGPIPE)
    signal (SIGPIPE, old_sigpipe);
    if (sigpipe_caught)
    {
        if (old_sigpipe != SIG_IGN && old_sigpipe != SIG_DFL)
        {
            sigpipe_caught = 0;
            (*old_sigpipe) (SIGPIPE);
        }
        else
        {
            outsnl (_LANG("Terminating on SIGPIPE"));
            exit (-1);
        }
    }
#endif

#if defined(SIGQUIT)
    signal (SIGQUIT, old_sigquit);
    if (sigquit_caught)
    {
        if (old_sigquit != SIG_IGN && old_sigquit != SIG_DFL)
        {
            sigquit_caught = 0;
            (*old_sigquit) (SIGQUIT);
        }
        else
        {
            SOCK_DEBUGF ((NULL, "\nExiting stuck program"));
            exit (-1);
        }
    }
#endif

    signal (SIGINT, old_sigint);
    if (sigint_caught && old_sigint != SIG_IGN && old_sigint != SIG_DFL)
    {
        sigint_caught = 0;
        (*old_sigint) (SIGINT);
    }

    sigalrm_caught = sigbrk_caught  = 0;
    sigint_caught  = sigquit_caught = 0;
    sigpipe_caught = 0;
}