1 files changed, 124 insertions, 0 deletions

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;
+}