add c subscribe interface, fix thread issue between python and c

dannynash · dannynash · commit de7466a0b795 · 2018-07-18T22:35:33.000+08:00
diff --git a/README.md b/README.md
@@ -1,3 +1,40 @@
+# Pre Installation
+
+## foohid
+https://github.com/unbit/foohid.git
+
+1. 到 recovery mode disable kext
+    a. 重開機， cmd + R 進 Recovery mode
+    b. 打開 terminal: util -> terminal
+    c. $ csrutil disable
+    d. $ csrutil enable --without kext 
+
+2. 下載專案，編完 foohid.text 放到 /Library/Extensions
+
+3. $ sudo kextload /Library/Extensions/foohid.kext
+
+## other
+
+$ pip3 install pyobjc
+
+# Installation
+
+```bash
+$ python3 setup.py install
+```
+
+# Update
+
+1. 在 foohid.c 實作 subscribe
+2. python 層設定 callback 到 C
+3. 不要在 C 層呼叫 CFRunLoopRun, 這樣會卡住 python thread
+4. 透過 pyobjc，在 python 呼叫底層 CFRunLoop 
+
+
+# Test
+
+$ python3 test_mouse.py
+
 # foohid-py
 Python wrapper for the foohid OSX driver. Compatible with Python 2 and 3.
 
@@ -38,4 +75,6 @@ $ sudo kextunload /Library/Extensions/foohid.kext
 $ sudo rm -rf /System/Library/Extensions/foohid.kext
 ```
 
-Then reinstall the kernel extension: https://github.com/unbit/foohid/releases/latest (no restart required)
+Then reinstall the kernel extension: https://github.com/unbit/foohid/releases/latest (no restart required)
+
+
diff --git a/foohid.c b/foohid.c
@@ -1,14 +1,31 @@
 #include <Python.h>
 #include <IOKit/IOKitLib.h>
+#include <CoreFoundation/CFRunLoop.h>
+
+#include "foohid_types.h"
+
+#include <Python.h>
 
 #define FOOHID_SERVICE "it_unbit_foohid"
 
 #define FOOHID_CREATE 0
 #define FOOHID_DESTROY 1
 #define FOOHID_SEND 2
 #define FOOHID_LIST 3
+#define FOOHID_NOTIFY 4
+
+CFRunLoopRef run_loop = NULL;
+IONotificationPortRef notification_port = NULL;
+
+static PyObject* pyfunc_event_handler = NULL;
 
 static int foohid_connect(io_connect_t *conn) {
+    if (!PyEval_ThreadsInitialized()) {
+        printf("will PyEval_InitThreads\n");
+        PyEval_InitThreads();
+    }
+        printf("did PyEval_InitThreads\n");
+
     io_iterator_t iterator;
     io_service_t service;
     kern_return_t ret = IOServiceGetMatchingServices(kIOMasterPortDefault, IOServiceMatching(FOOHID_SERVICE), &iterator);
@@ -113,6 +130,127 @@ static PyObject *foohid_send(PyObject *self, PyObject *args) {
     return Py_True;
 }
 
+void callback(void *refcon, IOReturn result, io_user_reference_t* args, uint32_t numArgs) {
+    foohid_report *report;
+
+    printf("callback called.\n");
+    if (sizeof(io_user_reference_t) * numArgs != sizeof(foohid_report)) {
+        printf("unexpected number of arguments.\n");
+        return;
+    }
+
+    report = (foohid_report *)args;
+    printf("received report (%llu bytes).\n", report->size);
+
+    PyGILState_STATE state = PyGILState_Ensure();
+
+    if (pyfunc_event_handler == NULL){
+        printf("pyfunc_event_handler == null!!!\n");
+        fflush(stdout);    
+    } 
+
+    PyObject* arglist = Py_BuildValue("(y#)", report->data, report->size);
+    // 一定要 tuple... 不然 PyObject_CallFunctionObjArgs 會錯
+
+    if (arglist == NULL){
+        printf("arglist NULL\n"); 
+        fflush(stdout);
+    }
+
+   PyObject *pyobjresult = PyObject_CallObject(pyfunc_event_handler, arglist);
+
+    if (pyobjresult == NULL){
+        printf("pyobjresult NULL\n"); 
+        fflush(stdout);
+    }
+    Py_DECREF(arglist);
+    fflush(stdout);
+    PyGILState_Release(state);
+}
+
+
+static PyObject *foohid_subscribe(PyObject *self, PyObject *args) {
+    // set handler
+    // PyObject *result = NULL;
+    PyObject *temp;
+
+    char *name;
+    Py_ssize_t name_len;
+
+    if (!PyArg_ParseTuple(args, "s#O:set_callback", &name, &name_len, &temp)) {
+        return NULL;
+    }
+    // set handler
+    if (!PyCallable_Check(temp)) {
+        PyErr_SetString(PyExc_TypeError, "parameter must be a function");
+        return NULL;
+    }
+    Py_XINCREF(temp);                    /* Add a reference to new func */
+    Py_XDECREF(pyfunc_event_handler);    /* Dispose of previous callback */
+    pyfunc_event_handler = temp;         /* Remember new callback */
+
+    if (name_len == 0) {
+        return PyErr_Format(PyExc_ValueError, "invalid values");
+    }
+
+    io_connect_t conn;
+    if (foohid_connect(&conn)) {        
+        return PyErr_Format(PyExc_SystemError, "unable to open " FOOHID_SERVICE " service");
+    }
+
+    // from u2f.c
+    mach_port_t mnotification_port;
+    CFRunLoopSourceRef run_loop_source;
+    io_async_ref64_t async_ref;
+    kern_return_t ret;
+
+    // Create port to listen for kernel notifications on.
+    notification_port = IONotificationPortCreate(kIOMasterPortDefault);
+    if (!notification_port) {
+        printf("Error getting notification port.\n");
+        return PyErr_Format(PyExc_ValueError, "invalid notification_port");
+    }
+
+    // Get lower level mach port from notification port.
+    mnotification_port = IONotificationPortGetMachPort(notification_port);
+    if (!mnotification_port) {
+        printf("Error getting mach notification port.\n");
+        return PyErr_Format(PyExc_ValueError, "invalid mnotification_port");
+    }
+
+    // Create a run loop source from our notification port so we can add the port to our run loop.
+    run_loop_source = IONotificationPortGetRunLoopSource(notification_port);
+    if (run_loop_source == NULL) {
+        printf("Error getting run loop source.\n");
+        return PyErr_Format(PyExc_ValueError, "invalid run_loop_source");
+    }
+
+    // Add the notification port and timer to the run loop.
+    CFRunLoopAddSource(CFRunLoopGetCurrent(), run_loop_source, kCFRunLoopDefaultMode);
+
+    // Params to pass to the kernel.
+    async_ref[kIOAsyncCalloutFuncIndex] = (uint64_t)callback;
+    async_ref[kIOAsyncCalloutRefconIndex] = 0;
+
+    uint32_t input_count = 2;
+    uint64_t input[input_count];
+    input[0] = (uint64_t) name;
+    input[1] = (uint64_t) name_len;
+
+    ret = IOConnectCallAsyncScalarMethod(conn, FOOHID_NOTIFY, mnotification_port, async_ref, kIOAsyncCalloutCount, input, input_count, NULL, 0);
+
+    foohid_close(conn);
+
+    if (ret != KERN_SUCCESS) {
+        return PyErr_Format(PyExc_SystemError, "unable to subscribe hid message");
+    }
+
+    run_loop = CFRunLoopGetCurrent();
+
+    Py_INCREF(Py_True);
+    return Py_True;
+}
+
 static PyObject *foohid_destroy(PyObject *self, PyObject *args) {
     char *name;
     Py_ssize_t name_len;
@@ -209,6 +347,8 @@ static PyMethodDef foohidMethods[] = {
     {"destroy", foohid_destroy, METH_VARARGS, "destroy a foohid device"},
     {"send", foohid_send, METH_VARARGS, "send a hid message to a foohid device"},
     {"list", foohid_list, METH_VARARGS, "list the currently available foohid devices"},
+    {"subscribe", foohid_subscribe, METH_VARARGS, "subscribe foohid devices"},
+
     {NULL, NULL, 0, NULL}
 };
 
diff --git a/foohid_types.h b/foohid_types.h
@@ -0,0 +1,19 @@
+//
+//  foohid_types.h
+//  foohid
+//
+//  Created by Benjamin P Toews on 2/3/17.
+//  Copyright © 2017 unbit. All rights reserved.
+//
+
+#ifndef foohid_types_h
+#define foohid_types_h
+
+const uint8_t foohid_max_report = 64;
+
+typedef struct foohid_report {
+    uint64_t size;
+    uint8_t data[foohid_max_report];
+} foohid_report;
+
+#endif
diff --git a/mouse.c b/mouse.c
@@ -0,0 +1,128 @@
+/**
+ * Create a virtual mouse.
+ * Compile me with: gcc mouse.c -o virtual_mouse -framework IOKit
+ */
+
+#include <IOKit/IOKitLib.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+unsigned char report_descriptor[] = {
+    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
+    0x09, 0x02,                    // USAGE (Mouse)
+    0xa1, 0x01,                    // COLLECTION (Application)
+    0x09, 0x01,                    //   USAGE (Pointer)
+    0xa1, 0x00,                    //   COLLECTION (Physical)
+    0x05, 0x09,                    //     USAGE_PAGE (Button)
+    0x19, 0x01,                    //     USAGE_MINIMUM (Button 1)
+    0x29, 0x03,                    //     USAGE_MAXIMUM (Button 3)
+    0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
+    0x25, 0x01,                    //     LOGICAL_MAXIMUM (1)
+    0x95, 0x03,                    //     REPORT_COUNT (3)
+    0x75, 0x01,                    //     REPORT_SIZE (1)
+    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
+    0x95, 0x01,                    //     REPORT_COUNT (1)
+    0x75, 0x05,                    //     REPORT_SIZE (5)
+    0x81, 0x03,                    //     INPUT (Cnst,Var,Abs)
+    0x05, 0x01,                    //     USAGE_PAGE (Generic Desktop)
+    0x09, 0x30,                    //     USAGE (X)
+    0x09, 0x31,                    //     USAGE (Y)
+    0x15, 0x81,                    //     LOGICAL_MINIMUM (-127)
+    0x25, 0x7f,                    //     LOGICAL_MAXIMUM (127)
+    0x75, 0x08,                    //     REPORT_SIZE (8)
+    0x95, 0x02,                    //     REPORT_COUNT (2)
+    0x81, 0x06,                    //     INPUT (Data,Var,Rel)
+    0xc0,                          //   END_COLLECTION
+    0xc0                           // END_COLLECTION
+};
+
+struct mouse_report_t {
+    uint8_t buttons;
+    int8_t x;
+    int8_t y;
+};
+
+#define SERVICE_NAME "it_unbit_foohid"
+
+#define FOOHID_CREATE 0  // create selector
+#define FOOHID_SEND 2  // send selector
+
+#define DEVICE_NAME "Foohid Virtual Mouse"
+#define DEVICE_SN "SN 123456"
+
+int main() {
+    io_iterator_t iterator;
+    io_service_t service;
+    io_connect_t connect;
+
+    // Get a reference to the IOService
+    kern_return_t ret = IOServiceGetMatchingServices(kIOMasterPortDefault, IOServiceMatching(SERVICE_NAME), &iterator);
+
+    if (ret != KERN_SUCCESS) {
+        printf("Unable to access IOService.\n");
+        exit(1);
+    }
+
+    // Iterate till success
+    int found = 0;
+    while ((service = IOIteratorNext(iterator)) != IO_OBJECT_NULL) {
+                printf("IOIteratorNext");
+
+        ret = IOServiceOpen(service, mach_task_self(), 0, &connect);
+        printf("%d", ret);
+
+        if (ret == KERN_SUCCESS) {
+            found = 1;
+            break;
+        }
+
+        IOObjectRelease(service);
+    }
+    IOObjectRelease(iterator);
+
+    if (!found) {
+        printf("Unable to open IOService.\n");
+        exit(1);
+    }
+
+    // Fill up the input arguments.
+    uint32_t input_count = 8;
+    uint64_t input[input_count];
+    input[0] = (uint64_t) strdup(DEVICE_NAME);  // device name
+    input[1] = strlen((char *)input[0]);  // name length
+    input[2] = (uint64_t) report_descriptor;  // report descriptor
+    input[3] = sizeof(report_descriptor);  // report descriptor len
+    input[4] = (uint64_t) strdup(DEVICE_SN);  // serial number
+    input[5] = strlen((char *)input[4]);  // serial number len
+    input[6] = (uint64_t) 2;  // vendor ID
+    input[7] = (uint64_t) 3;  // device ID
+
+    ret = IOConnectCallScalarMethod(connect, FOOHID_CREATE, input, input_count, NULL, 0);
+    if (ret != KERN_SUCCESS) {
+        printf("Unable to create HID device.\n");
+        exit(1);
+    }
+
+    // Arguments to be passed through the HID message.
+    struct mouse_report_t mouse;
+    uint32_t send_count = 4;
+    uint64_t send[send_count];
+    send[0] = (uint64_t)input[0];  // device name
+    send[1] = strlen((char *)input[0]);  // name length
+    send[2] = (uint64_t) &mouse;  // mouse struct
+    send[3] = sizeof(struct mouse_report_t);  // mouse struct len
+
+    for(;;) {
+        mouse.buttons = 0;
+        mouse.x = rand();
+        mouse.y = rand();
+
+        ret = IOConnectCallScalarMethod(connect, FOOHID_SEND, send, send_count, NULL, 0);
+        if (ret != KERN_SUCCESS) {
+            printf("Unable to send message to HID device.\n");
+        }
+
+        sleep(1);  // sleep for a second
+    }
+}
diff --git a/stoppableThread.py b/stoppableThread.py
@@ -0,0 +1,22 @@
+import threading
+
+
+class StoppableThread(threading.Thread):
+    worker = None
+    def __init__(self, w):        
+        threading.Thread.__init__(self)
+        self.worker = w
+
+    def run(self):
+        self.alive = True
+        def c():
+            return self.shouldStop()
+        self.worker(c)
+
+    def shouldStop(self):
+        return not self.alive
+
+    def stop(self):
+        self.alive = False
+        self.join()
+
diff --git a/test_u2f.py b/test_u2f.py
