More Signals

• Signal Sets
  • The way we have been dealing with signals would be tough if we were dealing with more than one or two signals.
  • Signal Sets allow us to work with an entire set of signals.
  • sigset_t is probably just a int (bit mask)
  • int sigemptyset ( sigset_t * set) creates an empty signal set.
  • int sifillset(sigset_t * set) creates a full signal set.
  • These should not be manipulated directly.
  • int sigaddset(const sigset_t * set, int sig); add a signal to a set
  • int sigdelset(const sigset_t * set, int sig); delete a signal from a set.
  • int sigismember(const sigset_t * set, int sig); returns 1 if sig is in the set, 0 otherwise.
  • int sigandset(sigset_t * dest, sigset_T * left, sigset_t * right)
  • int sigorset(sigset_t * dest, sigset_T * left, sigset_t * right)
  • int sigisemptyset(const sigset_t * set)
• Delaying signals with sigprocmask

  •  
           #include <signal.h>
           int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
    	

  • Fetch and change the signal mask.
  • how is one of the following
    • SIG_BLOCK - block signals in the union of the current set and the set parameter.
    • SIG_UNBLOCK - the set parameter signals are removed from the current set of blocked signals.
    • SIG_SETMASK - the current blocked signals is changed to the set parameter.
  • set
    • is used as discussed above.
    • Or if NULL, the current set is retrieved.
  • oldset
    • Is either NULL, no action
    • Or contains the prvious signal mask.
  • You can't block SIGKILL or SIGSTOP
    • Attempts to do so are ignored.
• You can observe what signals are pending with sigpending

  •        #include <signal.h>
           int sigpending(sigset_t *set);
    	  

  • set will contain a bit set for any pending signals.
• Blocked signals are not queued
  • You can only tell that a signal has been raised, not how many times it was raised.
• signal replacement sigaction

  •        #include <signal.h>
           int sigaction(int signum, const struct sigaction *act,
                         struct sigaction *oldact);
    
               struct sigaction {
                   void     (*sa_handler)(int);
                   void     (*sa_sigaction)(int, siginfo_t *, void *);
                   sigset_t   sa_mask;
                   int        sa_flags;
                   void     (*sa_restorer)(void);
               };
    	

  • signum is the signal number.
  • act
    • If NULL, only a query is performed.
    • If not null, then a new action for signum is installed.
  • oldact
    • If not NULL holds the previous (or current) action
  • the sigaction struct
    • A dreaded union
      • Only set one if these.
      • sa_handler
        • SIG_DFL - set to default handler
        • SIG_IGN - ignore the signal
        • function pointer as in signal
      • sa_sigaction
        • Must be marked with SA_SIGINFO set in the sa_flags field.
        • This is a three parameter function
          • int - the signal number
          • siginfo_t * - a structure containing information about the signal.
          • void * a pointer to a context, normally not used by the signal handler
    • sa_mask a set of additional signals to be blocked while the signal handler is executed.
      • The signal which triggered the handler will also be blocked.
    • sa_flags- a set of flags that modify the behavior of the signal handling process
      • SA_NOCLDSTOP - throw away child stopped messages.
      • SA_NODEFER - a signal will be received while another signal of this type is being processed. Normally blocked (see above)
      • SA_RESETHAND - restore the default signal action on entry of this signal handler.
      • There are others.
    • sa_restorer is obsolete, don't use.
• Just for fun you can send your process a signal

  • 	       #include <signal.h>
    	       int raise(int sig)