Factor out some new libraries

	word64-map:
		Data.Word64Map
	network-addr:
		Network.Address
	tox-crypto:
		Crypto.Tox
	lifted-concurrent:
		Control.Concurrent.Lifted.Instrument
		Control.Concurrent.Async.Lifted.Instrument
	psq-wrap:
		Data.Wrapper.PSQInt
		Data.Wrapper.PSQ
	minmax-psq:
		Data.MinMaxPSQ
        tasks:
                Control.Concurrent.Tasks
	kad:
		Network.Kademlia
		Network.Kademlia.Bootstrap
		Network.Kademlia.Routing
		Network.Kademlia.CommonAPI
		Network.Kademlia.Persistence
		Network.Kademlia.Search

1 files changed, 182 insertions, 0 deletions

diff --git a/dht/Presence/monitortty.c b/dht/Presence/monitortty.c
new file mode 100644
index 00000000..7582aa56
--- /dev/null
+++ b/dht/Presence/monitortty.c
@@ -0,0 +1,182 @@
+// monitortty.c
+
+#include <unistd.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <errno.h>
+#include <linux/vt.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <linux/kd.h>
+#include <stdlib.h>
+
+static char *conspath[] = {
+        "/proc/self/fd/0",
+        "/dev/tty",
+        "/dev/tty0",
+        "/dev/vc/0",
+        "/dev/systty",
+        "/dev/console",
+        NULL
+};
+
+static int
+is_a_console(int fd) {
+        char arg;
+
+        arg = 0;
+        return (isatty (fd)
+                && ioctl(fd, KDGKBTYPE, &arg) == 0
+                && ((arg == KB_101) || (arg == KB_84)));
+}
+
+static int
+open_a_console(const char *fnam) {
+        int fd;
+
+        /*
+         * For ioctl purposes we only need some fd and permissions
+         * do not matter. But setfont:activatemap() does a write.
+         */
+        fd = open(fnam, O_RDWR);
+        if (fd < 0)
+                fd = open(fnam, O_WRONLY);
+        if (fd < 0)
+                fd = open(fnam, O_RDONLY);
+        if (fd < 0)
+                return -1;
+        return fd;
+}
+
+int ttyfd() {
+        // We try several things because opening /dev/console will fail
+        // if someone else used X (which does a chown on /dev/console).
+        int i;
+        int fd;
+        for (i = 0; conspath[i]; i++) {
+                if ((fd = open_a_console(conspath[i])) >= 0) {
+                        if (is_a_console(fd)) {
+                                printf("using %s\n",conspath[i]);
+                                return fd;
+                        }
+                        close(fd);
+                }
+        }
+        for (fd = 0; fd < 3; fd++)
+                if (is_a_console(fd))
+                        return fd;
+        printf("failed to find console fd\n");
+        return -1;
+}
+
+void vt_wait(int tty_fd) {
+        struct vt_event vt;
+        memset(&vt,'\0',sizeof(vt));
+        vt.event = VT_EVENT_SWITCH;
+        int res;
+        // printf("started wait\n");
+        res = ioctl (tty_fd, VT_WAITEVENT, &vt);
+        if (res==-1) {
+                printf("vt_wait error fd=%i\n",tty_fd);
+                perror("vt_wait");
+                // printf("vt_wait: %u - %s\n", errno, errmsg(errno));
+                sleep(1);
+        }
+        // printf("finished wait\n");
+}
+
+int8_t get_active(int tty_fd) {
+        struct vt_stat vtstat;
+        memset(&vtstat,'\0',sizeof(vtstat));
+        if (ioctl(tty_fd, VT_GETSTATE, &vtstat)) {
+                perror ("get_active: VT_GETSTATE");
+                return 7;
+        }
+        return vtstat.v_active;
+}
+
+void chvt(int tty_fd, int n) {
+        if (ioctl(tty_fd, VT_ACTIVATE, n)) {
+                perror ("chvt: VT_ACTIVATE");
+        }
+
+}
+
+pthread_mutex_t mu;
+pthread_t mt;
+int tty = -1;
+
+void *write_vtch(void *pfd) {
+        int fd = (int)(intptr_t)pfd;
+        printf("started VT_WAITEVENT loop fd=%i\n",fd);
+        pthread_mutex_lock(&mu);
+        tty = ttyfd();
+        pthread_mutex_unlock(&mu);
+        int8_t active_tty = get_active(tty);
+        int8_t reported_tty;
+        ssize_t e;
+
+        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+        for (;;) {
+                // ssize_t write(int fd, const void *buf, size_t count);
+                e = write(fd, &active_tty, 1);
+                if (e<0 ) {
+                        if( errno==EAGAIN) continue;
+                        break;
+                }
+                else if(e==1) {
+                        reported_tty = active_tty;
+                }
+                do {
+                        vt_wait(tty);
+                        // printf("vt_wait() finished. tty=%d fd=%d\n",tty,fd);
+                        active_tty = get_active(tty);
+                } while (active_tty==reported_tty);
+        }
+        
+        // TODO:
+        //  use VT_GETSTATE
+        //  use VT_WAITEVENT
+        printf("stopped VT_WAITEVENT loop\n");
+        tty = -1;
+        pthread_mutex_destroy(&mu);
+        return NULL;
+}
+
+
+// Returns 0 on success.
+int monitorTTY(int fd) {
+    int er = -1, dev = -1;
+        pthread_mutex_init(&mu,NULL);
+    // Ensure we can open a device before we bother forking a thread.
+        dev = ttyfd();
+    if( dev != -1 ) {
+        er = pthread_create (&mt, NULL, write_vtch, (void*)(intptr_t)fd);
+        return er;
+    }
+    else {
+        return -1;
+    }
+}
+
+void closeTTY() {
+        int fd = -1;
+        int active = 7;
+        pthread_mutex_lock(&mu);
+        active = get_active(tty);
+        fd = tty;
+        pthread_mutex_unlock(&mu);
+#ifndef VTHACK
+        pthread_cancel(mt);
+#endif
+        char cmd[40]; cmd[39] = '\0';
+        // Hack to wake up from VT_WAITEVENT ioctl
+#ifdef VTHACK
+        snprintf(cmd,39,"chvt %i;chvt %i",active+1,active);
+        system(cmd);
+        pthread_join(mt,NULL);
+#endif
+        close(fd);
+}