kinda works, but blocks the main thread

Author: x1unix

.gitignore

@@ -0,0 +1,3 @@
+*.exe
+.vscode/
+.idea/

funcs.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func must(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func try(err error) {
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "ERR: %s\n", err)
+	}
+}

go.mod

@@ -0,0 +1,3 @@
+module regwatch
+
+go 1.12

main.go

@@ -0,0 +1,99 @@
+package main
+
+/*
+#cgo CFLAGS: -I.
+#include "watch.h"
+*/
+import "C"
+
+import (
+	"fmt"
+	"sync"
+	"syscall"
+	"os"
+	"os/signal"
+	"context"
+	"runtime"
+	"time"
+)
+
+const keyPath = `SOFTWARE\SAAZOD\ManagedPosix`
+
+type listener func(regPath string, event uint32) bool
+
+var listeners = map[string]listener{}
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	ctx, _ := cancelHandler()
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+	go func(wg *sync.WaitGroup) {
+		time.Sleep(time.Millisecond)
+		fmt.Printf("INFO:\tLooking for changes in '%s'...\n", keyPath)
+		defer wg.Done();
+		select {
+		case <-ctx.Done():
+			fmt.Printf("INFO:\tGot shutdown signal...\n")
+		default:
+		}
+		err := RegListen(C.HKEY_LOCAL_MACHINE, keyPath, func(kp string, event uint32) bool {
+			fmt.Printf("INFO:\t'%s' changed (%d)\n", kp, event)
+			select {
+			case <-ctx.Done():
+				fmt.Printf("DEBUG:\t context is dead\n")
+				return false
+			default:
+				return true
+			}
+		})
+		if err != nil {
+			fmt.Printf("ERR:\t%s", err)
+		}
+	}(wg)
+
+	fmt.Println("Waiting...")
+	wg.Wait()
+	fmt.Println("Goodbye")
+}
+
+func RegListen(hKey C.HKEY, regPath string, cb listener) error {
+	cstr := C.CString(regPath)
+	listeners[regPath] = cb
+	result := C.reg_listen(hKey, cstr)
+	if result == C.ERROR_SUCCESS {
+		return nil
+	}
+
+	return syscall.Errno(result)
+}
+
+//export reg_global_listener
+func reg_global_listener(cstr *C.char, dwEvent uint32) bool {
+	keyPath := C.GoString(cstr)
+	handler, ok := listeners[keyPath]
+	if !ok {
+		fmt.Printf("ERROR:\tno listener for '%s'\n", keyPath)
+		return false;
+	}
+
+	result := handler(keyPath, dwEvent)
+	return result
+}
+
+
+// cancelHandler returns cancellation context and function for graceful shutdown
+func cancelHandler() (context.Context, context.CancelFunc) {
+	ctx, cancelFn := context.WithCancel(context.Background())
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, os.Interrupt)
+
+	go func() {
+		<-signals
+		cancelFn()
+		signal.Stop(signals)
+	}()
+
+	return ctx, cancelFn
+}

watch.c

@@ -0,0 +1,64 @@
+#ifdef _WIN32
+#include "watch.h"
+#include <windows.h>
+#include <tchar.h>
+#include <stdio.h>
+
+boolean reg_global_listener(char* regPath, long lEvent);
+
+const DWORD dwFilter = REG_NOTIFY_CHANGE_NAME |
+                       REG_NOTIFY_CHANGE_ATTRIBUTES |
+                       REG_NOTIFY_CHANGE_LAST_SET |
+                       REG_NOTIFY_CHANGE_SECURITY;
+
+typedef struct Watcher {
+	HKEY hKey;
+	HANDLE hEvent;
+} Watcher;
+
+long reg_add_listener(callback cb, HKEY hMainKey, char* regPath) {
+	HKEY hKey;
+
+	DEBUG_PRINT("RegOpenKeyEx '%s'\n", regPath);
+	LONG lErrorCode = RegOpenKeyEx(hMainKey, regPath, 0, KEY_NOTIFY, &hKey);
+	if (lErrorCode != ERROR_SUCCESS) 
+		return lErrorCode;
+
+	DEBUG_PRINT("CreateEvent\n");
+	HANDLE hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	if (hEvent == NULL) 
+		return GetLastError();
+
+	while(TRUE) {
+		DEBUG_PRINT("RegNotifyChangeKeyValue\n");
+		lErrorCode = RegNotifyChangeKeyValue(hKey, TRUE, dwFilter, hEvent, TRUE);
+		if(lErrorCode != ERROR_SUCCESS) break;
+
+		DEBUG_PRINT("WaitForSingleObject\n");
+		DWORD dwEvent = WaitForSingleObject(hEvent, INFINITE);
+		ResetEvent(hEvent);
+		if (dwEvent == WAIT_OBJECT_0) {
+			boolean result = cb(regPath, dwEvent);
+			DEBUG_PRINT("Callback returned %d\n", result);
+			if (!result) {
+				DEBUG_PRINT("break\n");
+				break;
+			}
+			continue;
+		}
+
+		lErrorCode = dwEvent;
+		break;
+	}
+	
+	DEBUG_PRINT("Close watcher\n");
+	RegCloseKey(hKey);
+	CloseHandle(hEvent);
+	free(regPath);	// Allocated in heap by C.GoString()
+	return lErrorCode;
+}
+
+long reg_listen(HKEY hMainKey, char* regPath) {
+  return reg_add_listener(reg_global_listener, hMainKey, regPath);
+}
+#endif

watch.h

@@ -0,0 +1,22 @@
+#ifndef WATCH_H
+#define WATCH_H
+
+#define DEBUG 3
+#include <windows.h>
+#include <stdlib.h>
+
+#if defined(DEBUG) && DEBUG > 0
+ #define DEBUG_PRINT(fmt, ...) fprintf(stderr, "DEBUG: %s:%d:%s(): " fmt, \
+    __FILE__, __LINE__, __func__, ##__VA_ARGS__);
+
+#else
+ #define DEBUG_PRINT(fmt, ...) /* Don't do anything in release builds */
+#endif
+
+
+typedef boolean (*callback)(char*, long);
+
+long reg_add_listener(callback cb, HKEY hMainKey, char* regPath);
+long reg_listen(HKEY hMainKey, char* regPath);
+
+#endif