home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / old / ckermit70 / ckusig.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  7KB  |  353 lines
  1. /* C K U S I G  --  Kermit signal handling for Unix and OS/2 systems */
  2.  
  3. /*
  4.   Author: Jeffrey Altman (jaltman@columbia.edu),
  5.   Columbia University Academic Information Systems, New York City.
  6.  
  7.   Copyright (C) 1985, 2000,
  8.     Trustees of Columbia University in the City of New York.
  9.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  10.     copyright text in the ckcmai.c module for disclaimer and permissions.
  11. */
  12. #include "ckcsym.h"
  13. #include "ckcasc.h"            /* ASCII character symbols */
  14. #include "ckcdeb.h"            /* Debug & other symbols */
  15. #include "ckcker.h"            /* Kermit symbols */
  16. #include "ckcnet.h"            /* Network symbols */
  17. #ifndef NOSPL
  18. #include "ckuusr.h"
  19. #endif /* NOSPL */
  20.  
  21. #include <signal.h>
  22. #ifdef NT
  23. #include <setjmpex.h>
  24. #include <excpt.h>
  25. #else /* NT */
  26. #include <setjmp.h>
  27. #endif /* NT */
  28. #include "ckcsig.h"
  29.  
  30. #ifdef NOCCTRAP
  31. extern ckjmpbuf cmjbuf;
  32. #endif /* NOCCTRAP */
  33.  
  34. #ifdef MAC
  35. #define signal msignal
  36. #define SIGTYP long
  37. #define alarm malarm
  38. #define SIG_IGN 0
  39. #define SIGALRM 1
  40. #define SIGINT  2
  41. SIGTYP (*msignal(int type, SIGTYP (*func)(int)))(int);
  42. #endif /* MAC */
  43.  
  44. #ifdef STRATUS
  45. /* We know these are set here.  MUST unset them before the definitions. */
  46. #define signal vsignal
  47. #define alarm valarm
  48. SIGTYP (*vsignal(int type, SIGTYP (*func)(int)))(int);
  49. int valarm(int interval);
  50. #endif /* STRATUS */
  51.  
  52. #ifdef AMIGA
  53. #define signal asignal
  54. #define alarm aalarm
  55. #define SIGALRM (_NUMSIG+1)
  56. #define SIGTYP void
  57. SIGTYP (*asignal(int type, SIGTYP (*func)(int)))(int);
  58. unsigned aalarm(unsigned);
  59. #endif /* AMIGA */
  60.  
  61. #ifdef NTASM
  62. DWORD
  63. ckgetIP(void)
  64. {
  65.    __asm
  66.    {
  67.       mov eax, dword ptr [esp+0x10]
  68.       jmp ckgetIP + 0x18
  69.    }
  70.    return 1;
  71.  
  72. }
  73. #endif /* NTASM */
  74.  
  75. #ifdef NT
  76. DWORD
  77. exception_filter( void )
  78. {
  79.    GetExceptionInformation ;
  80.    return( EXCEPTION_EXECUTE_HANDLER ) ;
  81. }
  82. void
  83. crash( void )
  84. {
  85.    int x = 0, y = 0 ;
  86.     x / y ;
  87. }
  88. #endif /* NT */
  89.  
  90. #ifndef NOCCTRAP
  91. int
  92. #ifdef CK_ANSIC
  93. cc_execute( ckjptr(sj_buf), ck_sigfunc dofunc, ck_sigfunc failfunc )
  94. #else
  95. cc_execute( sj_buf, dofunc, failfunc)
  96.     ckjptr(sj_buf);
  97.     ck_sigfunc dofunc;
  98.     ck_sigfunc failfunc;
  99. #endif /* CK_ANSIC */
  100. /* cc_execute */ {
  101.     int rc = 0 ;
  102. #ifdef NTASM
  103.    DWORD Eip, Esp ;
  104.     isinterrupted = 0;
  105.     sj_buf->retcode = 0 ;
  106.     sj_buf->Id = GetCurrentThreadId() ;
  107.     memset( &sj_buf->context, 0, sizeof(CONTEXT) );
  108.     sj_buf->context.ContextFlags = CONTEXT_FULL ;
  109. #ifndef COMMENT
  110.     GetThreadContext(GetCurrentThread(), &(sj_buf->context) ) ;
  111.     __asm
  112.     {
  113.           mov       ecx,dword ptr [sj_buf]
  114.           mov       dword ptr [ecx+0xc4],esp
  115.     }
  116.    sj_buf->context.EFlags = 530 ;
  117.    sj_buf->context.Eip = ckgetIP()+0x0C ;
  118. #else /* COMMENT */
  119.    __asm
  120.    {
  121.       mov eax, dword ptr [sj_buf]
  122.       push eax
  123.       mov eax, 0xfffffffe
  124.       push eax
  125.       mov eax, 0x00000039
  126.       mov edx,esp
  127.       int 0x2e
  128.       pop eax
  129.       pop eax
  130.    }
  131. #endif /* COMMENT */
  132. #endif /* NTASM */
  133.     if (
  134. #ifdef NTASM
  135.          isinterrupted
  136. #else
  137.          cksetjmp(ckjdref(sj_buf))
  138. #endif /* NTASM */
  139.          ) {
  140. #ifdef NTASM
  141.           __asm
  142.             {
  143.                 mov esp, ESPToRestore
  144.             }
  145.             isinterrupted = 0 ;
  146. #endif /* NTASM */
  147.             (*failfunc)(NULL) ;
  148. #ifdef NTASM
  149.              rc = sj_buf->retcode ;
  150. #else /* NTASM */
  151.              rc = -1 ;
  152. #endif  /* NTASM */
  153.          } else {
  154. #ifdef NT
  155.             __try {
  156.                (*dofunc)(NULL);
  157.             }
  158.             __except(exception_filter())
  159.             {
  160.                debug(F100,"cc_execute __except","",0);
  161.                debug(F111,
  162.              "exception_filter",
  163.              "_exception_code",
  164.              etExceptionCode()
  165.              );
  166.                longjmp(ckjdref(sj_buf),SIGINT);
  167.             }
  168. #else /* NT */
  169.             (*dofunc)(NULL);
  170. #endif /* NT */
  171.          }
  172.    return rc ;
  173. }
  174. #endif /* NOCCTRAP */
  175.  
  176. int
  177. #ifdef CK_ANSIC                /* ANSIC C declaration... */
  178. alrm_execute(ckjptr(sj_buf),
  179.          int timo,
  180.          ck_sighand handler,
  181.          ck_sigfunc dofunc,
  182.          ck_sigfunc failfunc
  183.          )
  184.  
  185. #else /* Not ANSIC C ... */
  186.  
  187. alrm_execute(sj_buf,
  188.          timo,
  189.          handler,
  190.          dofunc,
  191.          failfunc
  192.          )
  193.     ckjptr(sj_buf);
  194.     int timo;
  195.     ck_sighand handler;
  196.     ck_sigfunc dofunc;
  197.     ck_sigfunc failfunc;
  198. #endif /* CK_ANSIC */
  199.  
  200. /* alrm_execute */ {
  201.  
  202.     int rc = 0;
  203.     int savalrm = 0;
  204. _PROTOTYP(SIGTYP (*savhandler), (int));
  205.  
  206.     savalrm = alarm(timo);
  207.     savhandler = signal(SIGALRM, handler);
  208.  
  209. #ifdef NTASM
  210.     sj_buf->retcode = 0 ;
  211.     sj_buf->Id = GetCurrentThreadId();
  212.     memset(&sj_buf->context, 0, sizeof(CONTEXT));
  213.     sj_buf->context.ContextFlags = CONTEXT_FULL;
  214. #ifndef COMMENT
  215.     GetThreadContext(GetCurrentThread(), &(sj_buf->context));
  216. #else
  217.    __asm
  218.    {
  219.       mov eax, dword ptr [sj_buf]
  220.       push eax
  221.       mov eax, 0xfffffffe
  222.       push eax
  223.       mov eax, 0x00000039
  224.       mov edx,esp
  225.       int 0x2e
  226.       pop eax
  227.       pop eax
  228.    }
  229. #endif
  230.     isinterrupted = 0;
  231. #endif /* NTASM */
  232.     if (
  233. #ifdef NTASM
  234.          sj_buf->retcode
  235. #else
  236.          cksetjmp(ckjdref(sj_buf))
  237. #endif /* NTASM */
  238.         ) {
  239.     (*failfunc)(NULL) ;
  240.     rc = -1 ;
  241.     } else {
  242. #ifdef NT
  243.        __try {
  244.           (*dofunc)(NULL) ;
  245.        }
  246.        __except( exception_filter() )
  247.        {
  248.           debug(F100,"alrm_execute __except","",0);
  249.           debug(F111,"exception_filter",
  250.         "_exception_code",
  251.         GetExceptionCode()
  252.         );
  253.           longjmp(ckjdref(sj_buf),SIGINT);
  254.        }
  255. #else /* NT */
  256.        (*dofunc)(NULL) ;
  257. #endif /* NT */
  258.     }
  259.     alarm(savalrm) ;
  260.     if ( savhandler )
  261.         signal( SIGALRM, savhandler ) ;
  262.     return rc ;
  263. }
  264.  
  265. int
  266. #ifdef CK_ANSIC                /* ANSIC C declaration... */
  267. cc_alrm_execute(ckjptr(sj_buf),
  268.         int timo,
  269.         ck_sighand handler,
  270.         ck_sigfunc dofunc,
  271.         ck_sigfunc failfunc
  272.         )
  273.  
  274. #else /* Not ANSIC C ... */
  275.  
  276. cc_alrm_execute(sj_buf,
  277.          timo,
  278.          handler,
  279.          dofunc,
  280.          failfunc
  281.          )
  282.     ckjptr(sj_buf);
  283.     int timo;
  284.     ck_sighand handler;
  285.     ck_sigfunc dofunc;
  286.     ck_sigfunc failfunc;
  287. #endif /* CK_ANSIC */
  288.  
  289. /* cc_alrm_execute */ {
  290.  
  291.     int rc = 0;
  292.     int savalrm = 0;
  293. _PROTOTYP(SIGTYP (*savhandler), (int));
  294.     savalrm = alarm(timo);
  295.     savhandler = signal( SIGALRM, handler );
  296.  
  297. #ifdef NTASM
  298.     sj_buf->retcode = 0 ;
  299.     sj_buf->Id = GetCurrentThreadId() ;
  300.     memset( &sj_buf->context, 0, sizeof(CONTEXT) );
  301.     sj_buf->context.ContextFlags = CONTEXT_FULL ;
  302. #ifndef COMMENT
  303.     GetThreadContext( GetCurrentThread(), &(sj_buf->context) ) ;
  304. #else
  305.    __asm
  306.    {
  307.       mov eax, dword ptr [sj_buf]
  308.       push eax
  309.       mov eax, 0xfffffffe
  310.       push eax
  311.       mov eax, 0x00000039
  312.       mov edx,esp
  313.       int 0x2e
  314.       pop eax
  315.       pop eax
  316.    }
  317. #endif
  318.     isinterrupted = 0;
  319. #endif /* NTASM */
  320.     if (
  321. #ifdef NTASM
  322.          sj_buf->retcode
  323. #else
  324.          cksetjmp(ckjdref(sj_buf))
  325. #endif /* NTASM */
  326.         ) {
  327.     (*failfunc)(NULL) ;
  328.     rc = -1 ;
  329.     } else {
  330. #ifdef NT
  331.        __try {
  332.           (*dofunc)(NULL) ;
  333.        }
  334.        __except( exception_filter() )
  335.        {
  336.        debug(F100,"cc_alrm_execute __except","",0);
  337.        debug(F111,
  338.          "exception_filter",
  339.          "_exception_code",
  340.          GetExceptionCode()
  341.          );
  342.        longjmp(ckjdref(sj_buf),SIGINT) ;
  343.        }
  344. #else /* NT */
  345.        (*dofunc)(NULL) ;
  346. #endif /* NT */
  347.     }
  348.     alarm(savalrm);
  349.     if (savhandler)
  350.       signal(SIGALRM,savhandler);
  351.     return(rc);
  352. }
  353.