From ffd1a826f41443bac8a7e97a8e69754e6dbff131 Mon Sep 17 00:00:00 2001 From: radiomanV Date: Sat, 20 Sep 2025 19:40:10 +0300 Subject: [PATCH] Introduced Wine64 wrapper --- README.md | 11 +- wine32/readme.md | 2 +- wine64/Makefile | 77 ++ wine64/README.md | 220 +++++ wine64/broker.c | 662 +++++++++++++++ wine64/launcher.c | 190 +++++ wine64/launcher.exe | Bin 0 -> 240798 bytes wine64/protocol.h | 141 ++++ wine64/resource.h | 7 + wine64/resource.rc | 38 + wine64/run.sh | 77 ++ wine64/shim.c | 1973 +++++++++++++++++++++++++++++++++++++++++++ wine64/shim.dll | Bin 0 -> 352107 bytes wine64/shim.ico | Bin 0 -> 38078 bytes wine64/usb-broker | Bin 0 -> 27384 bytes 15 files changed, 3394 insertions(+), 4 deletions(-) create mode 100644 wine64/Makefile create mode 100644 wine64/README.md create mode 100644 wine64/broker.c create mode 100644 wine64/launcher.c create mode 100755 wine64/launcher.exe create mode 100644 wine64/protocol.h create mode 100644 wine64/resource.h create mode 100644 wine64/resource.rc create mode 100755 wine64/run.sh create mode 100644 wine64/shim.c create mode 100755 wine64/shim.dll create mode 100644 wine64/shim.ico create mode 100755 wine64/usb-broker diff --git a/README.md b/README.md index 3e0e452..db0baf4 100644 --- a/README.md +++ b/README.md @@ -69,6 +69,11 @@ This utility can dump the `infoic.dll` and `infoic2plus.dll` to an XML format da More information on this here: [InfoicDump](https://github.com/radiomanV/TL866/tree/master/InfoIcDump#infoicdump) -### WineLib wrapper -This library provide an easy way to make Minipro/Xgpro software work in Linux. -More information on this here: [Wine](https://github.com/radiomanV/TL866/tree/master/wine32#) +### 32-bit WineLib wrapper (Unmaintained) + +This library provides an easy way to run Minipro/Xgpro software on Linux. +More information: [WineLib wrapper](https://github.com/radiomanV/TL866/tree/master/wine32#) + +**Note:** This 32-bit wrapper is no longer maintained. +For the actively maintained wrapper that supports all architectures, see [new wine wrapper](https://github.com/radiomanV/TL866/tree/master/wine64#) + diff --git a/wine32/readme.md b/wine32/readme.md index 747e559..f12bb80 100644 --- a/wine32/readme.md +++ b/wine32/readme.md @@ -2,7 +2,7 @@ > > This wrapper is no longer maintained. It targets 32-bit Wine environments and is provided *as-is* for users > on systems/Wine versions that still support 32-bit. -> For the actively maintained replacement, see the new wrapper [here](https://github.com/radiomanV/TL866/raw/refs/heads/master/wine64) +> For the actively maintained replacement, see the new wrapper [here](https://github.com/radiomanV/TL866/raw/refs/heads/master/wine64#) # Simple low level winelib usb wrapper for the Minipro TL866A/CS, TL866II+, Xgecu T48, T56 and T76 programmers. diff --git a/wine64/Makefile b/wine64/Makefile new file mode 100644 index 0000000..f242656 --- /dev/null +++ b/wine64/Makefile @@ -0,0 +1,77 @@ +CC ?= gcc +CFLAGS ?= -O2 -Wall -Wextra -Wno-unused-parameter +LDFLAGS ?= -lpthread +WINCC ?= i686-w64-mingw32-gcc +WINRC ?= i686-w64-mingw32-windres + +PKG_CONFIG := $(shell which pkg-config 2>/dev/null) + +# LibUSB detection +ifeq ($(strip $(PKG_CONFIG)),) + LIBUSB_CFLAGS := + LIBUSB_LIBS := -lusb-1.0 +else + LIBUSB_CFLAGS := $(shell $(PKG_CONFIG) --cflags libusb-1.0 2>/dev/null) + LIBUSB_LIBS := $(shell $(PKG_CONFIG) --libs libusb-1.0 2>/dev/null) + ifeq ($(strip $(LIBUSB_LIBS)),) + LIBUSB_LIBS := -lusb-1.0 + endif +endif + +# usb-broker +BIN := usb-broker +SRC := broker.c +HDR := protocol.h + +RES_RC := resource.rc +RES_RES := resource.res + + +# shim.dll +DLL := shim.dll +DLL_SRCS := shim.c +DLL_OBJS := $(DLL_SRCS:.c=.o) +DLL_CFLAGS := -O2 -s -DWIN32 -D_WIN32_WINNT=0x0601 -Wall -Wextra -Wno-unused-parameter +DLL_LDFLAGS := -shared -Wl,--kill-at -Wl,--enable-stdcall-fixup +DLL_LIBS := -lws2_32 -lshlwapi -lgdi32 -luxtheme + +# launcher.exe +LAUNCHER := launcher.exe +LAUNCHER_SRCS := launcher.c +LAUNCHER_OBJS := $(LAUNCHER_SRCS:.c=.o) +LAUNCHER_CFLAGS := -O2 -s -DWIN32 -D_WIN32_WINNT=0x0601 -Wall -Wextra +LAUNCHER_LDFLAGS:= -municode -mconsole +LAUNCHER_LIBS := -lshlwapi + + +.PHONY: all broker shim launcher windows clean + +all: broker shim launcher + +broker: $(BIN) + +$(BIN): $(SRC) $(HDR) + $(CC) $(CFLAGS) $(LIBUSB_CFLAGS) -o $@ $(SRC) $(LDFLAGS) $(LIBUSB_LIBS) + +windows: shim launcher + +shim: $(DLL) +launcher: $(LAUNCHER) + +$(DLL): $(DLL_OBJS) $(RES_RES) + $(WINCC) $(DLL_LDFLAGS) -o $@ $(DLL_OBJS) $(RES_RES) $(DLL_LIBS) + +$(LAUNCHER): $(LAUNCHER_OBJS) + $(WINCC) $(LAUNCHER_LDFLAGS) -o $@ $(LAUNCHER_OBJS) $(LAUNCHER_LIBS) + +%.o: %.c + $(WINCC) $(WCCFLAGS) -c $< -o $@ + +shim.o: WCCFLAGS := $(DLL_CFLAGS) +launcher.o: WCCFLAGS := $(LAUNCHER_CFLAGS) + +$(RES_RES): $(RES_RC) resource.h + $(WINRC) -i $(RES_RC) -O coff -o $(RES_RES) + +clean: + rm -f $(BIN) *.o $(DLL) $(LAUNCHER) $(RES_RES) diff --git a/wine64/README.md b/wine64/README.md new file mode 100644 index 0000000..511e5a9 --- /dev/null +++ b/wine64/README.md @@ -0,0 +1,220 @@ +# Xgpro/Minipro Cross-Architecture USB Wrapper (Broker + Shim) + + **What is this?** +A modern, cross-architecture replacement for the legacy 32-bit [WineLib wrapper](https://github.com/radiomanV/TL866/tree/master/wine32#). +It splits the old `setupapi.dll` logic into: + +- **A native USB broker** (Linux, 64-bit or 32-bit, any arch) that talks to LibUSB. + +- **A native Windows shim DLL** that runs inside the Windows app (Xgpro/Minipro) and proxies USB calls to the broker. + + **Why?** + +- Works on **x86_64, aarch64, armhf**, etc. + +- No 32-bit Wine and 32-bit libs requirement. + +- Avoids SSE/stack alignment pitfalls from the legacy approach. + +- Cleaner debugging and isolation. + +--- + +## Supported programmers + +- **Minipro TL866A/CS** +- **XGecu TL866II+** +- **XGecu T48 / T56 / T76** + +## Features + +- **Cross-arch**: broker builds natively for your host (x86_64, arm64, armhf, etc.) +- **Broker/Shim split**: minimal 32-Bit native Windows DLL +- **Socket protocol**: shim to broker IPC over local TCP socket +- **Hotplug**: libusb hotplug events +- **Verbose tracing**: single env var to dump full TX/RX +- **Drop-in**: works with stock `Xgpro.exe` / `Xgpro_T76.exe` / `Minipro.exe` + +--- + +## Requirements + +### Host (Linux) + +- `libusb-1.0` (runtime; `-dev` for building broker) + +- `wine` or `wine64` (only runtime, no `-dev` packages needed) + +- Build tools: `gcc`, `i686-w64-mingw32-gcc`, `make`, `pkg-config` + + ```bash + # Debian / Ubuntu / Mint + sudo apt install -y wine winetricks libusb-1.0-0 + sudo apt install -y build-essential pkg-config libusb-1.0-0-dev \ + mingw-w64 gcc-mingw-w64-i686 + + # Arch / Manjaro + sudo pacman -S --needed wine winetricks libusb + sudo pacman -S --needed gcc make pkgconf mingw-w64-gcc + + # Fedora / RHEL + sudo dnf install -y wine winetricks libusb1 + sudo dnf install -y gcc make pkgconfig libusb1-devel \ + mingw32-gcc mingw32-binutils mingw32-headers mingw32-crt + + # openSUSE + sudo zypper in -y wine winetricks libusb-1_0-0 + sudo zypper in -y gcc make pkg-config libusb-1_0-devel mingw32-gcc + ``` + +### Wine / App + +- App: `Xgpro.exe`, `Xgpro_T76.exe`, or `Minipro.exe` +- The **shim DLL** must be placed alongside the app (see install) + +--- + +## Install + +### 1) Clone git repository + +```bash +git clone https://github.com/radiomanV/TL866.git && cd TL866 +``` + +### 2) Udev rules (recommended) + +```bash +sudo cp ./udev/* /etc/udev/rules.d/ +sudo udevadm control --reload-rules +sudo udevadm trigger +``` + +This grants non-root access to the programmers. + +### 3) Build the broker (native) + +```bash +cd wine64 +make broker # produces usb-broker +``` + +### 4) Build the Windows component + +```bash +make windows # produces launcher.exe and shim.dll +``` + +#### A simple make will compile all three components above. + +```bash +make +``` + +You can use the provided `shim.dll`, `launcher.exe`, and `usb-broker`. +`shim.dll` and `launcher.exe` do not need recompilation (they’re prebuilt natively), but +`usb-broker` may need to be rebuilt depending on your Linux distribution or architecture. + +### 5) Place the shim, launcher and usb-broker next to the app + +Copy the resulting files `usb-broker` `shim.dll` `launcher.exe` and (optionally) `run.sh`to the application directory. +Mark `usb-broker` and `run.sh` as executable: + +```bash +chmod +x usb-broker run.sh +``` + +--- + +## Quick start + +``` +# Minimal, without any script: +cd /path/to/app/ +./usb-broker --quiet & wine launcher.exe 2>/dev/null + +# Or you can use the provided run.sh script, which can be customized via +# explicit environment variables: +BROKER_PORT=35866 +APP_PATH="/path/to/launcher.exe" +TARGET_EXE="Xgpro.exe" +SHIM_DLL="shim.dll" +USB_BROKER_PATH="/path/to/xgecu-usb-broker" +WINECMD="wine64" + +# This will start the broker (if needed) on the default port 35866 and +# run the launcher with the default Xgpro.exe name. +run.sh + +# This will overide the default Xgpro.exe name: +TARGET_EXE=Minipro.exe ./run.sh +TARGET_EXE=Xgpro_T76.exe ./run.sh + +# This will overide the default IPC port: +BROKER_PORT=35000 ./run.sh +``` + +- The script will: + - start the **broker** (if not running), + - launch Wine with the shimmed app, + - wire them together over the configured socket. + +Works without a 32-bit prefix; you can use `~/.wine64`, default prefix or any Wine prefix you prefer. + +The USB broker can also be run standalone for debugging. It accepts the following arguments: + +``` +--port (listens on port N) +--quiet (reduced logging) +--no-exit (do not exit when there are no clients) +``` + +The USB broker supports multiple concurrent connections and can handle up to 64 USB devices. +Unless `--no-exit` is specified, the USB broker will automatically exit after a timeout. + +--- + +## Configuration (env vars) + +These are read by `run.sh` and/or the shim: + +- `BROKER_PORT`: TCP port for shim-broker IPC (default: `35866`) +- `APP_PATH`: path to the Windows app launcher (optional) +- `TARGET_EXE`: the Windows binary to run (e.g. `Xgpro.exe`) +- `SHIM_DLL`: shim file name in the app folder (e.g. `shim.dll`) +- `USB_BROKER_PATH`: full path to the broker binary +- `WINECMD`: `wine` or `wine64` (default: `wine`) +- `TL_DEBUG`: set to `1` for verbose USB/protocol logs + +--- + +## Troubleshooting + +- **Device not found / permission denied** + + - Recheck udev rules, unplug/replug, verify you’re in the correct groups (e.g., `plugdev` on some distros). + +- **Shim cannot find broker** + + - Verify `BROKER_PORT` and that broker is running; try `USB_BROKER_PATH` absolute path. + +- **Socket conflicts** + + - Change `BROKER_PORT`. + +- **Black toolbar when theme is active under Wine** + + - Install native comctl32 v5.80 or disable the Wine theme. + + ```bash + winetricks comctl32 && wineboot + ``` + +--- + +## Security & privacy + +- The broker runs locally and exposes a local port (loopback only). +- No network access beyond the local IPC channel. + +--- diff --git a/wine64/broker.c b/wine64/broker.c new file mode 100644 index 0000000..eaf4890 --- /dev/null +++ b/wine64/broker.c @@ -0,0 +1,662 @@ +/* + * broker.c + * Minimal USB broker for shim.dll. + * The USB broker will redirect all RPC calls from the shim to the + * Linux USB subsystem using LibUSB calls. + * Created: September 10, 2025 + * Author: radiomanV + */ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "protocol.h" + +typedef struct { + uint32_t id; + libusb_device_handle *h; + uint8_t ifnum; + char path[128]; +} handle_entry_t; + +typedef struct { + int sock; + int running; + libusb_hotplug_callback_handle cb; +} hotplug_sub_t; + +static handle_entry_t libusb_map[64]; +static pthread_mutex_t map_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t id_mutex = PTHREAD_MUTEX_INITIALIZER; +static int map_idx = 0; +static uint32_t map_next_id = 1; +static volatile int num_clients = 0; +static volatile int b_verbose = 1; +static volatile int b_sigint = 0; + +#define LOG(fmt, ...) \ + do { \ + if (b_verbose) \ + fprintf(stderr, "[broker] " fmt "\n", ##__VA_ARGS__); \ + } while (0) + +#define ERR(fmt, ...) fprintf(stderr, "[broker:ERR] " fmt "\n", ##__VA_ARGS__) + +// Socket buffer send function +static int socket_send(int sock, const void *buf, int len) +{ + const char *pbuf = (const char *)buf; + int done = 0; + while (done < len) { + int n = send(sock, pbuf + done, len - done, 0); + if (n <= 0) + return RPC_E_SEND_ERR; + done += n; + } + return EXIT_SUCCESS; +} + +// Socket buffer receive function +static int socket_recv(int sock, void *buf, int len) +{ + char *p = (char *)buf; + int rcvd = 0; + while (rcvd < len) { + int n = recv(sock, p + rcvd, len - rcvd, 0); + if (n <= 0) + return RPC_E_RECV_ERR; + rcvd += n; + } + return EXIT_SUCCESS; +} + +// Socket reply function +static int send_reply(int s, uint16_t type, const void *payload, uint32_t plen) +{ + rpc_hdr_t h = { .len = plen, .type = type, .version = PROTO_VERSION }; + if (socket_send(s, &h, sizeof(h))) + return RPC_E_SEND_ERR; + if (plen && socket_send(s, payload, (int)plen)) + return RPC_E_SEND_ERR; + return EXIT_SUCCESS; +} + +// Helpers to store/read/delete a handle_entry +static int map_put(libusb_device_handle *h, uint8_t ifnum, uint32_t *out_id, + const char *path) +{ + pthread_mutex_lock(&map_mutex); + if (map_idx >= (int)(sizeof(libusb_map) / sizeof(libusb_map[0]))) { + pthread_mutex_unlock(&map_mutex); + return EXIT_FAILURE; + } + + uint32_t id; + pthread_mutex_lock(&id_mutex); + id = map_next_id++; + if (id == 0) + id = map_next_id++; + pthread_mutex_unlock(&id_mutex); + + libusb_map[map_idx] = + (handle_entry_t){ .id = id, .h = h, .ifnum = ifnum }; + strncpy(libusb_map[map_idx].path, path, sizeof(libusb_map[0].path)); + map_idx++; + + pthread_mutex_unlock(&map_mutex); + *out_id = id; + return EXIT_SUCCESS; +} + +static handle_entry_t *map_get(uint32_t id) +{ + for (int i = 0; i < map_idx; i++) { + if (libusb_map[i].id == id) + return &libusb_map[i]; + } + return NULL; +} + +static int map_del(uint32_t id) +{ + pthread_mutex_lock(&map_mutex); + for (int i = 0; i < map_idx; i++) { + if (libusb_map[i].id == id) { + libusb_map[i] = libusb_map[map_idx - 1]; + map_idx--; + pthread_mutex_unlock(&map_mutex); + return EXIT_SUCCESS; + } + } + pthread_mutex_unlock(&map_mutex); + return EXIT_FAILURE; +} + +// LibUSB enumerate helper +static int usb_enum(dev_info_t **out_list, uint32_t *out_cnt) +{ + libusb_device **list = NULL; + ssize_t n = libusb_get_device_list(NULL, &list); + if (n < 0) + return EXIT_FAILURE; + + uint32_t cap = (uint32_t)(n > 512 ? 512 : n); + dev_info_t *arr = (dev_info_t *)calloc(cap, sizeof(dev_info_t)); + if (!arr) { + libusb_free_device_list(list, 1); + return EXIT_FAILURE; + } + + uint32_t cnt = 0; + for (ssize_t i = 0; i < n && cnt < cap; i++) { + libusb_device *dev = list[i]; + struct libusb_device_descriptor dd; + if (libusb_get_device_descriptor(dev, &dd)) + continue; + dev_info_t di = { 0 }; + di.vid = dd.idVendor; + di.pid = dd.idProduct; + di.bus = libusb_get_bus_number(dev); + di.addr = libusb_get_device_address(dev); + di.ifnum = 0; + snprintf(di.path, sizeof(di.path), "usb:%u-%u", di.bus, + di.addr); + struct libusb_config_descriptor *cfg = NULL; + if (libusb_get_active_config_descriptor(dev, &cfg)) { + di.has_eps = 0; + memset(di.wMaxPacketSize, 0, sizeof(di.wMaxPacketSize)); + } else { + di.has_eps = 1; + memset(di.wMaxPacketSize, 0, sizeof(di.wMaxPacketSize)); + for (int i = 0; i < cfg->bNumInterfaces; i++) { + const struct libusb_interface *it = + &cfg->interface[i]; + for (int a = 0; a < it->num_altsetting; a++) { + const struct libusb_interface_descriptor + *id = &it->altsetting[a]; + for (int k = 0; k < id->bNumEndpoints; + k++) { + const struct libusb_endpoint_descriptor + *ep = &id->endpoint[k]; + uint8_t num = + ep->bEndpointAddress & + 0x0F; + if (num < 16) + di.wMaxPacketSize[num] = + ep->wMaxPacketSize; + } + } + } + } + libusb_free_config_descriptor(cfg); + + arr[cnt++] = di; + } + libusb_free_device_list(list, 1); + *out_list = arr; + *out_cnt = cnt; + return EXIT_SUCCESS; +} + +// LibUSB open_device RPC helper +static libusb_device_handle *open_device(const char *path, open_resp_t *resp) +{ + if (resp) { + resp->status = RPC_E_OPEN_ERR; + resp->product[0] = '\0'; + resp->speed = LIBUSB_SPEED_UNKNOWN; + resp->handle_id = 0; + } + + int wa = 0, wb = 0; + if (!path) + return NULL; + if (strcmp(path, "usb:auto-first") == 0) { + wa = -1, wb = -1; + } else if (sscanf(path, "usb:%d-%d", &wb, &wa) != 2) { + return NULL; + } + + libusb_device **list = NULL; + ssize_t n = libusb_get_device_list(NULL, &list); + if (n < 0) + return NULL; + + libusb_device_handle *hnd = NULL; + + for (ssize_t i = 0; i < n; i++) { + libusb_device *d = list[i]; + if ((wb == -1 && wa == -1) || + (libusb_get_bus_number(d) == wb && + libusb_get_device_address(d) == wa)) { + if (!libusb_open(d, &hnd)) { + if (resp) { + libusb_device *dev = + libusb_get_device(hnd); + if (dev) { + resp->speed = + libusb_get_device_speed( + dev); + + struct libusb_device_descriptor + dd; + if (libusb_get_device_descriptor( + dev, &dd) == + LIBUSB_SUCCESS && + dd.iProduct) { + unsigned char tmp[sizeof( + resp->product)]; + int m = libusb_get_string_descriptor_ascii( + hnd, + dd.iProduct, + tmp, + sizeof(tmp) - + 1); + if (m > 0) { + tmp[m] = 0; + strncpy(resp->product, + (const char + *) + tmp, + sizeof(resp->product) - + 1); + resp->product + [sizeof(resp->product) - + 1] = 0; + } + } + } + } + uint32_t id = 0; + if (map_put(hnd, 0, &id, path) == 0) { + if (resp) { + resp->handle_id = id; + } + int cfg = 0; + if (libusb_get_configuration(hnd, + &cfg) == + LIBUSB_SUCCESS && + cfg == 0) { + libusb_set_configuration(hnd, + 1); + } + if (libusb_claim_interface(hnd, 0) == + LIBUSB_SUCCESS) + resp->status = 0; + else + resp->status = RPC_E_OPEN_BUSY; + break; + } else { + libusb_close(hnd); + hnd = NULL; + } + } + if (wb != -1 || wa != -1) + break; + } + } + + libusb_free_device_list(list, 1); + return hnd; +} + +/* ------------ Client hotplug subscription socket notifier -------------*/ +static int LIBUSB_CALL on_hotplug(libusb_context *ctx, libusb_device *dev, + libusb_hotplug_event event, void *user) +{ + hotplug_sub_t *sub = (hotplug_sub_t *)user; + if (!sub || sub->sock < 0) + return 0; + + struct libusb_device_descriptor desc; + if (libusb_get_device_descriptor(dev, &desc)) + return 0; + + hotplug_evt_t evt = { 0 }; + evt.arrived = (event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) ? 1 : 0; + evt.vid = desc.idVendor; + evt.pid = desc.idProduct; + evt.bus = libusb_get_bus_number(dev); + evt.addr = libusb_get_device_address(dev); + + // Send reply to client + if (send_reply(sub->sock, MSG_HOTPLUG_EVT, &evt, sizeof(evt)) != 0) { + sub->running = 0; + } + return 0; +} + +// LibUSB hotplug thread loop +static void *hotplug_loop(void *arg) +{ + hotplug_sub_t *sub = (hotplug_sub_t *)arg; + struct timeval tv = { .tv_sec = 0, .tv_usec = 250000 }; + while (sub->running) { + int rc = + libusb_handle_events_timeout_completed(NULL, &tv, NULL); + if (rc != 0) + usleep(1000); + char tmp; + int n = recv(sub->sock, &tmp, 1, MSG_PEEK | MSG_DONTWAIT); + if (n == 0) { + sub->running = 0; + break; + } + } + return NULL; +} + +/* ---------- Client worker thread ---------------*/ +static void *client_worker(void *arg) +{ + //LOG("client connected (fd=%d)", sock); + + int sock = (int)(intptr_t)arg; + for (;;) { + rpc_hdr_t hdr; + if (socket_recv(sock, &hdr, sizeof(hdr))) + break; + if (hdr.version != PROTO_VERSION) { + ERR("version mismatch: %u", hdr.version); + break; + } + + uint8_t *request = NULL; + if (hdr.len) { + request = (uint8_t *)malloc(hdr.len); + if (!request) + break; + if (socket_recv(sock, request, (int)hdr.len)) { + free(request); + break; + } + } + + uint8_t buf[1 << 16]; + uint32_t len = 0; + switch (hdr.type) { + + // Enumerate USB devices RPC + case MSG_ENUMERATE: { + dev_info_t *list = NULL; + uint32_t cnt = 0; + enum_resp_t *resp = NULL; + int rc = usb_enum(&list, &cnt); + LOG("Enumerate: %u USB devices found.", cnt); + if (rc == 0) { + len = sizeof(enum_resp_t) + + cnt * sizeof(dev_info_t); + resp = (enum_resp_t *)malloc(len); + if (!resp) { + if (list) + free(list); + break; + } + resp->status = 0; + resp->count = cnt; + memcpy((uint8_t *)resp + sizeof(*resp), list, + cnt * sizeof(dev_info_t)); + free(list); + send_reply(sock, MSG_ENUMERATE, resp, len); + free(resp); + resp = NULL; + request = NULL; + continue; + } else { + enum_resp_t b = { .status = -1, .count = 0 }; + send_reply(sock, MSG_ENUMERATE, &b, sizeof(b)); + if (request) + free(request); + continue; + } + } break; + + // Open device RPC + case MSG_OPEN: { + const open_req_t *rq = (const open_req_t *)request; + open_resp_t resp; + memset(&resp, 0, sizeof(resp)); + resp.handle_id = 0; + resp.speed = 0; + resp.product[0] = '\0'; + open_device(rq->path, &resp); + if (!resp.status) { + LOG("Open device: %s", rq->path); + } + send_reply(sock, MSG_OPEN, &resp, sizeof(resp)); + } break; + + // Close device RPC + case MSG_CLOSE: { + const close_req_t *rq = (const close_req_t *)request; + close_resp_t resp = { .status = -1 }; + handle_entry_t *ent = map_get(rq->handle_id); + if (ent && ent->h) { + LOG("Close device: %s", ent->path); + libusb_release_interface(ent->h, ent->ifnum); + libusb_close(ent->h); + map_del(rq->handle_id); + resp.status = 0; + } + send_reply(sock, MSG_CLOSE, &resp, sizeof(resp)); + } break; + + // Bulk transfer RPC + case MSG_BULK: { + const bulk_req_t *rq = (const bulk_req_t *)request; + handle_entry_t *ent = map_get(rq->handle_id); + LOG("%s %s Bulk transfer: %u bytes", ent->path, + rq->ep & 0x80 ? "IN" : "OUT", rq->len); + + int ep_in = ((rq->ep & 0x80) != 0); + int rc = -1, xfer = 0; + uint8_t *payload = NULL; + size_t pay_len = 0; + size_t hdr_len = sizeof(*rq); + + if (!ep_in) { + payload = request + hdr_len; + pay_len = (hdr.len > hdr_len) ? + (hdr.len - hdr_len) : + 0; + } else { + payload = buf + sizeof(bulk_resp_t); + pay_len = rq->len; + } + + if (ent && ent->h) { + if (hdr.type == MSG_BULK) { + rc = libusb_bulk_transfer( + ent->h, rq->ep, payload, + (int)pay_len, &xfer, + rq->timeout_ms); + } else { + rc = libusb_interrupt_transfer( + ent->h, rq->ep, payload, + (int)pay_len, &xfer, + rq->timeout_ms); + } + } + + bulk_resp_t *resp = (bulk_resp_t *)buf; + resp->status = rc; + resp->rx_len = (ep_in && rc == 0) ? (uint32_t)xfer : 0; + len = sizeof(*resp) + resp->rx_len; + send_reply(sock, hdr.type, buf, len); + } break; + + // Cancel transfer RPC + case MSG_CANCEL: { + LOG("Cancel transfer"); + cancel_resp_t resp = { .status = 0 }; + send_reply(sock, MSG_CANCEL, &resp, sizeof(resp)); + } break; + + // Hotplug subscribe RPC + case MSG_HOTPLUG_SUB: { + LOG("Hotplug subcribe"); + hotplug_sub_t sub = { .sock = sock, .running = 1 }; + int rc = libusb_hotplug_register_callback( + NULL, + LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | + LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, + 0, LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, on_hotplug, &sub, + &sub.cb); + if (rc != LIBUSB_SUCCESS) { + ERR("hotplug not available: %s", + libusb_error_name(rc)); + } else { + pthread_t th; + // GCC atomic increment builtin + __sync_add_and_fetch(&num_clients, 1); + pthread_create(&th, NULL, hotplug_loop, &sub); + pthread_detach(th); + while (sub.running) { + char tmp; + int n = recv(sock, &tmp, 1, + MSG_PEEK | MSG_DONTWAIT); + if (n == 0) { + sub.running = 0; + break; + } + usleep(100000); + } + libusb_hotplug_deregister_callback(NULL, sub.cb); + if (request) + free(request); + // GCC atomic decrement builtin + __sync_sub_and_fetch(&num_clients, 1); + goto done; + } + } break; + + default: + ERR("unknown msg type: 0x%04x", hdr.type); + break; + } + + if (request) + free(request); + } + +done: + close(sock); + //LOG("client disconnected (fd=%d)", sock); + return NULL; +} + +// SIGINT handler +static void sigint_handler(int sig) +{ + LOG("SIGINT"); + b_sigint = 1; +} + +/*-------------Main loop------------------------------*/ +int main(int argc, char **argv) +{ + int port = RPC_PORT_DEFAULT; + int no_exit = 0; + + // Parse arguments + for (int i = 1; i < argc; i++) { + if (!strcmp(argv[i], "--port") && i + 1 < argc) { + port = atoi(argv[++i]); + } else if (!strcmp(argv[i], "--quiet")) { + b_verbose = 0; + } else if (!strcmp(argv[i], "--no-exit")) { + no_exit = 1; + } else if (!strcmp(argv[i], "--help")) { + fprintf(stderr, "usb-broker options:\n"); + fprintf(stderr, " --port N listen port (default %d)\n", + RPC_PORT_DEFAULT); + fprintf(stderr, + " --no-exit don't exit when no clients\n"); + fprintf(stderr, " --quiet less logs\n"); + return 0; + } + } + + // Initialize LibUSB + if (libusb_init(NULL) != 0) { + ERR("libusb_init failed"); + return EXIT_FAILURE; + } + + // Initialize SIGINT handler + signal(SIGINT, sigint_handler); + + // Initialize broker server + int sock = socket(AF_INET, SOCK_STREAM, 0); + if (sock < 0) { + perror("socket"); + return EXIT_FAILURE; + } + int on = 1; + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); + struct sockaddr_in addr; + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + perror("bind"); + return EXIT_FAILURE; + } + if (listen(sock, 32) < 0) { + perror("listen"); + return EXIT_FAILURE; + } + + // Set the non-blocking flag + int flags = fcntl(sock, F_GETFL, 0) | O_NONBLOCK; + fcntl(sock, F_SETFL, flags); + LOG("listening on 127.0.0.1:%d", port); + + // Enter client wait loop + int wait = 0; + do { + struct timeval tv = { .tv_sec = 3, .tv_usec = 0 }; + fd_set rf; + FD_ZERO(&rf); + FD_SET(sock, &rf); + int rc = select(sock + 1, &rf, NULL, NULL, &tv); + if (rc < 0) { + if (errno == EINTR) + continue; + perror("select"); + break; + } + + // Accept and create a new client worker thread + if (rc > 0 && FD_ISSET(sock, &rf)) { + int cs = accept(sock, NULL, NULL); + if (cs >= 0) { + pthread_t th; + pthread_create(&th, NULL, client_worker, + (void *)(intptr_t)cs); + pthread_detach(th); + wait = 3; + } + } + if(wait) wait--; + } while ((num_clients || no_exit || wait) && !b_sigint); + + close(sock); + libusb_exit(NULL); + return EXIT_SUCCESS; +} diff --git a/wine64/launcher.c b/wine64/launcher.c new file mode 100644 index 0000000..4e7773e --- /dev/null +++ b/wine64/launcher.c @@ -0,0 +1,190 @@ +/* + * launcher.c + * Native x86 windows dll injector and launcher. + * Created: September 10, 2025 + * Author: radiomanV + */ + +#define UNICODE +#define _UNICODE +#include +#include +#include +#include +#include + +// Dll injector function +static BOOL inject_dll(HANDLE hProc, const wchar_t *dllPath) +{ + SIZE_T size = (wcslen(dllPath) + 1) * sizeof(wchar_t), wr = 0; + LPVOID remote = VirtualAllocEx( + hProc, NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); + if (!remote) + return FALSE; + BOOL ok = WriteProcessMemory(hProc, remote, dllPath, size, &wr) && + wr == size; + if (!ok) { + VirtualFreeEx(hProc, remote, 0, MEM_RELEASE); + return FALSE; + } + + HMODULE hm = GetModuleHandleW(L"kernel32.dll"); + FARPROC pLoadLib = hm ? GetProcAddress(hm, "LoadLibraryW") : NULL; + if (!pLoadLib) { + VirtualFreeEx(hProc, remote, 0, MEM_RELEASE); + return FALSE; + } + + HANDLE thrd = CreateRemoteThread(hProc, NULL, 0, + (LPTHREAD_START_ROUTINE)pLoadLib, + remote, 0, NULL); + if (!thrd) { + VirtualFreeEx(hProc, remote, 0, MEM_RELEASE); + return FALSE; + } + + WaitForSingleObject(thrd, INFINITE); + DWORD ret = 0; + GetExitCodeThread(thrd, &ret); + CloseHandle(thrd); + VirtualFreeEx(hProc, remote, 0, MEM_RELEASE); + return ret != 0; +} + +// Check file path +static int check_path(const wchar_t *base_dir, const wchar_t *arg, wchar_t *out, + size_t out_sz) +{ + if (!arg || !*arg) + return 0; + + if (!PathIsRelativeW(arg)) { + wcsncpy(out, arg, out_sz); + out[out_sz - 1] = L'\0'; + } else { + if (!PathCombineW(out, base_dir, arg)) + return 0; + } + + DWORD att = GetFileAttributesW(out); + return (att != INVALID_FILE_ATTRIBUTES) && + !(att & FILE_ATTRIBUTE_DIRECTORY); +} + +// Main function +int wmain(int argc, wchar_t **argv) +{ + const wchar_t *exe_arg = L""; + const wchar_t *shim_arg = L"shim.dll"; + int forced = 0; + + // Get the launcher's directory + wchar_t dir[MAX_PATH]; + DWORD n = GetModuleFileNameW(NULL, dir, ARRAYSIZE(dir)); + if (n && n < ARRAYSIZE(dir)) { + PathRemoveFileSpecW(dir); + } + + // Parse command line + int pf = -1; + for (int i = 1; i < argc; i++) { + if (wcscmp(argv[i], L"--exe") == 0 && i + 1 < argc) { + exe_arg = argv[++i]; + forced = 1; + continue; + } + if (wcscmp(argv[i], L"--shim") == 0 && i + 1 < argc) { + shim_arg = argv[++i]; + continue; + } + if (wcscmp(argv[i], L"--") == 0) { + pf = i + 1; + break; + } + } + + wchar_t exe_path[MAX_PATH], shim_path[MAX_PATH]; + if (forced) { + if (!check_path(dir, exe_arg, exe_path, ARRAYSIZE(exe_path))) { + wprintf(L"[launcher] --exe path not found or invalid: \"%ls\"\n", + exe_arg); + return EXIT_FAILURE; + } + } else { + const wchar_t *progs[] = { L"Minipro.exe", L"Xgpro.exe", + L"Xgpro_T76.exe" }; + int found = 0; + for (size_t i = 0; i < ARRAYSIZE(progs); ++i) { + if (check_path(dir, progs[i], exe_path, + ARRAYSIZE(exe_path))) { + exe_arg = progs[i]; + found = 1; + break; + } + } + if (!found) { + wprintf(L"[launcher] --exe not specified and no known executable found.\n", + dir); + return EXIT_FAILURE; + } + } + + // Resolve shim (accept absolute or relative) + if (!check_path(dir, shim_arg, shim_path, ARRAYSIZE(shim_path))) { + wprintf(L"[launcher] Shim not found: \"%ls\" (base: \"%ls\")\n", + shim_arg, dir); + return EXIT_FAILURE; + } + + // Build the target process command line + wchar_t cmdline[4096]; + int off = _snwprintf(cmdline, ARRAYSIZE(cmdline), L"\"%s\"", exe_path); + if (off < 0 || off >= (int)ARRAYSIZE(cmdline)) { + wprintf(L"[launcher] Command line too long (exe).\n"); + return EXIT_FAILURE; + } + if (pf > 0) { + for (int i = pf; i < argc; ++i) { + int wrote = _snwprintf(cmdline + off, + ARRAYSIZE(cmdline) - off, + L" \"%ls\"", argv[i]); + if (wrote < 0 || + off + wrote >= (int)ARRAYSIZE(cmdline)) { + wprintf(L"[launcher] Command line too long.\n"); + return EXIT_FAILURE; + } + off += wrote; + } + } + + // Create a suspended process + STARTUPINFOW si = { 0 }; + si.cb = sizeof(si); + PROCESS_INFORMATION pinfo = { 0 }; + if (!CreateProcessW(NULL, cmdline, NULL, NULL, FALSE, + CREATE_SUSPENDED | CREATE_UNICODE_ENVIRONMENT, NULL, + NULL, &si, &pinfo)) { + wprintf(L"[launcher] CreateProcessW failed, err=%lu\n", + GetLastError()); + return EXIT_FAILURE; + } + + // Inject our shim.dll into the target process + if (!inject_dll(pinfo.hProcess, shim_path)) { + wprintf(L"[launcher] DLL injection failed, err=%lu\n", + GetLastError()); + TerminateProcess(pinfo.hProcess, 1); + CloseHandle(pinfo.hThread); + CloseHandle(pinfo.hProcess); + return EXIT_FAILURE; + } + + // Resume process and wait for exit + ResumeThread(pinfo.hThread); + WaitForSingleObject(pinfo.hProcess, INFINITE); + DWORD ret = 0; + GetExitCodeProcess(pinfo.hProcess, &ret); + CloseHandle(pinfo.hThread); + CloseHandle(pinfo.hProcess); + return (int)ret; +} diff --git a/wine64/launcher.exe b/wine64/launcher.exe new file mode 100755 index 0000000000000000000000000000000000000000..b2bee1d9ac352faaae2271ef497b57ad5c35c080 GIT binary patch literal 240798 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 OxEk^FK~LY+^nU^F2IKAk literal 0 HcmV?d00001 diff --git a/wine64/protocol.h b/wine64/protocol.h new file mode 100644 index 0000000..787232f --- /dev/null +++ b/wine64/protocol.h @@ -0,0 +1,141 @@ +/* + * protocol.h + * USB broker protocol call definitions + * Created: September 10, 2025 + * Author: radiomanV + */ + +#pragma once +#include + +#if defined(_MSC_VER) +#define PACKED +#pragma pack(push, 1) +#else +#define PACKED __attribute__((__packed__)) +#endif + +#define PROTO_VERSION 2 +#define RPC_PORT_DEFAULT 35866 + +// ---- MSG ---- +enum msg_type { + MSG_ENUMERATE = 1, + MSG_OPEN, + MSG_CLOSE, + MSG_BULK, + MSG_CANCEL, + MSG_HOTPLUG_SUB, + MSG_HOTPLUG_EVT, +}; + +// ---- RPC HEADER ---- +typedef struct PACKED { + uint32_t len; + uint16_t type; + uint16_t version; +} rpc_hdr_t; + +// --- DEVICE INFO --- +typedef struct PACKED { + uint16_t vid, pid; + uint8_t bus, addr; + uint8_t ifnum; + uint8_t has_eps; + uint16_t wMaxPacketSize[16]; + char path[128]; +} dev_info_t; + +// ---- ENUMERATE ---- +typedef struct PACKED { + int32_t status; + uint32_t count; + dev_info_t devs[0]; +} enum_resp_t; + +// ---- OPEN ---- +typedef struct PACKED { + char path[128]; +} open_req_t; + +typedef struct PACKED { + int32_t status; + uint32_t handle_id; + uint8_t speed; + char product[64]; +} open_resp_t; + +// ---- CLOSE ---- +typedef struct PACKED { + uint32_t handle_id; +} close_req_t; + +typedef struct PACKED { + int32_t status; +} close_resp_t; + +// ---- BULK ---- +typedef struct PACKED { + uint32_t handle_id; + uint8_t ep; + uint32_t timeout_ms; + uint32_t len; +} bulk_req_t; + +typedef struct PACKED { + int32_t status; + uint32_t rx_len; + uint8_t data[0]; +} bulk_resp_t; + +// ---- CANCEL ---- +typedef struct PACKED { + uint32_t handle_id; +} cancel_req_t; + +typedef struct PACKED { + int32_t status; +} cancel_resp_t; + +// ---- HOTPLUG ---- +typedef struct PACKED { + uint16_t vid, pid; +} hotplug_sub_req_t; + +typedef struct PACKED { + uint8_t arrived; + uint16_t vid, pid; + uint8_t bus, addr; +} hotplug_evt_t; + +typedef enum rpc_err_t { + BR_E_WSA = -1, + BR_E_SOCK = -2, + BR_E_CONNECT_IMMEDIATE = -3, + BR_E_CONNECT_SOERR = -4, + BR_E_CONNECT_TIMEOUT = -5, + BRK_E_READY_TIMEOUT = -50, + BRK_E_READY_FAILED = -51, + BRK_E_WAIT_TIMEOUT = -52, + RPC_E_RESP_LEN_NULL = -100, + RPC_E_RESP_BUF_NULL = -101, + RPC_E_MKSOCK_FAIL = -102, + RPC_E_CONNECT_TIMEOUT = -103, + RPC_E_CONNECT_FAIL = -104, + RPC_E_SEND_HEADER = -105, + RPC_E_SEND_REQ = -106, + RPC_E_SEND_EXTRA = -107, + RPC_E_RECV_HEADER = -108, + RPC_E_PROTO_MISMATCH = -109, + RPC_E_RESP_TOO_LARGE = -110, + RPC_E_RECV_PAYLOAD = -111, + RPC_E_RECV_ERR = -112, + RPC_E_SEND_ERR = -113, + RPC_E_OPEN_BUSY = -114, + RPC_E_OPEN_ERR = -115, +} rpc_err_t; + +#if defined(_MSC_VER) +#pragma pack(pop) +#endif +#undef PACKED diff --git a/wine64/resource.h b/wine64/resource.h new file mode 100644 index 0000000..cdf761e --- /dev/null +++ b/wine64/resource.h @@ -0,0 +1,7 @@ +#pragma once + +#define IDD_SHIM_ABOUTBOX 0xE100 +#define IDS_SHIM_VERSION 0xE200 +#define IDM_SHIM_ABOUT 0xE300 +#define IDC_SHIM_LINK 0xE400 +#define IDC_SHIM_APPICON 0xE401 diff --git a/wine64/resource.rc b/wine64/resource.rc new file mode 100644 index 0000000..07343a2 --- /dev/null +++ b/wine64/resource.rc @@ -0,0 +1,38 @@ +#include +#include "resource.h" + +#define VER_MAJOR 1 +#define VER_MINOR 0 + +#define STR_HELPER(x) #x +#define STR(x) STR_HELPER(x) + +#define IDI_APP 1 + +LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL + +IDI_APP ICON "shim.ico" + +STRINGTABLE +BEGIN + IDS_SHIM_VERSION, "v" STR(VER_MAJOR) "." STR(VER_MINOR) +END + + +// About dialog +IDD_SHIM_ABOUTBOX DIALOGEX 0, 0, 287, 118 +STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "About USB wrapper" +FONT 9, "MS Shell Dlg" +BEGIN + LTEXT "Minipro / Xgpro USB wrapper for Wine.", -1, 10, 10, 200, 10 + LTEXT "Version:", -1, 10, 24, 40, 10 + LTEXT "", IDS_SHIM_VERSION, 40, 24, 156, 10 + LTEXT "(C) 2014-2025 radiomanV", -1, 10, 38, 266, 10 + CONTROL "", -1, "Static", SS_BLACKFRAME | WS_CHILD | WS_VISIBLE, 10, 56, 270, 1 + CONTROL "", IDC_SHIM_LINK, "Static", WS_CHILD | WS_VISIBLE | SS_NOTIFY, 10, 70, 230, 24 + ICON IDI_APP, IDC_SHIM_APPICON, 234, 21, 96, 96, WS_CHILD | WS_VISIBLE + DEFPUSHBUTTON "OK", IDOK, 228, 95, 50, 14 +END + + diff --git a/wine64/run.sh b/wine64/run.sh new file mode 100755 index 0000000..0109a6e --- /dev/null +++ b/wine64/run.sh @@ -0,0 +1,77 @@ +#!/usr/bin/env bash +set -euo pipefail + +PORT="${BROKER_PORT:-35866}" +DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)" +APP="${APP_PATH:-"$DIR/launcher.exe"}" +EXE="${TARGET_EXE:-Xgpro.exe}" +SHIM="${SHIM_DLL:-shim.dll}" +BROKER="${USB_BROKER_PATH:-"$DIR/usb-broker"}" +WINECMD="${WINECMD:-wine}" + +have_nc() { command -v nc >/dev/null 2>&1; } + +is_valid_port() { + case $1 in + ''|*[!0-9]*) return 1 + esac + [ "$1" -ge 1 ] && [ "$1" -le 65535 ] +} + +port_ready() { + if ! is_valid_port "$PORT"; then + printf 'Invalid PORT="%s" (expected 1..65535)\n' "$PORT" >&2 + exit 1 + fi + + if (exec 3<>"/dev/tcp/127.0.0.1/$PORT") 2>/dev/null; then + exec 3>&- 3<&- + return 0 + fi + if have_nc && nc -z 127.0.0.1 "$PORT" >/dev/null 2>&1; then + return 0 + fi + return 1 +} + +wait_port() { + local timeout_sec="${1:-8}" i + for ((i=0; i&2 + exit 1 + fi + + echo "Starting usb-broker: $BROKER --port $PORT" + chmod +x "$BROKER" || true + "$BROKER" --port "$PORT" --quiet & + local bpid=$! + echo "usb-broker PID=$bpid" + + if ! wait_port 10; then + echo "ERROR: usb-broker did not open port $PORT in time" >&2 + kill "$bpid" 2>/dev/null || true + exit 1 + fi +} + +run_app() { + cd "$DIR" + echo "Launching wine app: $EXE" + "$WINECMD" "$APP" --exe "$EXE" --shim "$SHIM" -- "$@" 2>/dev/null +} + +start_broker +run_app "$@" diff --git a/wine64/shim.c b/wine64/shim.c new file mode 100644 index 0000000..4289416 --- /dev/null +++ b/wine64/shim.c @@ -0,0 +1,1973 @@ +/* + * shim.c + * Native x86 dll wrapper for Minipro TL866A/CS, TL866II+, XgPro T48, T56 and T76 + * programmers. + * This library will redirect all USB related functions from Minipro or Xgpro + * software to the Linux USB subsystem via usb-broker RPC calls. + * Created: September 10, 2025 + * Author: radiomanV + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "protocol.h" +#include "resource.h" + +// Defines +#define TL866A_VID 0x04d8 +#define TL866A_PID 0xe11c +#define TL866II_VID 0xa466 +#define TL866II_PID 0x0a53 +#define T76_VID 0xa466 +#define T76_PID 0x1a86 + +#define X86_PUSH 0x68 +#define X86_RET 0xc3 +#define X86_JMP 0xeb + +// Typedefs +typedef struct { + void *handle; + UCHAR PipeID; + PUCHAR Buffer; + ULONG BufferLength; + PUINT LengthTransferred; + LPOVERLAPPED Overlapped; +} Args; + +typedef struct { + uint32_t handle_id; + uint16_t wMaxPacketSize [16]; +} broker_handle_t; + +// Broker connection status +typedef enum { + BRK_STATE_INIT = 0, + BRK_STATE_CONNECTING = 1, + BRK_STATE_READY = 2, + BRK_STATE_FAILED = 3, +} broker_state_t; + +// Notification interfaces +const GUID MINIPRO_GUID = { + 0x85980D83, 0x32B9, 0x4BA1, + { 0x8F, 0xDF, 0x12, 0xA7, 0x11, 0xB9, 0x9C, 0xA2 } }; + +const GUID XGPRO_GUID1 = { + 0xE7E8BA13, 0x2A81, 0x446E, + { 0xA1, 0x1E, 0x72, 0x39, 0x8F, 0xBD, 0xA8, 0x2F } }; + +const GUID XGPRO_GUID2 = { + 0x015DE341, 0x91CC, 0x8286, + { 0x39, 0x64, 0x1A, 0x00, 0x6B, 0xC1, 0xF0, 0x0F } }; + +// Xgpro/Minipro pointers +HANDLE *usb_handle; +HANDLE *winusb_handle; +int *devices_count; + +// Globals +GUID m_guid; +uint16_t device_vid; +uint16_t device_pid; +uint16_t broker_port; +int ep_timeout[2][7]; +broker_handle_t broker_handle[4]; +volatile LONG broker_state = BRK_STATE_INIT; +HANDLE broker_evt = NULL; +HANDLE cancel_evt = NULL; +HINSTANCE m_hInst = NULL; +HANDLE hotplug_thread = NULL; +HWND hWnd_notify; +WNDPROC prev_wndproc = NULL; +int debug = 0; + +// These are function signatures extracted from Xgpro.exe and should be +// compatible from V7.0 and above. +const unsigned char xgpro_open_devices_pattern1[] = { + 0x53, 0x57, 0x6A, 0x00, 0x68, 0x80, 0x00, 0x00, 0x40, 0x6A, 0x03, + 0x6A, 0x00, 0x6A, 0x03, 0x68, 0x00, 0x00, 0x00, 0xC0, 0x68 +}; + +const unsigned char xgpro_open_devices_pattern2[] = { + 0x6A, 0x00, 0x68, 0x80, 0x00, 0x00, 0x40, 0x6A, 0x03, 0x6A, + 0x00, 0x6A, 0x03, 0x68, 0x00, 0x00, 0x00, 0xC0, 0x51 +}; + +// These are function signatures extracted from MiniPro.exe and should be +// compatible from V6.0 and above. +const unsigned char minipro_open_devices_pattern[] = { + 0x6A, 0x00, 0x68, 0x80, 0x00, 0x00, 0x00, 0x6A, + 0x03, 0x6A, 0x00, 0x6A, 0x03 }; + +const unsigned char usb_write_pattern[] = { + 0x8B, 0x94, 0x24, 0x0C, 0x10, 0x00, 0x00, 0x8D, + 0x44, 0x24, 0x00, 0x6A,0x00, 0x50, 0x8B, 0x84 }; + +const unsigned char usb_write2_pattern[] = { + 0x8B, 0x94, 0x24, 0x10, 0x10, 0x00, 0x00, 0x8D, + 0x44, 0x24, 0x00, 0x6A, 0x00, 0x50, 0x8B, 0x84 }; + +const unsigned char usb_read_pattern[] = { + 0x64, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x4C, + 0x24, 0x08, 0x8B, 0x54, 0x24, 0x04, 0x6A, 0xFF }; + +const unsigned char usb_read2_pattern[] = { + 0x8B, 0x4C, 0x24, 0x0C, 0x8B, 0x54, 0x24, 0x08, + 0x8D, 0x44, 0x24, 0x0C, 0x6A, 0x00, 0x50, 0x51 }; + +const unsigned char brickbug_pattern[] = { + 0x83, 0xC4, 0x18, 0x3D, 0x13, 0xF0, 0xC2, 0xC8, 0x75 }; + +// Print given array in hex +void print_hex(const unsigned char *buffer, unsigned int size) +{ + unsigned int i; + for (i = 0; i < size; i++) { + printf("%02X ", buffer[i]); + if ((i + 1) % 16 == 0 || i + 1 == size) { + unsigned int start = i / 16 * 16; + if ((i + 1) % 16 != 0) { + printf("%*s", (16 - (i + 1) % 16) * 3, ""); + } + if (debug != 3) { + printf(" "); + for (unsigned int j = start; j <= i; j++) { + printf("%c", (buffer[j] < 32 || + buffer[j] > 126) ? + '.' : + buffer[j]); + } + } + printf("\n"); + } + } + printf("\n"); +} + +// memmem replacement function for Windows +static inline void *memmem_r(const void *haystack, size_t hlen, + const void *needle, size_t nlen) +{ + if (nlen == 0) + return (void *)haystack; + if (hlen < nlen) + return NULL; + + const unsigned char *h = (const unsigned char *)haystack; + const unsigned char *n = (const unsigned char *)needle; + const unsigned char *h_end = h + (hlen - nlen) + 1; + const unsigned char first = n[0]; + + while (h < h_end) { + const unsigned char *p = (const unsigned char *)memchr( + h, first, (size_t)(h_end - h)); + if (!p) + return NULL; + if (memcmp(p, n, nlen) == 0) + return (void *)p; + h = p + 1; + } + return NULL; +} + + +/*================== RPC client functions ==========s========*/ + +// Init WSA +int wsa_init(void) +{ + static LONG wsa_init = 0; + if (InterlockedCompareExchange(&wsa_init, 1, 0) == 0) { + WSADATA w; + if (WSAStartup(MAKEWORD(2, 2), &w)) { + InterlockedExchange(&wsa_init, 0); + printf("WSA initialization error.\n"); + return BR_E_WSA; + } + } + return NO_ERROR; +} + +// Get a socket +static SOCKET get_socket(struct sockaddr_in *out_addr) +{ + SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + if (s == INVALID_SOCKET) + return INVALID_SOCKET; + + DWORD to = 5000; + setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (const char *)&to, sizeof(to)); + setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char *)&to, sizeof(to)); + int one = 1; + setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (const char *)&one, + sizeof(one)); + setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (const char *)&one, + sizeof(one)); + + if (out_addr) { + memset(out_addr, 0, sizeof(*out_addr)); + out_addr->sin_family = AF_INET; + out_addr->sin_port = htons(broker_port); + out_addr->sin_addr.s_addr = htonl(INADDR_LOOPBACK); + } + return s; +} + +// Connect to broker +static int connect_to_broker(int timeout_ms) +{ + struct sockaddr_in addr; + SOCKET sock = get_socket(&addr); + if (sock == INVALID_SOCKET) + return BR_E_SOCK; + + // Set non-blocking I/O socket + u_long nb = 1; + ioctlsocket(sock, FIONBIO, &nb); + + int rc = connect(sock, (struct sockaddr *)&addr, sizeof(addr)); + if (rc == 0) { + closesocket(sock); + return 0; + } + + int err = WSAGetLastError(); + if (err != WSAEWOULDBLOCK && err != WSAEINPROGRESS) { + closesocket(sock); + return BR_E_CONNECT_IMMEDIATE; + } + + fd_set wf; + FD_ZERO(&wf); + FD_SET(sock, &wf); + struct timeval tv; + tv.tv_sec = timeout_ms / 1000; + tv.tv_usec = (timeout_ms % 1000) * 1000; + rc = select((int)sock + 1, NULL, &wf, NULL, &tv); + if (rc == 1) { + int soerr = 0; + int len = sizeof(soerr); + getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&soerr, &len); + closesocket(sock); + return (soerr == 0) ? NO_ERROR : BR_E_CONNECT_SOERR; + } + closesocket(sock); + return BR_E_CONNECT_TIMEOUT; +} + +// Try to connect to broker +int try_connect(DWORD timeout_ms) +{ + DWORD start = GetTickCount(); + DWORD limit = start + timeout_ms; + + // We're already connected, fast exit. + if (InterlockedCompareExchange(&broker_state, BRK_STATE_READY, + BRK_STATE_READY) == BRK_STATE_READY) + return NO_ERROR; + + // Try to become connector thread + LONG prev = InterlockedCompareExchange( + &broker_state, BRK_STATE_CONNECTING, BRK_STATE_INIT); + if (prev != BRK_STATE_INIT) + prev = InterlockedCompareExchange( + &broker_state, BRK_STATE_CONNECTING, BRK_STATE_FAILED); + + // Reset the event so that others threads will wait for this cycle + if (prev == BRK_STATE_INIT || prev == BRK_STATE_FAILED) { + if (broker_evt) + ResetEvent(broker_evt); + + for (;;) { + if (connect_to_broker(200) == 0) { + InterlockedExchange(&broker_state, + BRK_STATE_READY); + if (broker_evt) + SetEvent(broker_evt); + return NO_ERROR; + } + if ((LONG)(GetTickCount() - limit) >= 0) { + InterlockedExchange(&broker_state, + BRK_STATE_FAILED); + if (broker_evt) + SetEvent(broker_evt); + return BRK_E_READY_TIMEOUT; + } + Sleep(100); + } + } + + // Another thread is connecting. Wait for timeout or READY/FAIL + for (;;) { + LONG s = broker_state; + if (s == BRK_STATE_READY) + return NO_ERROR; + if (s == BRK_STATE_FAILED) + return BRK_E_READY_FAILED; + + DWORD now = GetTickCount(); + DWORD left = + (DWORD)((LONG)(limit - now) > 0 ? (limit - now) : 0); + if (left == 0) + return BRK_E_WAIT_TIMEOUT; + + if (broker_evt) { + DWORD wr = WaitForSingleObject(broker_evt, left); + if (wr == WAIT_TIMEOUT) + return BRK_E_WAIT_TIMEOUT; + } else { + Sleep(min(left, 50)); + } + } + return NO_ERROR; +} + +// Reset wait event state if a fatal wsa error detected +void reset_state(void) +{ + InterlockedExchange(&broker_state, BRK_STATE_FAILED); + int e = WSAGetLastError(); + int fatal = (e == WSAECONNREFUSED || e == WSAETIMEDOUT || + e == WSAENETUNREACH || e == WSAEHOSTUNREACH || + e == WSAENETDOWN || e == WSAECONNRESET || + e == WSAESHUTDOWN); + if (fatal && broker_evt) + SetEvent(broker_evt); +} + +// Socket send function +static int socket_send(SOCKET s, const void *buf, int len) +{ + const char *pbuf = (const char *)buf; + int sent = 0; + while (sent < len) { + int n = send(s, pbuf + sent, len - sent, 0); + if (n <= 0) + return RPC_E_SEND_ERR; + sent += n; + } + return NO_ERROR; +} + +// Socket receive function +static int socket_recv(SOCKET s, void *buf, int len) +{ + char *pbuf = (char *)buf; + int recvd = 0; + while (recvd < len) { + int n = recv(s, pbuf + recvd, len - recvd, 0); + if (n <= 0) + return RPC_E_RECV_ERR; + recvd += n; + } + return NO_ERROR; +} + +// RPC call function to USB broker +int rpc_call(uint16_t type, const void *req, uint32_t req_len, + const void *extra, uint32_t extra_len, void *resp_buf, + uint32_t *resp_len) +{ + // Validity check + if (!resp_len) + return RPC_E_RESP_LEN_NULL; + if (*resp_len && !resp_buf) + return RPC_E_RESP_BUF_NULL; + + // Try to connect to broker + int ret = try_connect(3000); + if (ret != 0) + return ret; + + // Get a socket + struct sockaddr_in addr; + SOCKET sock = get_socket(&addr); + if (sock == INVALID_SOCKET) + return RPC_E_MKSOCK_FAIL; + + // Connect to broker + if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) != 0) { + int e = WSAGetLastError(); + reset_state(); + closesocket(sock); + return (e == WSAETIMEDOUT) ? RPC_E_CONNECT_TIMEOUT : + RPC_E_CONNECT_FAIL; + } + + // Send header + rpc_hdr_t snd_hdr; + snd_hdr.len = req_len + extra_len; + snd_hdr.type = type; + snd_hdr.version = PROTO_VERSION; + if (socket_send(sock, &snd_hdr, (int)sizeof(snd_hdr))) { + reset_state(); + closesocket(sock); + return RPC_E_SEND_HEADER; + } + + // Send request + if (req_len && socket_send(sock, req, (int)req_len)) { + closesocket(sock); + return RPC_E_SEND_REQ; + } + + // Send extra data + if (extra_len && socket_send(sock, extra, (int)extra_len)) { + closesocket(sock); + return RPC_E_SEND_EXTRA; + } + + // Receive header + rpc_hdr_t rcv_hdr; + if (socket_recv(sock, &rcv_hdr, (int)sizeof(rcv_hdr))) { + reset_state(); + closesocket(sock); + return RPC_E_RECV_HEADER; + } + + // Check if required protocol version match + if (rcv_hdr.version != PROTO_VERSION) { + reset_state(); + closesocket(sock); + return RPC_E_PROTO_MISMATCH; + } + + // Check for response header length + if (rcv_hdr.len > *resp_len) { + reset_state(); + closesocket(sock); + return RPC_E_RESP_TOO_LARGE; + } + + // Receive payload + if (rcv_hdr.len) { + if (socket_recv(sock, resp_buf, (int)rcv_hdr.len)) { + closesocket(sock); + return RPC_E_RECV_PAYLOAD; + } + } + *resp_len = rcv_hdr.len; + + // Disconect and return + closesocket(sock); + return NO_ERROR; +} + +/*================== Minipro/Xgpro replacement functions =====================*/ + +// USB close replacement function. Called by Xgpro/Minipro +void close_devices(void) +{ + int max = (device_pid == T76_PID) ? 1 : 4; + int any = 0; + for (int i = 0; i < max; i++) { + if (broker_handle[i].handle_id || + usb_handle[i] != INVALID_HANDLE_VALUE) { + any = 1; + break; + } + } + if (!any) + return; + + printf("Close devices\n"); + try_connect(1000); + + for (int i = 0; i < max; i++) { + if (broker_handle[i].handle_id) { + close_req_t q = { .handle_id = + broker_handle[i].handle_id }; + uint8_t rb[32]; + uint32_t rl = sizeof(rb); + rpc_call(MSG_CLOSE, &q, sizeof(q), NULL, 0, rb, &rl); + broker_handle[i].handle_id = 0; + } + } + + for (int i = 0; i < 4; i++) { + usb_handle[i] = INVALID_HANDLE_VALUE; + if (device_vid == TL866II_VID) + winusb_handle[i] = INVALID_HANDLE_VALUE; + } + if (devices_count) + *devices_count = 0; +} + +// USB open replacement function. Called by Xgpro/Minipro +int open_devices(void) +{ + // Close devices first + close_devices(); + + for (int i = 0; i < 2; i++) + for (int j = 0; j < 7; j++) + ep_timeout[i][j] = 5000; + + // Initialize all handles + usb_handle[0] = INVALID_HANDLE_VALUE; + if (device_pid != T76_PID) { + usb_handle[1] = usb_handle[2] = usb_handle[3] = + INVALID_HANDLE_VALUE; + } + + if (device_vid == TL866II_VID) { + *devices_count = 0; + winusb_handle[0] = INVALID_HANDLE_VALUE; + if (device_pid != T76_PID) + winusb_handle[1] = winusb_handle[2] = winusb_handle[3] = + INVALID_HANDLE_VALUE; + } + + // Try to connect to the usb-broker + printf("Open devices:\n"); + if (try_connect(30000) != NO_ERROR) { + printf("Couldn't connect to usb-broker\n"); + return 0; + } + + // Performs an enumerate RPC call to retrieve the USB devices list + static uint8_t resp_buf[16384]; + uint32_t resp_len = sizeof(resp_buf); + int ret = + rpc_call(MSG_ENUMERATE, NULL, 0, NULL, 0, resp_buf, &resp_len); + if (ret != 0 || resp_len < sizeof(enum_resp_t)) { + printf("ENUM rpc_call failed rc=%d len=%u\n", ret, resp_len); + return 0; + } + + const enum_resp_t *enum_resp = (const enum_resp_t *)resp_buf; + if (enum_resp->status != 0) { + printf("ENUM status=%d\n", (int)enum_resp->status); + return 0; + } + + const uint8_t *p_list = resp_buf + sizeof(enum_resp_t); + size_t left = resp_len - sizeof(enum_resp_t); + uint32_t count = enum_resp->count; + if (left < count * sizeof(dev_info_t)) { + printf("ENUM payload too short: count=%u payload=%zu need=%zu\n", + count, left, (size_t)count * sizeof(dev_info_t)); + return 0; + } + + const dev_info_t *list = (const dev_info_t *)p_list; + int max_devices = (device_pid == T76_PID) ? 1 : 4; + int devices_found = 0; + + // Loop through all devices in the list and parse each entry + for (uint32_t i = 0; i < count; i++) { + const dev_info_t *dev_info = &list[i]; + + // If not our required VID/PID skip + if (!(dev_info->vid == device_vid && + dev_info->pid == device_pid)) + continue; + + // We found a device, lets try to open it + open_req_t open_req; + memset(&open_req, 0, sizeof(open_req)); + snprintf(open_req.path, sizeof(open_req.path), "%.*s", + (int)sizeof(open_req.path) - 1, dev_info->path); + + uint8_t out_buf[256]; + uint32_t out_len = sizeof(out_buf); + ret = rpc_call(MSG_OPEN, &open_req, sizeof(open_req), NULL, 0, + out_buf, &out_len); + if (ret != 0 || out_len < sizeof(open_resp_t)) { + printf("OPEN rpc_call failed rc=%d len=%u\n", ret, + out_len); + continue; + } + const open_resp_t *open_resp = (const open_resp_t *)out_buf; + if (open_resp->status != 0) { + printf("Device %s %s\n", dev_info->path, + (int)open_resp->status == RPC_E_OPEN_BUSY ? + "busy." : + "open error."); + continue; + } + + // If device was succesfully open initialize its handle + int idx = devices_found; + broker_handle[idx].handle_id = open_resp->handle_id; + usb_handle[idx] = (HANDLE)idx; + if (device_vid == TL866II_VID) { + winusb_handle[idx] = (HANDLE)idx; + *devices_count = idx + 1; + } + + // Save wMaxPacketSize for later + memcpy(broker_handle[idx].wMaxPacketSize, + dev_info->wMaxPacketSize, + sizeof(dev_info->wMaxPacketSize)); + + // Format the device name + char name[128] = { 0 }; + if (open_resp->product[0]) { + snprintf(name, sizeof(name), "%.*s", + (int)sizeof(name) - 1, open_resp->product); + } else { + strcpy(name, "Unknown"); + } + if (strstr(name, "Xingong")) + strcpy(name, "XGecu TL866II+"); + else if (strstr(name, "MiniPro")) + strcpy(name, "Minipro TL866A/CS"); + char *end = name + strlen(name) - 1; + while (end >= name && isspace((unsigned char)*end)) + *end-- = '\0'; + + // Format the device speed + const char *speed = ""; + switch (open_resp->speed) { + case 1: + speed = "Low speed (1.5MBit/s)"; + break; + case 2: + speed = "Full speed (12MBit/s)"; + break; + case 3: + speed = "High speed (480MBit/s)"; + break; + case 4: + speed = "Super speed (5000MBit/s)"; + } + + // Print the device name and speed + devices_found++; + printf(" %u: VID_%04X, PID_%04X; %s; %s\n", + devices_found, dev_info->vid, dev_info->pid, name, + speed); + + // Limit the maximum devices to 4 or 1 + if (devices_found == max_devices) + break; + } + + if(!devices_found) + printf("No devices found.\n"); + return 0; +} + +// Helper function to get a pipe timeout +int get_timeout(UCHAR PipeID) +{ + return ep_timeout[(PipeID > 80 ? 1 : 0)][(PipeID & 0x7f) - 1]; +} + +// Helper function to set a pipe timeout +void set_timeout(UCHAR PipeID, int val) +{ + ep_timeout[(PipeID > 80 ? 1 : 0)][(PipeID & 0x7f) - 1] = val; +} + +// Helper function to get wMaxPacketSize for a specified device +static inline int get_mps(int idx, unsigned char pipeId) +{ + unsigned epnum = (unsigned)(pipeId & 0x0F); + if (idx < 0 || idx >= 4 || epnum >= 16) + return 0; + return (int)broker_handle[idx].wMaxPacketSize[epnum]; +} + +// Helper function to get USB error string +static const char *usb_errstr(int code) +{ + switch (code) { + case 0: return "Success"; + case -1: return "Input/Output Error"; + case -2: return "Invalid parameter"; + case -3: return "Access denied"; + case -4: return "No such device"; + case -5: return "Entity not found"; + case -6: return "Resource busy"; + case -7: return "Operation timed out"; + case -8: return "Overflow"; + case -9: return "Pipe error"; + case -10: return "System call interrupted"; + case -11: return "Insufficient memory"; + case -12: return "Operation not supported"; + default: return "Unknown error"; + } +} + + +/*============= Xgpro replacement functions. ==============*/ + +// USB transfer for WinUsb_ReadPipe/WinUsb_WritePipe. +// This function will run in a separate thread if overlapped +// transfer is specified. +void usb_transfer(Args *args) +{ + // Submit the bulk transfer to the broker + { + int idx = (int)(uintptr_t)args->handle; + if (idx < 0 || idx > 3 || broker_handle[idx].handle_id == 0) { + printf("\nIO error: %s\n", usb_errstr(-4)); + free(args); + return; + } + + const int ep_in = (args->PipeID & 0x80) ? 1 : 0; + bulk_req_t req; + memset(&req, 0, sizeof(req)); + req.handle_id = broker_handle[idx].handle_id; + req.ep = args->PipeID; + req.timeout_ms = get_timeout(args->PipeID); + req.len = args->BufferLength; + + // Response buffer: for IN we need space for data + uint32_t rcap = (uint32_t)(sizeof(bulk_resp_t) + + (ep_in ? args->BufferLength : 0)); + uint8_t *rbuf = (uint8_t *)malloc(rcap ? rcap : 1); + if (!rbuf) { + printf("Out of memory!\n"); + free(args); + return; + } + + uint32_t rlen = rcap; + const void *extra = ep_in ? NULL : (const void *)args->Buffer; + uint32_t xlen = ep_in ? 0 : args->BufferLength; + + int ret = rpc_call(MSG_BULK, &req, sizeof(req), extra, xlen, + rbuf, &rlen); + if (ret != 0 || rlen < sizeof(bulk_resp_t)) { + printf("\nIO error: %s\n", usb_errstr(ret ? -1 : -11)); + free(rbuf); + free(args); + return; + } + + const bulk_resp_t *resp = (const bulk_resp_t *)rbuf; + + // Check if transfer was okay + if (resp->status != 0) { + printf("\nIO Error: %s\n", usb_errstr(resp->status)); + free(rbuf); + free(args); + return; + } + + // Get the actual transfer length + if (ep_in) { + uint32_t rcvd = resp->rx_len; + if (rcvd && args->Buffer) { + const uint8_t *data = + rbuf + sizeof(bulk_resp_t); + if (rcvd > args->BufferLength) + rcvd = args->BufferLength; + memcpy(args->Buffer, data, rcvd); + } + *args->LengthTransferred = rcvd; + } else { + *args->LengthTransferred = args->BufferLength; + } + + // Free the allocated transfer structure + free(rbuf); + } + + // If debug mode is active print some debug info + if (debug) { + printf("%s %s %u bytes on endpoint 0x%02X\n", + (args->PipeID & 0x80) ? "Read" : "Write", + args->Overlapped ? "Async" : "Normal", + *args->LengthTransferred, args->PipeID); + if (debug == 1 || debug == 3) { + print_hex(args->Buffer, *args->LengthTransferred); + } + } + + // If Overlapped (async) transfer was completed + // signal the event to release the waiting object. + if (args->Overlapped) { + SetEvent(args->Overlapped->hEvent); + } + + // Free the malloced args. + free(args); +} + +/********************** ENDPOINTS USAGE ******************************** + *********************************************************************** + * TL866A/CS; wMaxPacketSize=64 bytes, 2 endpoints; USB 2.0, 12MBit/s * + * EP1_OUT=0x01, EP1_IN=0x81; All used * + *********************************************************************** + * TL866II+; wMaxPacketSize=64 bytes, 6 endpoints; USB 2.0, 12MBit/s * + * EP1_OUT=0x01, EP1_IN=0x81, EP2_OUT=0x02, EP2_IN=0x82, * + * EP3_OUT=0x03, EP3_IN=0x83; All used * + *********************************************************************** + * T48; wMaxPacketSize=512 bytes, 4 endpoints; USB 2.0, 480MBit/s * + * EP1_OUT=0x01, EP1_IN=0x81, EP2_OUT=0x02, EP2_IN=0x82; All used * + *********************************************************************** + * T56 wMaxPacketSize = 512 bytes, 2 endpoints; USB 2.0, 480MBit/s * + * EP1_OUT=0x01, EP1_IN=0x81; All used * + *********************************************************************** + * T76 wMaxPacketSize = 1024 bytes, 14 endpoints; USB 3.0, 5000MBit/s * + * EP1_OUT=0x01, EP1_IN=0x81, EP2_OUT=0x02, EP2_IN=0x82, * + * EP3_OUT=0x03, EP3_IN=0x83, EP4_OUT=0x04, EP4_IN=0x84, * + * EP5_OUT=0x05, EP5_IN=0x85, EP6_OUT=0x06, EP6_IN=0x86 * + * EP7_OUT=0x07, EP7_IN=0x87; * + * Only EP1_OUT, EP1_IN, EP2_IN, EP5_OUT are used in current firmware * + ***********************************************************************/ + +// WinUsb_ReadPipe/winUsb_WritePipe implementation. +BOOL WINAPI WinUsb_Transfer(HANDLE InterfaceHandle, UCHAR PipeID, PUCHAR Buffer, + ULONG BufferLength, PUINT LengthTransferred, + LPOVERLAPPED Overlapped) +{ + // Check for usb handles + int idx = (int)(uintptr_t)InterfaceHandle; + if (idx < 0 || idx > 3 || broker_handle[idx].handle_id == 0) { + printf("\nIO error: %s\n", usb_errstr(-4)); + return FALSE; + } + + // Workaround for T76 endpoint 0x83 not used issue. + // The Xgecu T76 software will issue a Winusb_ReadPipe on + // endpoint 0x83 and later on will call WinUSB_AbortPipe. + // Because the T76 firmware doesn't use endpoint 0x83 this will + // get us a libusb timeout error and the Xgpro software locked + // waiting for 'Overlapped->hEvent' to be signaled. + // This will throw an error in Xgpro T76 and the programmer power + // must be cycled. + // We handle this bug here by releasing the waiting object first + // and then aborting the transfer on this endpoint. + if (device_pid == T76_PID && PipeID == 0x83) { + if (Overlapped != NULL) { + SetEvent(Overlapped->hEvent); + } + return TRUE; + } + + // Workaround for Xgpro read BufferLength issue. + // Depending on what chip is used we can get more bytes than + // declared by the Xgpro software in 'BufferLength' argument; + // so if the BufferLength < LengthTransferred we end with a libusb + // overflow error (there is more unread data). + // Perhaps the Windows driver handle this somewhat (multiple reads + // or bigger buffers). We handle this by rounding the buffer size + // in multiple of wMaxPacketSize bytes (64, 512 or 1024). + + if ((PipeID > 0x80)) { + // Round BufferLength to the next multiple of endpoint wMaxPacketSize + int wMaxPacketSize = get_mps(idx, PipeID) - 1; + BufferLength = (BufferLength + wMaxPacketSize) & + ~wMaxPacketSize; + } + + // Prepare args + Args *args = malloc(sizeof(Args)); + if (!args) { + printf("Out of memory!\n"); + return FALSE; + } + + *args = (Args){ .handle = InterfaceHandle, + .PipeID = PipeID, + .Buffer = Buffer, + .BufferLength = BufferLength, + .LengthTransferred = LengthTransferred, + .Overlapped = Overlapped }; + + // If an overlapped (async) transfer is needed then create a + // new thread and return immediately. + if (Overlapped != NULL) { + ResetEvent(Overlapped->hEvent); + CreateThread(NULL, 0, (void *)usb_transfer, args, 0, NULL); + return TRUE; + } else { + // Just a synchronous transfer is needed; + usb_transfer(args); + } + + return TRUE; +} + +// WinUsb_SetPipePolicy implementation. +// Only setting pipe timeout is supported +BOOL WINAPI WinUsb_SetPipePolicy(HANDLE InterfaceHandle, UCHAR PipeID, + ULONG PolicyType, ULONG ValueLength, + PVOID Value) +{ + if (PolicyType == 0x03) { + set_timeout(PipeID, *(int *)Value); + } + return TRUE; +} + +// WinUsb_AbortPipe implementation +BOOL WINAPI WinUsb_AbortPipe(HANDLE InterfaceHandle, UCHAR PipeID) +{ + return TRUE; +} + +// WinUsb unused but stubbbed functions. +BOOL WINAPI WinUsb_FlushPipe(HANDLE InterfaceHandle, UCHAR PipeID) +{ + return TRUE; +} + +BOOL WINAPI WinUsb_Initialize(HANDLE DeviceHandle, PVOID *InterfaceHandle) +{ + return TRUE; +} + +BOOL WINAPI WinUsb_Free(HANDLE InterfaceHandle) +{ + return TRUE; +} + + +/*============ Minipro replacement functions ==============*/ + +// USB read implementation. Use the WinUsb_Transfer above +int uread(HANDLE hDevice, unsigned char *data, unsigned int size) +{ + int transferred = 0; + set_timeout(0x80 | 1, 20000); + BOOL ret = WinUsb_Transfer(hDevice, 0x80 | 1, data, size, + (unsigned *)&transferred, NULL); + return (ret ? transferred : -1); +} + +// USB write implementation. Use the WinUsb_Transfer above +BOOL uwrite(HANDLE hDevice, unsigned char *data, size_t size) +{ + int transferred = 0; + set_timeout(0x00 | 1, 20000); + return WinUsb_Transfer(hDevice, 0x00 | 1, data, size, + (unsigned *)&transferred, NULL); +} + +// USB write to device zero +BOOL usb_write(unsigned char *lpInBuffer, unsigned int nInBufferSize) +{ + return uwrite(0, lpInBuffer, nInBufferSize); +} + +// USB read from device zero +int usb_read(unsigned char *lpOutBuffer, unsigned int nBytesToRead, + unsigned int nOutBufferSize) +{ + int ret = uread(0, lpOutBuffer, nBytesToRead); + if (ret == -1) + MessageBox(GetForegroundWindow(), "Read error!", "TL866", + MB_ICONWARNING); + return ret; +} + +// USB write to specified device +BOOL usb_write2(HANDLE hDevice, unsigned char *lpInBuffer, + unsigned int nInBufferSize) +{ + return uwrite(hDevice, lpInBuffer, nInBufferSize); +} + +// USB read from specified device +int usb_read2(HANDLE hDevice, unsigned char *lpOutBuffer, + unsigned int nBytesToRead, unsigned int nOutBufferSize) +{ + return uread(hDevice, lpOutBuffer, nBytesToRead); +} + + +/*=========== Program extension section ==================*/ + +#define WM_ADD_TOOLS_MENU (WM_APP + 1) +static const char *GitHubUrl = "https://github.com/radiomanV/TL866/tree/master/wine64"; + +// About dialog +static INT_PTR CALLBACK AboutDlgProc(HWND hDlg, UINT msg, WPARAM wParam, + LPARAM lParam) +{ + static HFONT hFontLinkU = NULL; + static HCURSOR hCursorHand = NULL; + switch (msg) { + case WM_INITDIALOG: { + + // Set hand Cursor + HWND hLink = GetDlgItem(hDlg, IDC_SHIM_LINK); + if (!hCursorHand) { + HCURSOR h = LoadCursorA(NULL, IDC_HAND); + hCursorHand = h ? h : LoadCursorA(NULL, IDC_ARROW); + } + SetClassLongPtrW(hLink, GCLP_HCURSOR, (LONG_PTR)hCursorHand); + + // Set underline font + HFONT hBase = (HFONT)SendMessageA(hDlg, WM_GETFONT, 0, 0); + if (!hBase) + hBase = (HFONT)GetStockObject(DEFAULT_GUI_FONT); + LOGFONT lf = { 0 }; + GetObjectA(hBase, sizeof(lf), &lf); + lf.lfUnderline = TRUE; + hFontLinkU = CreateFontIndirectA(&lf); + + // Set version string + char buf[256]; + if (LoadString(m_hInst, IDS_SHIM_VERSION, buf, 256) && buf[0]) { + SetDlgItemText(hDlg, IDS_SHIM_VERSION, buf); + } + + // Set GitHub link + _snprintf(buf, sizeof(buf), "GitHub: %s", GitHubUrl); + SetDlgItemTextA(hDlg, IDC_SHIM_LINK, buf); + return TRUE; + } + + case WM_CTLCOLORSTATIC: { + HWND hCtrl = (HWND)lParam; + if (GetDlgCtrlID(hCtrl) == IDC_SHIM_LINK) { + HDC hdc = (HDC)wParam; + SetTextColor(hdc, RGB(0, 0, 238)); + SetBkMode(hdc, TRANSPARENT); + return (INT_PTR)GetStockObject(NULL_BRUSH); + } + break; + } + + case WM_COMMAND: + if (LOWORD(wParam) == IDC_SHIM_LINK && + HIWORD(wParam) == STN_CLICKED) { + ShellExecuteA(hDlg, "open", GitHubUrl, NULL, NULL, + SW_SHOWNORMAL); + InvalidateRect(GetDlgItem(hDlg, IDC_SHIM_LINK), NULL, + TRUE); + return TRUE; + } + + if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) { + EndDialog(hDlg, LOWORD(wParam)); + return TRUE; + } + break; + + case WM_DESTROY: + if (hFontLinkU) { + DeleteObject(hFontLinkU); + hFontLinkU = NULL; + } + break; + } + return FALSE; +} + +// WindowProc subclassing +LRESULT CALLBACK ShimWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + // Intercept program close + switch (msg) { + + // Add Shim menu + case WM_ADD_TOOLS_MENU: { + HMENU hMain = GetMenu(hwnd); + HMENU hShim = CreatePopupMenu(); + InsertMenuA(hShim, 0, MF_BYPOSITION | MF_STRING, IDM_SHIM_ABOUT, + "About USB wrapper..."); + int topCount = GetMenuItemCount(hMain); + InsertMenuA(hMain, topCount, MF_BYPOSITION | MF_POPUP, + (UINT_PTR)hShim, "Shim(&W)"); + DrawMenuBar(hwnd); + return 0; + } + + // Intercept menu item click + case WM_COMMAND: { + UINT id = LOWORD(wParam); + if (id == IDM_SHIM_ABOUT) { + DialogBoxParamA(m_hInst, + MAKEINTRESOURCE(IDD_SHIM_ABOUTBOX), + hwnd, AboutDlgProc, 0); + return 0; + } + break; + } + + case WM_NCDESTROY: { + LRESULT r = CallWindowProcA(prev_wndproc, hwnd, msg, wParam, + lParam); + SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)prev_wndproc); + prev_wndproc = NULL; + return r; + } + + case WM_QUERYENDSESSION: + case WM_ENDSESSION: + case WM_CLOSE: + case WM_DESTROY: + ShowWindow(hwnd, 0); + if (cancel_evt) { + SetEvent(cancel_evt); + } + if (hotplug_thread) { + WaitForSingleObject(hotplug_thread, 5000); + CloseHandle(hotplug_thread); + CloseHandle(cancel_evt); + cancel_evt = NULL; + hotplug_thread = NULL; + } + break; + } + + // Call old windowproc + return CallWindowProcA(prev_wndproc, hwnd, msg, wParam, lParam); +} + +/*=========== USB Hotplug detection section ==================*/ + +// Notifier function. This will force the software to rescan devices. +void device_changed(unsigned int event) +{ + // Initialize the device broadcast interface + DEV_BROADCAST_DEVICEINTERFACE_W DevBi; + DevBi.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE_W); + DevBi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE; + DevBi.dbcc_classguid = m_guid; + + // Close all devices + close_devices(); + Sleep(100); + + // Broadcast a device change message + SendMessage(hWnd_notify, WM_DEVICECHANGE, event, (LPARAM)&DevBi); + Sleep(100); + + // Force software to refresh the GUI + RedrawWindow(hWnd_notify, NULL, NULL, RDW_INVALIDATE); +} + +// Hotplug USB monitoring thread +DWORD WINAPI notifier_thread(LPVOID unused) +{ + // Open a persistent event channel to the broker + struct sockaddr_in a; + SOCKET sock = get_socket(&a); + if (sock == INVALID_SOCKET || + connect(sock, (struct sockaddr *)&a, sizeof(a)) != 0) { + if (sock != INVALID_SOCKET) { + closesocket(sock); + } + printf("USB broker hotplug callback error.\n"); + SendMessage(hWnd_notify, WM_CLOSE, 0, 0); + return EXIT_FAILURE; + } + + rpc_hdr_t hdr = { 0 }; + hotplug_sub_req_t req = { 0 }; + req.vid = (uint16_t)device_vid; + req.pid = (uint16_t)device_pid; + hdr.type = MSG_HOTPLUG_SUB; + hdr.version = PROTO_VERSION; + hdr.len = (uint32_t)sizeof(req); + + if (socket_send(sock, &hdr, sizeof(hdr)) != 0 || + socket_send(sock, &req, sizeof(req)) != 0) { + printf("USB broker hotplug callback error.\n"); + closesocket(sock); + SendMessage(hWnd_notify, WM_CLOSE, 0, 0); + return EXIT_FAILURE; + } + + printf("\nSubscribed to USB broker hotplug events.\n\n"); + + // Enter the monitoring thread and handle hotplug events. + int rc = EXIT_FAILURE; + for (;;) { + // Exit if cancel event is signaled + if (WaitForSingleObject(cancel_evt, 50) == WAIT_OBJECT_0) { + rc = EXIT_SUCCESS; + break; + } + + fd_set rf, xf; + FD_ZERO(&rf); + FD_ZERO(&xf); + FD_SET(sock, &rf); + FD_SET(sock, &xf); + + struct timeval tv; + tv.tv_sec = 3; + tv.tv_usec = 0; + int r = select((int)sock + 1, &rf, NULL, NULL, &tv); + if (r == 0) + continue; + if (r < 0) { + int e = WSAGetLastError(); + if (e == WSAEWOULDBLOCK || e == WSAEINTR) + continue; + break; + } + + rpc_hdr_t evh; + if (socket_recv(sock, &evh, sizeof(evh)) != 0) + break; + + if (evh.version != PROTO_VERSION) + continue; + if (evh.type != MSG_HOTPLUG_EVT) { + if (evh.len) { + char buf[256]; + int read_len = (int)((evh.len <= sizeof(buf)) ? + evh.len : + sizeof(buf)); + socket_recv(sock, buf, read_len); + } + continue; + } + + // Receive hotplug event + hotplug_evt_t evt; + if (evh.len != sizeof(evt)) { + if (evh.len) { + char dump[256]; + int to_read = (int)((evh.len <= sizeof(dump)) ? + evh.len : + sizeof(dump)); + socket_recv(sock, dump, to_read); + } + continue; + } + + // Exit thread if error + if (socket_recv(sock, &evt, sizeof(evt)) != 0) + break; + + // Compare VID/PID and send the device_changed event + if (evt.vid == device_vid && evt.pid == device_pid) { + device_changed(evt.arrived ? DBT_DEVICEARRIVAL : + DBT_DEVICEREMOVECOMPLETE); + } + } + + // Exit from notifier thread + printf("USB hotplug monitoring thread terminated.\n"); + closesocket(sock); + if (rc) + SendMessage(hWnd_notify, WM_CLOSE, 0, 0); + return rc; +} + +// RegisterDeviceNotifications WINAPI replacement +HANDLE WINAPI RegisterDeviceNotifications(HWND hwnd, LPVOID NotificationFilter, + DWORD Flags) +{ + // Initialize cancel event + cancel_evt = CreateEventA(NULL, TRUE, FALSE, NULL); + + // Subclass WindowProc + hWnd_notify = hwnd; + if (IsWindow(hwnd) && !prev_wndproc) { + SetLastError(0); + LONG_PTR prev = SetWindowLongPtrA(hwnd, GWLP_WNDPROC, + (LONG_PTR)ShimWndProc); + if (prev) { + prev_wndproc = (WNDPROC)prev; + PostMessageA(hwnd, WM_ADD_TOOLS_MENU, 0, 0); + } else if (GetLastError() != 0) + printf("Subclass failed.\n"); + } + + // Create notifier thread + HANDLE h = CreateThread(NULL, 0, notifier_thread, NULL, 0, NULL); + if (!h) { + printf("Failed to create the hotplug monitoring thread!\n"); + return 0; + } + + hotplug_thread = h; + return 0; +} + +/*================== Patcher functions ==================*/ + +// Inline helper patcher functions. +static inline void patch(void *src, void *dest) +{ + // push xxxx, ret; an absolute Jump replacement. + *(BYTE *)src = X86_PUSH; + *((DWORD *)((BYTE *)src + 1)) = (DWORD)dest; + *((BYTE *)src + 5) = X86_RET; +} + +static inline uint32_t read_le32(const void *p) +{ + uint32_t v; + memcpy(&v, p, sizeof(v)); + return v; +} + +static inline void *rel32_target(const void *instr, size_t disp_off, + size_t next_off) +{ + const uint8_t *ip = (const uint8_t *)instr; + int32_t rel = (int32_t)read_le32(ip + disp_off); + uintptr_t next = (uintptr_t)(ip + next_off); + return (void *)(next + (intptr_t)rel); +} + +static inline void *abs32_imm(const void *instr, size_t imm_off) +{ + return (void *)(uintptr_t)read_le32((const uint8_t *)instr + imm_off); +} + +// Find signature +static inline uint8_t *find_sig(const uint8_t *code, size_t code_sz, + const void *pat, size_t pat_sz, ptrdiff_t disp) +{ + uint8_t *p = (uint8_t *)memmem_r(code, code_sz, pat, pat_sz); + return p ? (p + disp) : NULL; +} + +// Dll redirect patch function +BOOL patch_function(char *library, char *func_name, void *custom_func) +{ + DWORD dwOldProtection; + DWORD func_addr = 0; + + void *BaseAddress = GetModuleHandle(NULL); + PIMAGE_NT_HEADERS NtHeader = + (PIMAGE_NT_HEADERS)((PBYTE)BaseAddress + + ((PIMAGE_DOS_HEADER)BaseAddress)->e_lfanew); + PIMAGE_IMPORT_DESCRIPTOR ImpDesc = + (PIMAGE_IMPORT_DESCRIPTOR)((PBYTE)BaseAddress + + NtHeader->OptionalHeader + .DataDirectory + [IMAGE_DIRECTORY_ENTRY_IMPORT] + .VirtualAddress); + + // Search for library in the import directory + while (ImpDesc->Characteristics && ImpDesc->Name) { + if (strcasecmp(BaseAddress + ImpDesc->Name, library) == 0) { + break; // Found it! + } + ImpDesc++; + } + + // check if the library was found in the import directory + if (!ImpDesc->Characteristics) { + printf("Library '%s' was not found in the import directory.\n", + library); + return FALSE; + } + + // If the desired library was found we can get the function address + DWORD_PTR ProcAddress = + (DWORD_PTR)GetProcAddress(GetModuleHandle(library), func_name); + + // Check if the desired function address was found + if (!ProcAddress) { + printf("Function '%s' was not found in '%s' library.\n", + func_name, library); + return FALSE; + } + + // We have the address, let's search it in the thunk table + PIMAGE_THUNK_DATA thunk = + (PIMAGE_THUNK_DATA)(BaseAddress + ImpDesc->FirstThunk); + while (thunk->u1.Function) { + if ((DWORD_PTR)thunk->u1.Function == ProcAddress) { + // if an entry is found, patch it to point to our custom function + MEMORY_BASIC_INFORMATION info; + VirtualQuery(&thunk->u1.Function, &info, + sizeof(MEMORY_BASIC_INFORMATION)); + VirtualProtect(info.BaseAddress, info.RegionSize, + PAGE_READWRITE, &dwOldProtection); + func_addr = thunk->u1.Function; + thunk->u1.Function = (DWORD_PTR)custom_func; + VirtualProtect(info.BaseAddress, info.RegionSize, + info.Protect, &dwOldProtection); + } + thunk++; + } + + // check if the patch was ok. + if (!func_addr) { + printf("Function '%s' was not found in the IAT thunk table.\n", + func_name); + return FALSE; + } + return TRUE; +} + +/* Xgpro patcher function. Called from DllMain. + * Returns TRUE if patch was ok and continue with + * program loading or FALSE to exit with error. + */ +BOOL patch_xgpro() +{ + // Get the BaseAddress, NT Header and Image Import Descriptor + void *base_address = GetModuleHandle(NULL); + PIMAGE_NT_HEADERS ntheader = + (PIMAGE_NT_HEADERS)((PBYTE)base_address + + ((PIMAGE_DOS_HEADER)base_address)->e_lfanew); + + // Search for version and set the Xgpro GUID and VID/PID + unsigned char *version; + if ((version = memmem_r(base_address, + ntheader->OptionalHeader.SizeOfImage, "Xgpro v", + 7))) { + // TL866II+, T48, T56 VID/PID and interface GUID + device_vid = TL866II_VID; + device_pid = TL866II_PID; + memcpy(&m_guid, &XGPRO_GUID1, sizeof(GUID)); + } else if ((version = memmem_r(base_address, + ntheader->OptionalHeader.SizeOfImage, + "Xgpro T76 v", 11))) { + // T76 VID/PID and interface GUID + device_vid = T76_VID; + device_pid = T76_PID; + memcpy(&m_guid, &XGPRO_GUID2, sizeof(GUID)); + } else { + return FALSE; + } + printf("Found %s\n", version); + + // Patch the Linux incompatible functions + if (!patch_function("user32.dll", "RegisterDeviceNotificationA", + &RegisterDeviceNotifications)) + return FALSE; + + if (!patch_function("winusb.dll", "WinUsb_SetPipePolicy", + &WinUsb_SetPipePolicy)) + return FALSE; + + if (!patch_function("winusb.dll", "WinUsb_WritePipe", &WinUsb_Transfer)) + return FALSE; + + if (!patch_function("winusb.dll", "WinUsb_ReadPipe", &WinUsb_Transfer)) + return FALSE; + + if (!patch_function("winusb.dll", "WinUsb_Initialize", + &WinUsb_Initialize)) + return FALSE; + + if (!patch_function("winusb.dll", "WinUsb_Free", &WinUsb_Free)) + return FALSE; + + // Searching for functions signature in code section. + void *p_opendevices = NULL; + void *p_closedevices = NULL; + void *p_winusbhandle = NULL; + void *p_usbhandle = NULL; + void *p_devicescount = NULL; + + const uint8_t *code = (const uint8_t *)base_address + + ntheader->OptionalHeader.BaseOfCode; + size_t code_sz = ntheader->OptionalHeader.SizeOfCode; + + // Search for open_device function pattern 1 (xgpro < V12.7x) + uint8_t *p_od1 = find_sig(code, code_sz, &xgpro_open_devices_pattern1, + sizeof(xgpro_open_devices_pattern1), 0); + + // Search for open_device function pattern 2 (xgpro > V12.7x) + uint8_t *p_od2 = find_sig(code, code_sz, &xgpro_open_devices_pattern2, + sizeof(xgpro_open_devices_pattern2), 0); + + // If we obtained the most important function address (open_devices) then, + // we can also calculate the other necessary addresses. + // Basically we need two function pointers (open_devices and close_devices) + // which are invoked by Minipro/Xgpro when the program is started/closed + // or a device is attached or dettached. + // + // We also need three data pointers: + // 1. usb_handle which is used in both Minipro and Xgpro as a handle to a + // device obtained by calling the CreateFile API. This is actually an array of + // four pointers which in windows holds a handle to the newly opened device or + // an invalid handle value. As we redirect the open/close usb functions we + // initialize each item with an index (0 to 3) or the INVALID_HANDLE_VALUE + // (0xffffffff) if the coresponding device is not found. + // + // 2. winusb_handle used only in Xgpro because Xgpro uses the WinUsb library + // for USB communications. Like the usb_handle this is actually an array of + // four pointers which are initialized with an index (0 to 3) or the invalid + // handle value in our custom open_devices function. + // + // 3. devices_count which is used only by Xgpro to know how many devices are + // available. The Minipro and Xgpro can handle up to four devices while the + // Xgpro_T76 software can handle only one programmer at this time. + + if (p_od1) { + uint8_t *open = (uint8_t *)p_od1 - 0x1D; + p_opendevices = (void *)open; + p_closedevices = rel32_target(open, 5, 9); + p_winusbhandle = abs32_imm(p_closedevices, 0x12); + p_usbhandle = abs32_imm(p_closedevices, 0x02); + p_devicescount = abs32_imm(open, 0xAF); + } else if (p_od2) { + uint8_t *open = (uint8_t *)p_od2 - 0x41; + p_opendevices = (void *)open; + p_closedevices = rel32_target(open, 8, 12); + p_winusbhandle = abs32_imm(p_closedevices, 0x12); + p_usbhandle = abs32_imm(p_closedevices, 0x02); + p_devicescount = abs32_imm(open, 0x28); + if (!patch_function("winusb.dll", "WinUsb_AbortPipe", + &WinUsb_AbortPipe)) + return FALSE; + + if (!patch_function("winusb.dll", "WinUsb_FlushPipe", + &WinUsb_FlushPipe)) + return FALSE; + } else { + printf("Function signatures not found! Unsupported Xgpro version.\n"); + return FALSE; + } + + // Print debug info. + printf("Base Address = 0x%p\n", base_address); + printf("Code section = 0x%p, 0x%lx\n", + base_address + ntheader->OptionalHeader.BaseOfCode, + (DWORD)ntheader->OptionalHeader.SizeOfCode); + printf("Open Devices found at 0x%p\n", p_opendevices); + printf("Close Devices found at 0x%p\n", p_closedevices); + printf("Usb Handle found at 0x%p\n", p_usbhandle); + printf("WinUsb Handle found at 0x%p\n", p_winusbhandle); + printf("Devices count found at 0x%p\n", p_devicescount); + + // Patch all low level functions in Xgpro.exe to point to our custom + // functions. + DWORD dwOldProtection; + + // Initialize the usb_handle, winusb_handle and devices_count pointers + // These variables are used by Xgpro to handle all opened devices + usb_handle = p_usbhandle; + winusb_handle = p_winusbhandle; + devices_count = p_devicescount; + + // Now this is the actual code patch. So we need to patch the code + // to redirect the open_devices/close_devices functions to our custom + // functions. The patch is done by inserting an absolute jump at the + // desired adress. To do this we need first to change the READ_ONLY + // attribute of the code section, patch the desired address and then + // restore the old READ_ONLY attribute. + // So, we have a self modifying code here. + + // Unprotect the code memory section (make it writable) + VirtualProtect(base_address + ntheader->OptionalHeader.BaseOfCode, + ntheader->OptionalHeader.SizeOfCode, PAGE_READWRITE, + &dwOldProtection); + + // patch open_devices function to point to our implementation + patch(p_opendevices, &open_devices); + + // patch close_devices function to point to our implementation + patch(p_closedevices, &close_devices); + + // restore the old READ_ONLY protection + VirtualProtect(base_address + ntheader->OptionalHeader.BaseOfCode, + ntheader->OptionalHeader.SizeOfCode, dwOldProtection, + &dwOldProtection); + return TRUE; +} + +/* Minipro patcher function. Called from DllMain. + * Returns TRUE if patch was ok and continue with + * program loading or FALSE to exit with error. + */ +BOOL patch_minipro() +{ + // Get the BaseAddress, NT Header and Image Import Descriptor + void *BaseAddress = GetModuleHandle(NULL); + PIMAGE_NT_HEADERS NtHeader = + (PIMAGE_NT_HEADERS)((PBYTE)BaseAddress + + ((PIMAGE_DOS_HEADER)BaseAddress)->e_lfanew); + + unsigned char *version = memmem_r(BaseAddress, + NtHeader->OptionalHeader.SizeOfImage, + "MiniPro v", 9); + if (!version) + return FALSE; + printf("Found %s\n", version); + + // Patch the Linux incompatible functions functions + if (!patch_function("user32.dll", "RegisterDeviceNotificationA", + &RegisterDeviceNotifications)) + return FALSE; + + // Searching for functions signature in code section. + const uint8_t *code = (const uint8_t *)BaseAddress + + NtHeader->OptionalHeader.BaseOfCode; + size_t code_sz = NtHeader->OptionalHeader.SizeOfCode; + uint8_t *p_opendevices = + find_sig(code, code_sz, &minipro_open_devices_pattern, + sizeof(minipro_open_devices_pattern), -0x28); + void *p_closedevices = rel32_target(p_opendevices, 4, 8); + uint8_t *p_usbwrite = find_sig(code, code_sz, &usb_write_pattern, + sizeof(usb_write_pattern), -0x0A); + uint8_t *p_usbwrite2 = find_sig(code, code_sz, &usb_write2_pattern, + sizeof(usb_write2_pattern), -0x0A); + uint8_t *p_usbread = find_sig(code, code_sz, &usb_read_pattern, + sizeof(usb_read_pattern), 0); + uint8_t *p_usbread2 = find_sig(code, code_sz, &usb_read2_pattern, + sizeof(usb_read2_pattern), 0); + void *p_usbhandle = abs32_imm(p_closedevices, 1); + + // check if all pointers are o.k. + if (!p_opendevices || !p_usbwrite || !p_usbwrite2 || !p_usbread || + !p_usbread2) { + printf("Function signatures not found! Unsupported MiniPro version.\n"); + return FALSE; + } + + // Search for brick bug. This is not an actually bug but a special code + // used to brick pirated TL866A/CS devices. The problem is that they + // used a wrong detection which can also brick genuine TL866A/CS devices + // See this for more info: https://pastebin.com/i5iLGPs1 + unsigned char *p_brickbug = + memmem_r(BaseAddress + NtHeader->OptionalHeader.BaseOfCode, + NtHeader->OptionalHeader.SizeOfCode, &brickbug_pattern, + sizeof(brickbug_pattern)); + + // Print some debug info. + printf("Base Address = 0x%p\n", BaseAddress); + printf("Code section = 0x%p, 0x%lx\n", + BaseAddress + NtHeader->OptionalHeader.BaseOfCode, + (DWORD)NtHeader->OptionalHeader.SizeOfCode); + printf("Open Devices found at 0x%p\n", p_opendevices); + printf("Close Devices found at 0x%p\n", p_closedevices); + printf("Usb Write found at 0x%p\n", p_usbwrite); + printf("Usb Read found at 0x%p\n", p_usbread); + printf("Usb Write2 found at 0x%p\n", p_usbwrite2); + printf("Usb Read2 found at 0x%p\n", p_usbread2); + printf("Usb Handle found at 0x%p\n", p_usbhandle); + if (p_brickbug) + printf("Patched brick bug at 0x%p\n", p_brickbug + 0x08); + + // Patch all low level functions in MiniPro.exe to point to our custom + // functions. + + // Initialize the usb_handle pointer. + // Compared to Xgpro software we have only a data pointer here. + // We initialize each element with a simple index (0 to 3) + // or the INVALID_HANDLE_VALUE. + usb_handle = p_usbhandle; + + // Now this is the actual code patch. So we need to patch the code + // to redirect all the usb realated functions as well as open/close devices + // functions to point to our custom implementation. + // functions. The patch is done by inserting an absolute jump at the + // desired adress. To do this we need first to change the READ_ONLY + // attribute of the code section, patch the desired address and then + // restore the old READ_ONLY attribute. + // So, we have a self modifying code here. + + // Unprotect the code memory section (make it writable) + DWORD dwOldProtection; + VirtualProtect(BaseAddress + NtHeader->OptionalHeader.BaseOfCode, + NtHeader->OptionalHeader.SizeOfCode, PAGE_READWRITE, + &dwOldProtection); + + // patch open_devices function + patch(p_opendevices, &open_devices); + + // patch close_devices function + patch(p_closedevices, &close_devices); + + // patch usb_write function + patch(p_usbwrite, &usb_write); + + // patch usb_read function + patch(p_usbread, &usb_read); + + // patch usb_write2 function + patch(p_usbwrite2, &usb_write2); + + // patch usb_read2 function + patch(p_usbread2, &usb_read2); + + // patch the brick bug + if (p_brickbug) + *(p_brickbug + 0x08) = X86_JMP; + + // Restore the old READ_ONLY protection + VirtualProtect(BaseAddress + NtHeader->OptionalHeader.BaseOfCode, + NtHeader->OptionalHeader.SizeOfCode, dwOldProtection, + &dwOldProtection); + + // Set the Minipro GUID + memcpy(&m_guid, &MINIPRO_GUID, sizeof(GUID)); + + // Set the VID/PID + device_vid = TL866A_VID; + device_pid = TL866A_PID; + return TRUE; +} + +// Parse environment variables +void get_env_variables(void) +{ + debug = 0; + broker_port = RPC_PORT_DEFAULT; + + // TL_DEBUG + const char *dbg = getenv("TL_DEBUG"); + if (dbg && *dbg) { + if (!strncmp(dbg, "1", 1)) + debug = 1; + else if (!strncmp(dbg, "2", 1)) + debug = 2; + else if (!strncmp(dbg, "3", 1)) + debug = 3; + else + debug = 0; + } + + // BROKER_PORT + const char *port = getenv("BROKER_PORT"); + if (port && *port) { + char *end; + errno = 0; + unsigned long val = strtoul(port, &end, 10); + if (errno == 0 && *end == '\0' && val > 0 && val <= USHRT_MAX) { + broker_port = (unsigned short)val; + } else { + fprintf(stderr, + "Invalid BROKER_PORT='%s' (expected 1-65535)\n", + port); + } + } +} + +// Machine to string helper +static const char *machine_to_str(USHORT m) +{ + switch (m) { + case 0x8664: + return "AMD64"; + case 0x014c: + return "x86"; + case 0xAA64: + return "ARM64"; + case 0x01c4: + return "ARM"; + case 0x0000: + return "NATIVE"; + default: + return "Unknown"; + } +} + +// Read registry +static int reg_read_sz(HKEY root, const char *subkey, const char *name, + char *out, DWORD out_sz) +{ + HKEY hkey; + DWORD type = 0, sz = out_sz; + if (RegOpenKeyEx(root, subkey, 0, KEY_READ, &hkey) != ERROR_SUCCESS) + return 0; + int ok = (RegQueryValueEx(hkey, name, NULL, &type, (LPBYTE)out, &sz) == + ERROR_SUCCESS && + type == REG_SZ); + RegCloseKey(hkey); + return ok; +} + +// Detect Windows and Wine version +void detect_wine_version() +{ + typedef LONG(WINAPI * RtlGetVersion_t)(OSVERSIONINFO *); + typedef BOOL(WINAPI * IsWow64Process2_t)(HANDLE, USHORT *, USHORT *); + typedef BOOL(WINAPI * IsWow64Process_t)(HANDLE, PBOOL); + typedef VOID(WINAPI * GetNativeSystemInfo)(LPSYSTEM_INFO); + typedef const char *(*wine_get_version_t)(void); + RtlGetVersion_t pRtlGetVersion = NULL; + + HMODULE ntdll = GetModuleHandle("ntdll.dll"); + HMODULE k32 = GetModuleHandle("kernel32.dll"); + if (!ntdll || !k32) + return; + + printf("\n------------Wine info-------------------\n"); + pRtlGetVersion = + (RtlGetVersion_t)GetProcAddress(ntdll, "RtlGetVersion"); + wine_get_version_t wine_get_version = + (wine_get_version_t)(uintptr_t)GetProcAddress( + ntdll, "wine_get_version"); + + if (wine_get_version) { + printf("Detected Wine version: %s\n", wine_get_version()); + } + + OSVERSIONINFO osv = { 0 }; + osv.dwOSVersionInfoSize = sizeof(osv); + if (pRtlGetVersion && pRtlGetVersion(&osv) == 0) { + wprintf(L"Windows version: %lu.%lu (build %lu)\n", + osv.dwMajorVersion, osv.dwMinorVersion, + osv.dwBuildNumber); + } else { + if (GetVersionExA(&osv)) { + wprintf(L"(Windows version: %lu.%lu (build %lu)\n", + osv.dwMajorVersion, osv.dwMinorVersion, + osv.dwBuildNumber); + } + } + + char pname[256] = ""; + const char *cv = "Software\\Microsoft\\Windows NT\\CurrentVersion"; + if (reg_read_sz(HKEY_LOCAL_MACHINE, cv, "ProductName", pname, + sizeof(pname))) + printf("Product Name: %s\n", pname); + + IsWow64Process2_t pIsWow64Process2 = + GetProcAddress(k32, "IsWow64Process2"); + + if (pIsWow64Process2) { + USHORT pm = 0, nm = 0; + if (pIsWow64Process2(GetCurrentProcess(), &pm, &nm)) { + BOOL wow64 = (pm != 0); + USHORT proc_m = (pm != 0) ? pm : nm; + + printf("Arch (process/native): %s / %s%s\n", + machine_to_str(proc_m), machine_to_str(nm), + wow64 ? " (WOW64)" : ""); + } + } else { + IsWow64Process_t pIsWow64Process = + GetProcAddress(k32, "IsWow64Process"); + GetNativeSystemInfo pGetNativeSystemInfo = + (void *)GetProcAddress(k32, "GetNativeSystemInfo"); + + SYSTEM_INFO si; + ZeroMemory(&si, sizeof(si)); + if (pGetNativeSystemInfo) + pGetNativeSystemInfo(&si); + else + GetSystemInfo(&si); + + BOOL wow64 = FALSE; + if (pIsWow64Process) + (void)pIsWow64Process(GetCurrentProcess(), &wow64); + + USHORT proc_m = (sizeof(void *) == 8) ? 0x8664 : 0x014c; + const char *native_str = "Unknown"; + switch (si.wProcessorArchitecture) { + case PROCESSOR_ARCHITECTURE_AMD64: + native_str = "AMD64"; + break; + case PROCESSOR_ARCHITECTURE_INTEL: + native_str = "x86"; + break; + case PROCESSOR_ARCHITECTURE_ARM64: + native_str = "ARM64"; + break; + case PROCESSOR_ARCHITECTURE_ARM: + native_str = "ARM"; + break; + } + + printf("Arch (process/native): %s / %s%s\n", + machine_to_str(proc_m), native_str, + wow64 ? " (WOW64)" : ""); + } +} + +// Detect comctl32 and toolbar rendering bug in Wine +void detect_comctl(void) +{ + DWORD maj = 0, min = 0; + HMODULE hComctl = LoadLibraryA("comctl32.dll"); + if (hComctl) { + typedef HRESULT(CALLBACK * PFN_DLLGETVERSION)(DLLVERSIONINFO *); + PFN_DLLGETVERSION p = (PFN_DLLGETVERSION)GetProcAddress( + hComctl, "DllGetVersion"); + if (p) { + DLLVERSIONINFO dvi = { 0 }; + dvi.cbSize = sizeof(dvi); + if (SUCCEEDED(p(&dvi))) { + maj = dvi.dwMajorVersion; + min = dvi.dwMinorVersion; + } + } + FreeLibrary(hComctl); + } + + printf("comctl32 version: %lu.%lu\n", (unsigned long)maj, + (unsigned long)min); + int theme_on = 0; + HMODULE hUx = LoadLibraryA("uxtheme.dll"); + if (hUx) { + BOOL(WINAPI * is_themed)(void) = + (void *)GetProcAddress(hUx, "IsAppThemed"); + BOOL(WINAPI * is_theme_active)(void) = + (void *)GetProcAddress(hUx, "IsThemeActive"); + theme_on = (is_themed && is_theme_active) ? + (is_themed() && is_theme_active()) : + 0; + FreeLibrary(hUx); + } + + if (theme_on && !(maj == 5 && min == 80)) { + printf("WARN: Theme enabled and comctl32 != 5.80; toolbar may render incorrectly.\n" + "Run `winetricks comctl32` (native 5.80) or disable the theme.\n"); + } +} + +/*================== DllMain ====================*/ +BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) +{ + // Get the module name (should be shim.dll) + wchar_t buffer[MAX_PATH]; + GetModuleFileNameW(hinstDLL, buffer, sizeof(buffer)); + const wchar_t *module_name = PathFindFileNameW(buffer); + if (!module_name) { + module_name = L"shim.dll"; + } + + switch (fdwReason) { + + // Dll loaded and atached to process + case DLL_PROCESS_ATTACH: + DisableThreadLibraryCalls(hinstDLL); + m_hInst = hinstDLL; + + // Attach console to our parrent process + AttachConsole(ATTACH_PARENT_PROCESS); + freopen("CONOUT$", "w", stdout); + setvbuf(stdout, NULL, _IONBF, 0); + freopen("CONOUT$", "w", stderr); + setvbuf(stderr, NULL, _IONBF, 0); + printf("%ls loaded\n", module_name); + + // Parse environment variables + get_env_variables(); + + // Detect Wine version + detect_wine_version(); + + // Detect comctl32 version + detect_comctl(); + + // Initialize broker event + InterlockedExchange(&broker_state, BRK_STATE_INIT); + broker_evt = CreateEvent(NULL, TRUE, FALSE, NULL); + + // Try to patch the software + printf("\n------------Software--------------------\n"); + if ((patch_xgpro() || patch_minipro()) && !wsa_init()){ + printf("\n------------Devices----------------------\n"); + printf("Using USB broker port: %u\n", broker_port); + return TRUE; + } + printf("%ls unloaded\n", module_name); + return FALSE; + + // We are detached from a process, terminate hotplug thread and exit. + case DLL_PROCESS_DETACH: + printf("%ls unloaded\n", module_name); + HANDLE h = (HANDLE)InterlockedExchangePointer( + (PVOID *)broker_evt, NULL); + CloseHandle(h); + WSACleanup(); + } + return TRUE; +} diff --git a/wine64/shim.dll b/wine64/shim.dll new file mode 100755 index 0000000000000000000000000000000000000000..c7e189d8d7a39a5edda756e063a33b2df30c1559 GIT binary patch literal 352107 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

Kcrn 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

C?f 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 literal 0 HcmV?d00001 diff --git a/wine64/usb-broker b/wine64/usb-broker new file mode 100755 index 0000000000000000000000000000000000000000..016782f169cd8719b11bd645953eac74f0338d98 GIT binary patch literal 27384 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 literal 0 HcmV?d00001