home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / unixSyscall / sigvec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-14  |  4.6 KB  |  165 lines
  1. /* 
  2.  * sigvec.c --
  3.  *
  4.  *    Procedure to map from Unix sigvec system call to Sprite.
  5.  *
  6.  *    Note: None of the special flags in the sigvec structure is supported
  7.  *    as yet. Eventually we could support the signal stack, if we're kludgey,
  8.  *    the interruption, if we use the raw Sprite system calls for the
  9.  *    emulation, and the reset handler (Sun UNIX only) bits if desired.
  10.  *
  11.  *    Note further: many Unix signals are not supported under Sprite.
  12.  *
  13.  * Copyright (C) 1986 Regents of the University of California
  14.  * All rights reserved.
  15.  */
  16.  
  17. #ifndef lint
  18. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/sigvec.c,v 1.4 90/12/13 17:07:42 shirriff Exp $ SPRITE (Berkeley)";
  19. #endif not lint
  20.  
  21. #include "sprite.h"
  22. #include "sig.h"
  23.  
  24. #include "compatInt.h"
  25. #include <signal.h>
  26. #include <errno.h>
  27.  
  28. /*
  29.  * Array of signal handlers for UNIX signals. Need the extra indirection
  30.  * to provide the proper UNIX signal number to the handler, since it may
  31.  * decide what to do based on that number...We'll worry about codes later.
  32.  */
  33. void    (*unixHandlers[NSIG])();
  34.  
  35. /*
  36.  *----------------------------------------------------------------------
  37.  *
  38.  * unixHandleSig --
  39.  *
  40.  *    Procedure to handle the receipt of a Sprite signal. Maps the
  41.  *    Sprite signal to a UNIX signal and calls the right handler.
  42.  *
  43.  * Results:
  44.  *    None.
  45.  *
  46.  * Side effects:
  47.  *    The signal handler for the UNIX signal is called. Note that since
  48.  *    several UNIX signals may map to the same Sprite signal, there
  49.  *    will be problems if different functions are given for the 
  50.  *    overlapping signals.
  51.  *
  52.  *----------------------------------------------------------------------
  53.  */
  54.     /* ARGSUSED */
  55.  
  56. static
  57. unixHandleSig (spriteSig, spriteCode, sigContext, sigAddr)
  58.     int        spriteSig;    /* Sprite signal being delivered */
  59.     int        spriteCode;    /* Sub code of signal */
  60.  
  61.     struct sigcontext *sigContext;    /* Context of signal. */
  62.     char    *sigAddr;    /* Address of fault. */
  63. {
  64.     int        unixSig;    /* "Equivalent" UNIX signal */
  65.     
  66.     if ((Compat_SpriteSignalToUnix (spriteSig, &unixSig) == SUCCESS) &&
  67.     (unixHandlers[unixSig] != (void (*)()) NULL)) {
  68.         /*
  69.          * XXX: Should decode spriteCode and pass sigcontext *
  70.          */
  71.         (* unixHandlers[unixSig]) (unixSig, spriteCode, sigContext,
  72.             sigAddr);
  73.     }
  74.     /*
  75.      * XXX: Should warn about bogus signal handler, yes?
  76.      */
  77. }
  78.  
  79.  
  80. /*
  81.  *----------------------------------------------------------------------
  82.  *
  83.  * sigvec --
  84.  *
  85.  *    Procedure to map from Unix sigvec system call to Sprite Sig_SetAction.
  86.  *
  87.  * Results:
  88.  *    UNIX_ERROR is returned upon error, with the actual error code
  89.  *    stored in errno.  Upon success 0 is returned.
  90.  *
  91.  * Side effects:
  92.  *    The signal handler associated with the specified signal is modified.
  93.  *
  94.  *----------------------------------------------------------------------
  95.  */
  96. int
  97. sigvec(sig, newVectorPtr, oldVectorPtr)
  98.     int         sig;        /* Signal to set the vector for. */
  99.     struct sigvec    *newVectorPtr;    /* New vector. */
  100.     struct sigvec    *oldVectorPtr;    /* Old vector. */
  101. {
  102.     int         spriteSignal;    /* Equivalent signal for Sprite */
  103.     Sig_Action         newAction;    /* Action to take */
  104.     Sig_Action         oldAction;    /* Former action */
  105.     ReturnStatus     status;        /* Generic result code */
  106.     void              (*handler)();    /* New handler for UNIX signal */
  107.  
  108.     status = Compat_UnixSignalToSprite(sig, &spriteSignal);
  109.     if (status == FAILURE || spriteSignal == NULL) {
  110.     errno = EINVAL;
  111.     return(UNIX_ERROR);
  112.     }
  113.     handler = (void (*)()) NULL;
  114.  
  115.     if (newVectorPtr != (struct sigvec *)NULL) {
  116.     switch ((int)newVectorPtr->sv_handler) {
  117.         case SIG_DFL:
  118.         newAction.action = SIG_DEFAULT_ACTION;
  119.         break;
  120.         case SIG_IGN:
  121.         newAction.action = SIG_IGNORE_ACTION;
  122.         break;
  123.         default:
  124.         newAction.action = SIG_HANDLE_ACTION;
  125.         newAction.handler = unixHandleSig;
  126.         handler = newVectorPtr->sv_handler;
  127.     }
  128.     status = Compat_UnixSigMaskToSprite(newVectorPtr->sv_mask,
  129.                         &newAction.sigHoldMask);
  130.     if (status == FAILURE) {
  131.         errno = EINVAL;
  132.         return(UNIX_ERROR);
  133.     }
  134.  
  135.     status = Sig_SetAction(spriteSignal, &newAction, &oldAction);
  136.     if (status != SUCCESS) {
  137.         errno = Compat_MapCode(status);
  138.         return(UNIX_ERROR);
  139.     } 
  140.     }
  141.  
  142.     if (oldVectorPtr != NULL) {
  143.     switch (oldAction.action) {
  144.         case SIG_DEFAULT_ACTION:
  145.         oldVectorPtr->sv_handler = SIG_DFL;
  146.         break;
  147.         case SIG_IGNORE_ACTION:
  148.         oldVectorPtr->sv_handler = SIG_IGN;
  149.         break;
  150.         default:
  151.         oldVectorPtr->sv_handler = unixHandlers[sig];
  152.         break;
  153.     }
  154.     (void) Compat_SpriteSigMaskToUnix(oldAction.sigHoldMask, 
  155.                       &oldVectorPtr->sv_mask);
  156.     oldVectorPtr->sv_flags = 0;
  157.     }
  158.  
  159.     if (newVectorPtr != NULL) {
  160.     unixHandlers[sig] = handler;
  161.     }
  162.  
  163.     return(UNIX_SUCCESS);
  164. }
  165.