move shared code to pkg.

pkg/xorg/keysymdef.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+wget https://cgit.freedesktop.org/xorg/proto/x11proto/plain/keysymdef.h
+sed -i -E 's/\#define (XK_[a-zA-Z_0-9]+\s+)(0x[0-9a-f]+)/const \1 = \2/g' keysymdef.h
+sed -i -E 's/^\#/\/\//g' keysymdef.h
+echo "package xorg" | cat - keysymdef.h > keysymdef.go && rm keysymdef.h

pkg/xorg/xorg.c

@@ -0,0 +1,266 @@
+#include "xorg.h"
+
+static Display *DISPLAY = NULL;
+
+Display *getXDisplay(void) {
+  return DISPLAY;
+}
+
+int XDisplayOpen(char *name) {
+  DISPLAY = XOpenDisplay(name);
+  return DISPLAY == NULL;
+}
+
+void XDisplayClose(void) {
+  XCloseDisplay(DISPLAY);
+}
+
+void XMove(int x, int y) {
+  Display *display = getXDisplay();
+  XWarpPointer(display, None, DefaultRootWindow(display), 0, 0, 0, 0, x, y);
+  XSync(display, 0);
+}
+
+void XCursorPosition(int *x, int *y) {
+  Display *display = getXDisplay();
+  Window root = DefaultRootWindow(display);
+  Window window;
+  int i;
+  unsigned mask;
+  XQueryPointer(display, root, &root, &window, x, y, &i, &i, &mask);
+}
+
+void XScroll(int x, int y) {
+  int ydir = 4; /* Button 4 is up, 5 is down. */
+  int xdir = 6;
+
+  Display *display = getXDisplay();
+
+  if (y < 0) {
+    ydir = 5;
+  }
+
+  if (x < 0) {
+    xdir = 7;
+  }
+
+  int xi;
+  int yi;
+
+  for (xi = 0; xi < abs(x); xi++) {
+    XTestFakeButtonEvent(display, xdir, 1, CurrentTime);
+    XTestFakeButtonEvent(display, xdir, 0, CurrentTime);
+  }
+
+  for (yi = 0; yi < abs(y); yi++) {
+    XTestFakeButtonEvent(display, ydir, 1, CurrentTime);
+    XTestFakeButtonEvent(display, ydir, 0, CurrentTime);
+  }
+
+  XSync(display, 0);
+}
+
+void XButton(unsigned int button, int down) {
+  if (button == 0)
+    return;
+
+  Display *display = getXDisplay();
+  XTestFakeButtonEvent(display, button, down, CurrentTime);
+  XSync(display, 0);
+}
+
+static xkeyentry_t *xKeysHead = NULL;
+
+void XKeyEntryAdd(KeySym keysym, KeyCode keycode) {
+  xkeyentry_t *entry = (xkeyentry_t *) malloc(sizeof(xkeyentry_t));
+  if (entry == NULL)
+    return;
+
+  entry->keysym = keysym;
+  entry->keycode = keycode;
+  entry->next = xKeysHead;
+  xKeysHead = entry;
+}
+
+KeyCode XKeyEntryGet(KeySym keysym) {
+  xkeyentry_t *prev = NULL;
+  xkeyentry_t *curr = xKeysHead;
+
+  KeyCode keycode = 0;
+  while (curr != NULL) {
+    if (curr->keysym == keysym) {
+      keycode = curr->keycode;
+
+      if (prev == NULL) {
+        xKeysHead = curr->next;
+      } else {
+        prev->next = curr->next;
+      }
+
+      free(curr);
+      return keycode;
+    }
+
+    prev = curr;
+    curr = curr->next;
+  }
+
+  return 0;
+}
+
+// From https://github.com/TigerVNC/tigervnc/blob/0946e298075f8f7b6d63e552297a787c5f84d27c/unix/x0vncserver/XDesktop.cxx#L343-L379
+KeyCode XkbKeysymToKeycode(Display* dpy, KeySym keysym) {
+  XkbDescPtr xkb;
+  XkbStateRec state;
+  unsigned int mods;
+  unsigned keycode;
+
+  xkb = XkbGetMap(dpy, XkbAllComponentsMask, XkbUseCoreKbd);
+  if (!xkb)
+    return 0;
+
+  XkbGetState(dpy, XkbUseCoreKbd, &state);
+  // XkbStateFieldFromRec() doesn't work properly because
+  // state.lookup_mods isn't properly updated, so we do this manually
+  mods = XkbBuildCoreState(XkbStateMods(&state), state.group);
+
+  for (keycode = xkb->min_key_code;
+       keycode <= xkb->max_key_code;
+       keycode++) {
+    KeySym cursym;
+    unsigned int out_mods;
+    XkbTranslateKeyCode(xkb, keycode, mods, &out_mods, &cursym);
+    if (cursym == keysym)
+      break;
+  }
+
+  if (keycode > xkb->max_key_code)
+    keycode = 0;
+
+  XkbFreeKeyboard(xkb, XkbAllComponentsMask, True);
+
+  // Shift+Tab is usually ISO_Left_Tab, but RFB hides this fact. Do
+  // another attempt if we failed the initial lookup
+  if ((keycode == 0) && (keysym == XK_Tab) && (mods & ShiftMask))
+    return XkbKeysymToKeycode(dpy, XK_ISO_Left_Tab);
+
+  return keycode;
+}
+
+void XKey(KeySym keysym, int down) {
+  if (keysym == 0)
+    return;
+
+  Display *display = getXDisplay();
+  KeyCode keycode = 0;
+
+  if (!down)
+    keycode = XKeyEntryGet(keysym);
+
+  if (keycode == 0)
+    keycode = XkbKeysymToKeycode(display, keysym);
+
+  // Map non-existing keysyms to new keycodes
+  if (keycode == 0) {
+    int min, max, numcodes;
+    XDisplayKeycodes(display, &min, &max);
+    XGetKeyboardMapping(display, min, max-min, &numcodes);
+
+    keycode = (max-min+1)*numcodes;
+    KeySym keysym_list[numcodes];
+    for(int i=0;i<numcodes;i++) keysym_list[i] = keysym;
+    XChangeKeyboardMapping(display, keycode, numcodes, keysym_list, 1);
+  }
+
+  if (down)
+    XKeyEntryAdd(keysym, keycode);
+
+  XTestFakeKeyEvent(display, keycode, down, CurrentTime);
+  XSync(display, 0);
+}
+
+void XGetScreenConfigurations() {
+  Display *display = getXDisplay();
+  Window root = RootWindow(display, 0);
+  XRRScreenSize *xrrs;
+  int num_sizes;
+
+  xrrs = XRRSizes(display, 0, &num_sizes);
+  for (int i = 0; i < num_sizes; i++) {
+    short *rates;
+    int num_rates;
+
+    goCreateScreenSize(i, xrrs[i].width, xrrs[i].height, xrrs[i].mwidth, xrrs[i].mheight);
+    rates = XRRRates(display, 0, i, &num_rates);
+    for (int j = 0; j < num_rates; j++) {
+      goSetScreenRates(i, j, rates[j]);
+    }
+  }
+}
+
+void XSetScreenConfiguration(int index, short rate) {
+  Display *display = getXDisplay();
+  Window root = RootWindow(display, 0);
+  XRRSetScreenConfigAndRate(display, XRRGetScreenInfo(display, root), root, index, RR_Rotate_0, rate, CurrentTime);
+}
+
+int XGetScreenSize() {
+  Display *display = getXDisplay();
+  XRRScreenConfiguration *conf = XRRGetScreenInfo(display, RootWindow(display, 0));
+  Rotation original_rotation;
+  return XRRConfigCurrentConfiguration(conf, &original_rotation);
+}
+
+short XGetScreenRate() {
+  Display *display = getXDisplay();
+  XRRScreenConfiguration *conf = XRRGetScreenInfo(display, RootWindow(display, 0));
+  return XRRConfigCurrentRate(conf);
+}
+
+void XSetKeyboardModifier(int mod, int on) {
+  Display *display = getXDisplay();
+  XkbLockModifiers(display, XkbUseCoreKbd, mod, on ? mod : 0);
+  XFlush(display);
+}
+
+char XGetKeyboardModifiers() {
+  XkbStateRec xkbState;
+  Display *display = getXDisplay();
+  XkbGetState(display, XkbUseCoreKbd, &xkbState);
+  return xkbState.locked_mods;
+}
+
+XFixesCursorImage *XGetCursorImage(void) {
+  Display *display = getXDisplay();
+  return XFixesGetCursorImage(display);
+}
+
+char *XGetScreenshot(int *w, int *h) {
+  Display *display = getXDisplay();
+  Window root = DefaultRootWindow(display);
+
+  XWindowAttributes attr;
+  XGetWindowAttributes(display, root, &attr);
+  int width = attr.width;
+  int height = attr.height;
+
+  XImage *ximage = XGetImage(display, root, 0, 0, width, height, AllPlanes, ZPixmap);
+
+  *w = width;
+  *h = height;
+  char *pixels = (char *)malloc(width * height * 3);
+
+	for (int row = 0; row < height; row++) {
+		for (int col = 0; col < width; col++) {
+			int pos = ((row * width) + col) * 3;
+      unsigned long pixel = XGetPixel(ximage, col, row);
+
+			pixels[pos]   = (pixel & ximage->red_mask)   >> 16;
+			pixels[pos+1] = (pixel & ximage->green_mask) >> 8;
+			pixels[pos+2] =  pixel & ximage->blue_mask;
+    }
+  }
+
+  XDestroyImage(ximage);
+  return pixels;
+}

pkg/xorg/xorg.go

@@ -0,0 +1,320 @@
+package xorg
+
+/*
+#cgo LDFLAGS: -lX11 -lXrandr -lXtst -lXfixes
+
+#include "xorg.h"
+*/
+import "C"
+
+import (
+	"fmt"
+	"image"
+	"image/color"
+	"sync"
+	"time"
+	"unsafe"
+
+	"gitlab.com/demodesk/neko/server/pkg/types"
+)
+
+//go:generate ./keysymdef.sh
+
+type KbdMod uint8
+
+const (
+	KbdModCapsLock KbdMod = 2
+	KbdModNumLock  KbdMod = 16
+)
+
+var ScreenConfigurations = make(map[int]types.ScreenConfiguration)
+
+var debounce_button = make(map[uint32]time.Time)
+var debounce_key = make(map[uint32]time.Time)
+var mu = sync.Mutex{}
+
+func GetScreenConfigurations() {
+	mu.Lock()
+	defer mu.Unlock()
+
+	C.XGetScreenConfigurations()
+}
+
+func DisplayOpen(display string) bool {
+	mu.Lock()
+	defer mu.Unlock()
+
+	displayUnsafe := C.CString(display)
+	defer C.free(unsafe.Pointer(displayUnsafe))
+
+	ok := C.XDisplayOpen(displayUnsafe)
+	return int(ok) == 1
+}
+
+func DisplayClose() {
+	mu.Lock()
+	defer mu.Unlock()
+
+	C.XDisplayClose()
+}
+
+func Move(x, y int) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	C.XMove(C.int(x), C.int(y))
+}
+
+func GetCursorPosition() (int, int) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	var x C.int
+	var y C.int
+	C.XCursorPosition(&x, &y)
+
+	return int(x), int(y)
+}
+
+func Scroll(x, y int) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	C.XScroll(C.int(x), C.int(y))
+}
+
+func ButtonDown(code uint32) error {
+	mu.Lock()
+	defer mu.Unlock()
+
+	if _, ok := debounce_button[code]; ok {
+		return fmt.Errorf("debounced button %v", code)
+	}
+
+	debounce_button[code] = time.Now()
+
+	C.XButton(C.uint(code), C.int(1))
+	return nil
+}
+
+func KeyDown(code uint32) error {
+	mu.Lock()
+	defer mu.Unlock()
+
+	if _, ok := debounce_key[code]; ok {
+		return fmt.Errorf("debounced key %v", code)
+	}
+
+	debounce_key[code] = time.Now()
+
+	C.XKey(C.KeySym(code), C.int(1))
+	return nil
+}
+
+func ButtonUp(code uint32) error {
+	mu.Lock()
+	defer mu.Unlock()
+
+	if _, ok := debounce_button[code]; !ok {
+		return fmt.Errorf("debounced button %v", code)
+	}
+
+	delete(debounce_button, code)
+
+	C.XButton(C.uint(code), C.int(0))
+	return nil
+}
+
+func KeyUp(code uint32) error {
+	mu.Lock()
+	defer mu.Unlock()
+
+	if _, ok := debounce_key[code]; !ok {
+		return fmt.Errorf("debounced key %v", code)
+	}
+
+	delete(debounce_key, code)
+
+	C.XKey(C.KeySym(code), C.int(0))
+	return nil
+}
+
+func ResetKeys() {
+	mu.Lock()
+	defer mu.Unlock()
+
+	for code := range debounce_button {
+		C.XButton(C.uint(code), C.int(0))
+		delete(debounce_button, code)
+	}
+
+	for code := range debounce_key {
+		C.XKey(C.KeySym(code), C.int(0))
+		delete(debounce_key, code)
+	}
+}
+
+func CheckKeys(duration time.Duration) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	t := time.Now()
+	for code, start := range debounce_button {
+		if t.Sub(start) < duration {
+			continue
+		}
+
+		C.XButton(C.uint(code), C.int(0))
+		delete(debounce_button, code)
+	}
+
+	for code, start := range debounce_key {
+		if t.Sub(start) < duration {
+			continue
+		}
+
+		C.XKey(C.KeySym(code), C.int(0))
+		delete(debounce_key, code)
+	}
+}
+
+func ChangeScreenSize(width int, height int, rate int16) error {
+	mu.Lock()
+	defer mu.Unlock()
+
+	for index, size := range ScreenConfigurations {
+		if size.Width == width && size.Height == height {
+			for _, fps := range size.Rates {
+				if rate == fps {
+					C.XSetScreenConfiguration(C.int(index), C.short(fps))
+					return nil
+				}
+			}
+		}
+	}
+
+	return fmt.Errorf("unknown screen configuration %dx%d@%d", width, height, rate)
+}
+
+func GetScreenSize() *types.ScreenSize {
+	mu.Lock()
+	defer mu.Unlock()
+
+	index := int(C.XGetScreenSize())
+	rate := int16(C.XGetScreenRate())
+
+	if conf, ok := ScreenConfigurations[index]; ok {
+		return &types.ScreenSize{
+			Width:  conf.Width,
+			Height: conf.Height,
+			Rate:   rate,
+		}
+	}
+
+	return nil
+}
+
+func SetKeyboardModifier(mod KbdMod, active bool) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	num := C.int(0)
+	if active {
+		num = C.int(1)
+	}
+
+	C.XSetKeyboardModifier(C.int(mod), num)
+}
+
+func GetKeyboardModifiers() KbdMod {
+	mu.Lock()
+	defer mu.Unlock()
+
+	return KbdMod(C.XGetKeyboardModifiers())
+}
+
+func GetCursorImage() *types.CursorImage {
+	mu.Lock()
+	defer mu.Unlock()
+
+	cur := C.XGetCursorImage()
+	defer C.XFree(unsafe.Pointer(cur))
+
+	width := int(cur.width)
+	height := int(cur.height)
+
+	// Xlib stores 32-bit data in longs, even if longs are 64-bits long.
+	pixels := C.GoBytes(unsafe.Pointer(cur.pixels), C.int(width*height*8))
+
+	img := image.NewRGBA(image.Rect(0, 0, width, height))
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			pos := ((y * width) + x) * 8
+
+			img.SetRGBA(x, y, color.RGBA{
+				A: pixels[pos+3],
+				R: pixels[pos+2],
+				G: pixels[pos+1],
+				B: pixels[pos+0],
+			})
+		}
+	}
+
+	return &types.CursorImage{
+		Width:  uint16(width),
+		Height: uint16(height),
+		Xhot:   uint16(cur.xhot),
+		Yhot:   uint16(cur.yhot),
+		Serial: uint64(cur.cursor_serial),
+		Image:  img,
+	}
+}
+
+func GetScreenshotImage() *image.RGBA {
+	mu.Lock()
+	defer mu.Unlock()
+
+	var w, h C.int
+	pixelsUnsafe := C.XGetScreenshot(&w, &h)
+	pixels := C.GoBytes(unsafe.Pointer(pixelsUnsafe), w*h*3)
+	defer C.free(unsafe.Pointer(pixelsUnsafe))
+
+	width := int(w)
+	height := int(h)
+	img := image.NewRGBA(image.Rect(0, 0, width, height))
+	for row := 0; row < height; row++ {
+		for col := 0; col < width; col++ {
+			pos := ((row * width) + col) * 3
+
+			img.SetRGBA(col, row, color.RGBA{
+				R: uint8(pixels[pos]),
+				G: uint8(pixels[pos+1]),
+				B: uint8(pixels[pos+2]),
+				A: 0xFF,
+			})
+		}
+	}
+
+	return img
+}
+
+//export goCreateScreenSize
+func goCreateScreenSize(index C.int, width C.int, height C.int, mwidth C.int, mheight C.int) {
+	ScreenConfigurations[int(index)] = types.ScreenConfiguration{
+		Width:  int(width),
+		Height: int(height),
+		Rates:  make(map[int]int16),
+	}
+}
+
+//export goSetScreenRates
+func goSetScreenRates(index C.int, rate_index C.int, rateC C.short) {
+	rate := int16(rateC)
+
+	// filter out all irrelevant rates
+	if rate > 60 || (rate > 30 && rate%10 != 0) {
+		return
+	}
+
+	ScreenConfigurations[int(index)].Rates[int(rate_index)] = rate
+}

pkg/xorg/xorg.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/Xrandr.h>
+#include <X11/extensions/XTest.h>
+#include <X11/extensions/Xfixes.h>
+#include <stdlib.h>
+
+extern void goCreateScreenSize(int index, int width, int height, int mwidth, int mheight);
+extern void goSetScreenRates(int index, int rate_index, short rate);
+
+Display *getXDisplay(void);
+int XDisplayOpen(char *input);
+void XDisplayClose(void);
+
+void XMove(int x, int y);
+void XCursorPosition(int *x, int *y);
+void XScroll(int x, int y);
+void XButton(unsigned int button, int down);
+
+typedef struct xkeyentry_t {
+  KeySym keysym;
+  KeyCode keycode;
+  struct xkeyentry_t *next;
+} xkeyentry_t;
+
+static void XKeyEntryAdd(KeySym keysym, KeyCode keycode);
+static KeyCode XKeyEntryGet(KeySym keysym);
+static KeyCode XkbKeysymToKeycode(Display *dpy, KeySym keysym);
+void XKey(KeySym keysym, int down);
+
+void XGetScreenConfigurations();
+void XSetScreenConfiguration(int index, short rate);
+int XGetScreenSize();
+short XGetScreenRate();
+
+void XSetKeyboardModifier(int mod, int on);
+char XGetKeyboardModifiers();
+XFixesCursorImage *XGetCursorImage(void);
+
+char *XGetScreenshot(int *w, int *h);