win32: add signal routines and SIGALRM support

The implementation for SIGALRM only because Git needs it
(I think for progress display or something). Probably not hurt
having it. Although the only thing needed here are stubs.

2 files changed, 127 insertions, 1 deletions

diff --git a/include/mingw.h b/include/mingw.h
index c5f72837b..0ff7f5442 100644
--- a/include/mingw.h
+++ b/include/mingw.h
@@ -109,9 +109,11 @@ struct sigaction {
 #define sigemptyset(x) (void)0
 #define SA_RESTART 0
 
-NOIMPL(sigaction,int sig UNUSED_PARAM, struct sigaction *in UNUSED_PARAM, struct sigaction *out UNUSED_PARAM);
+int sigaction(int sig, struct sigaction *in, struct sigaction *out);
+sighandler_t mingw_signal(int sig, sighandler_t handler);
 NOIMPL(sigfillset,int *mask UNUSED_PARAM);
 
+#define signal mingw_signal
 /*
  * stdio.h
  */
diff --git a/win32/mingw.c b/win32/mingw.c
index 2b9776175..72e23998c 100644
--- a/win32/mingw.c
+++ b/win32/mingw.c
@@ -90,3 +90,127 @@ struct passwd *getpwuid(int uid)
         p.pw_dir = NULL;
         return &p;
 }
+
+static HANDLE timer_event;
+static HANDLE timer_thread;
+static int timer_interval;
+static int one_shot;
+static sighandler_t timer_fn = SIG_DFL;
+
+/* The timer works like this:
+ * The thread, ticktack(), is a trivial routine that most of the time
+ * only waits to receive the signal to terminate. The main thread tells
+ * the thread to terminate by setting the timer_event to the signalled
+ * state.
+ * But ticktack() interrupts the wait state after the timer's interval
+ * length to call the signal handler.
+ */
+
+static __stdcall unsigned ticktack(void *dummy UNUSED_PARAM)
+{
+        while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
+                if (timer_fn == SIG_DFL)
+                        bb_error_msg_and_die("Alarm");
+                if (timer_fn != SIG_IGN)
+                        timer_fn(SIGALRM);
+                if (one_shot)
+                        break;
+        }
+        return 0;
+}
+
+static int start_timer_thread(void)
+{
+        timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
+        if (timer_event) {
+                timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
+                if (!timer_thread ) {
+                        errno = ENOMEM;
+                        return -1;
+                }
+        } else {
+                errno = ENOMEM;
+                return -1;
+        }
+        return 0;
+}
+
+static void stop_timer_thread(void)
+{
+        if (timer_event)
+                SetEvent(timer_event);  /* tell thread to terminate */
+        if (timer_thread) {
+                int rc = WaitForSingleObject(timer_thread, 1000);
+                if (rc == WAIT_TIMEOUT)
+                        fprintf(stderr, "timer thread did not terminate timely");
+                else if (rc != WAIT_OBJECT_0)
+                        fprintf(stderr, "waiting for timer thread failed: %lu",
+                              GetLastError());
+                CloseHandle(timer_thread);
+        }
+        if (timer_event)
+                CloseHandle(timer_event);
+        timer_event = NULL;
+        timer_thread = NULL;
+}
+
+static inline int is_timeval_eq(const struct timeval *i1, const struct timeval *i2)
+{
+        return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
+}
+
+int setitimer(int type UNUSED_PARAM, struct itimerval *in, struct itimerval *out)
+{
+        static const struct timeval zero;
+        static int atexit_done;
+
+        if (out != NULL) {
+                errno = EINVAL;
+                return -1;
+        }
+        if (!is_timeval_eq(&in->it_interval, &zero) &&
+            !is_timeval_eq(&in->it_interval, &in->it_value)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        if (timer_thread)
+                stop_timer_thread();
+
+        if (is_timeval_eq(&in->it_value, &zero) &&
+            is_timeval_eq(&in->it_interval, &zero))
+                return 0;
+
+        timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
+        one_shot = is_timeval_eq(&in->it_interval, &zero);
+        if (!atexit_done) {
+                atexit(stop_timer_thread);
+                atexit_done = 1;
+        }
+        return start_timer_thread();
+}
+
+int sigaction(int sig, struct sigaction *in, struct sigaction *out)
+{
+        if (sig != SIGALRM) {
+                errno = EINVAL;
+                return -1;
+        }
+        if (out != NULL) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        timer_fn = in->sa_handler;
+        return 0;
+}
+
+#undef signal
+sighandler_t mingw_signal(int sig, sighandler_t handler)
+{
+        sighandler_t old = timer_fn;
+        if (sig != SIGALRM)
+                return signal(sig, handler);
+        timer_fn = handler;
+        return old;
+}