From 1dc16fc74bb91136d75b656f3a4aaefa87af9f20 Mon Sep 17 00:00:00 2001
From: Christopher Faylor <me@cgf.cx>
Date: Sun, 15 Oct 2000 01:37:07 +0000
Subject: * exceptions.cc (set_console_handler): Don't allocate
 console_handler_thread_waiter.  It is obsolete. (ctrl_c_handler): Don't use
 console_handler_thread_waiter. * path.cc (hash_path_name): Fix handling of
 relative names.  Make case insensitive. * path.h (suffix_info): Use
 initializers. * pinfo.h (_pinfo): Avoid initializers for null case. *
 resource.cc (fill_rusage): Zero rest of rusage structure. * security.cc
 (set_process_privileges): Don't reopen parent process.  Just use hMainProc. *
 signal.cc (signal): Track when a signal handler has been used. (sigaction):
 Ditto. * sigproc.cc (pchildren): Use default initializer. (zombies): Ditto.
 (sigproc_terminate): Avoid closing handles that will be closed on exit
 anyway. (wait_sig): Send signal to "parent" on EXECing, not FORKing.
 (wait_subproc): Send SIGCHLD here rather than in proc_wait to avoid potential
 muto conflicts. * sigproc.h (sigthread): Don't initialize to zero.  It's the
 default. * spawn.cc (spawn_guts): Fill in resources from exec parent prior to
 termination. * sync.h (muto): Don't initialize to zero. * syscalls.cc
 (close_all_files): Use one lock around entire loop and call fhandler
 close/release stuff directly. (_read): Don't use ready_for_read if there are
 not signal handlers active. * dcrt0.cc (dll_crt0_1): Fix display of "title".
 (do_exit): Use pinfo exit method to exit. (__api_fatal): Ditto. *
 exceptions.cc (signal_exit): Ditto. * fork.cc (fork_child): Remove debugging
 stuff.  Use pinfo_fixup_after fork in place of exec_fixup_after_fork. *
 pinfo.cc (pinfo_fixup_after_fork): New method.
 (pinfo_fixup_in_spawned_child): Ditto. (_pinfo::exit): New method.
 (_pinfo::init): Remove recursion.  Detect pathological case where pinfo
 structure already exists for new pid. * pinfo.h (_pinfo): Reorganize
 slightly.  Add new method and new function declarations. * sigproc.cc
 (proc_exists): Previous simplification was a little to simple. Try harder to
 detect if a process exists. (proc_terminate): Use PID_EXITED setting to
 determine if process is still around. (WFSO): Remove debugging statement.
 (WFMO): Ditto. * spawn.cc (exec_fixup_after_fork): Eliminate. (spawn_guts):
 Always set old_title to NULL.  Is it really needed?  Move hexec_proc to
 pinfo.cc.  Call pinfo_fixup_in_spawned_child to eliminate handle link after a
 spawn. * include/sys/cygwin.h: Remove PID_NOT_IN_USE.  Add PID_EXITED.

---
 winsup/cygwin/signal.cc | 36 ++++++++++++++++++++++--------------
 1 file changed, 22 insertions(+), 14 deletions(-)

(limited to 'winsup/cygwin/signal.cc')

diff --git a/winsup/cygwin/signal.cc b/winsup/cygwin/signal.cc
index d1ff1157c..afed39d6b 100644
--- a/winsup/cygwin/signal.cc
+++ b/winsup/cygwin/signal.cc
@@ -19,6 +19,10 @@ details. */
 #include "sigproc.h"
 #include "pinfo.h"
 
+int sigcatchers;	/* FIXME: Not thread safe. */
+
+#define sigtrapped(func) ((func) != SIG_IGN && (func) != SIG_DFL)
+
 extern "C" _sig_func_ptr
 signal (int sig, _sig_func_ptr func)
 {
@@ -35,6 +39,11 @@ signal (int sig, _sig_func_ptr func)
   prev = myself->getsig (sig).sa_handler;
   myself->getsig (sig).sa_handler = func;
   myself->getsig (sig).sa_mask = 0;
+  if (!sigtrapped (prev) && sigtrapped (func))
+    sigcatchers++;
+  else if (sigtrapped (prev) && !sigtrapped (func))
+    sigcatchers--;
+  
   syscall_printf ("%p = signal (%d, %p)", prev, sig, func);
   return prev;
 }
@@ -224,12 +233,8 @@ killpg (int pgrp, int sig)
 }
 
 extern "C" int
-sigaction (int sig,
-		const struct sigaction *newaction,
-		struct sigaction *oldaction)
+sigaction (int sig, const struct sigaction *newact, struct sigaction *oldact)
 {
-  struct sigaction out_oldaction;
-
   /* check that sig is in right range */
   if (sig < 0 || sig >= NSIG)
     {
@@ -238,25 +243,28 @@ sigaction (int sig,
       return -1;
     }
 
-  if (oldaction)
-    out_oldaction = myself->getsig (sig);
+  struct sigaction oa = myself->getsig (sig);
 
-  if (newaction)
+  if (newact)
     {
-      if ((sig == SIGKILL || sig == SIGSTOP) && newaction->sa_handler != SIG_DFL)
+      if ((sig == SIGKILL || sig == SIGSTOP) && newact->sa_handler != SIG_DFL)
 	{
 	  set_errno (EINVAL);
 	  return -1;
 	}
-      myself->getsig (sig) = *newaction;
-      if (newaction->sa_handler == SIG_IGN)
+      myself->getsig (sig) = *newact;
+      if (newact->sa_handler == SIG_IGN)
 	sig_clear (sig);
-      if (newaction->sa_handler == SIG_DFL && sig == SIGCHLD)
+      if (newact->sa_handler == SIG_DFL && sig == SIGCHLD)
 	sig_clear (sig);
+      if (!sigtrapped (oa.sa_handler) && sigtrapped (newact->sa_handler))
+	sigcatchers++;
+      else if (sigtrapped (oa.sa_handler) && !sigtrapped (newact->sa_handler))
+	sigcatchers--;
     }
 
-  if (oldaction)
-    *oldaction = out_oldaction;
+  if (oldact)
+    *oldact = oa;
 
   return 0;
 }
-- 
cgit v1.2.3