MAG160C/csdk/tools/legacy/libusb0_trace_shim.c

/*
 * libusb0.dll API-interception shim for protocol capture.
 * Forward to real libusb0.dll (renamed libusb0_real.dll in same dir),
 * logging usb_bulk_write/read payloads and control transfers.
 */
#define _WIN32_WINNT 0x0601
#include <windows.h>
#include <stdio.h>

typedef struct usb_dev_handle usb_dev_handle;
typedef void *usb_bus;


static HMODULE g_real;
static FILE *g_log;
static CRITICAL_SECTION g_lock;
static int g_init_done;

/* function pointers resolved at first call */
static int (*p_usb_init)(void);
static int (*p_usb_find_busses)(void);
static int (*p_usb_find_devices)(void);
static usb_bus (*p_usb_get_busses)(void);
static usb_dev_handle *(*p_usb_open)(void *);
static int (*p_usb_close)(usb_dev_handle *);
static int (*p_usb_set_configuration)(usb_dev_handle *, int);
static int (*p_usb_claim_interface)(usb_dev_handle *, int);
static int (*p_usb_release_interface)(usb_dev_handle *, int);
static int (*p_usb_set_altinterface)(usb_dev_handle *, int);
static int (*p_usb_clear_halt)(usb_dev_handle *, int);
static int (*p_usb_resetep)(usb_dev_handle *);
static int (*p_usb_reset)(usb_dev_handle *);
static int (*p_usb_bulk_write)(usb_dev_handle *, int, const char *, int, int);
static int (*p_usb_bulk_read)(usb_dev_handle *, int, char *, int, int);
static int (*p_usb_interrupt_write)(usb_dev_handle *, int, const char *, int, int);
static int (*p_usb_interrupt_read)(usb_dev_handle *, int, char *, int, int);
static int (*p_usb_control_msg)(usb_dev_handle *, int, int, int, int, char *, int, int);

#define LOAD(name) p_##name = (void *)GetProcAddress(g_real, #name)

static int g_loading;

static void ensure(void) {
    if (g_init_done || g_loading) return;
    g_loading = 1;
    InitializeCriticalSection(&g_lock);
    g_log = fopen("C:/Project/MAG160C/analysis/captures/libusb0_trace.txt", "ab");
    g_real = LoadLibraryA("libusb0_real.dll");
    LOAD(usb_init); LOAD(usb_find_busses); LOAD(usb_find_devices);
    LOAD(usb_get_busses); LOAD(usb_open); LOAD(usb_close);
    LOAD(usb_set_configuration); LOAD(usb_claim_interface);
    LOAD(usb_release_interface); LOAD(usb_set_altinterface);
    LOAD(usb_clear_halt); LOAD(usb_resetep); LOAD(usb_reset);
    LOAD(usb_bulk_write); LOAD(usb_bulk_read);
    LOAD(usb_interrupt_write); LOAD(usb_interrupt_read);
    LOAD(usb_control_msg);
    g_init_done = 1;
    g_loading = 0;
}

static void log_bytes(const char *tag, const void *buf, int len) {
    if (!g_log) return;
    EnterCriticalSection(&g_lock);
    fprintf(g_log, "%s len=%d: ", tag, len);
    const unsigned char *p = (const unsigned char *)buf;
    int n = len < 512 ? len : 512;
    for (int i = 0; i < n; ++i) fprintf(g_log, "%02x ", p[i]);
    if (len > 512) fprintf(g_log, "...(+%d)", len - 512);
    fprintf(g_log, "\n");
    fflush(g_log);
    LeaveCriticalSection(&g_lock);
}

int usb_init(void) { ensure(); return p_usb_init ? p_usb_init() : -1; }
int usb_find_busses(void) { ensure(); return p_usb_find_busses ? p_usb_find_busses() : -1; }
int usb_find_devices(void) { ensure(); return p_usb_find_devices ? p_usb_find_devices() : -1; }
usb_bus usb_get_busses(void) { ensure(); return p_usb_get_busses ? p_usb_get_busses() : 0; }
usb_dev_handle *usb_open(void *d) { ensure(); return p_usb_open ? p_usb_open(d) : 0; }
int usb_close(usb_dev_handle *d) { ensure(); return p_usb_close ? p_usb_close(d) : -1; }
int usb_set_configuration(usb_dev_handle *d, int c) { ensure(); return p_usb_set_configuration ? p_usb_set_configuration(d, c) : -1; }
int usb_claim_interface(usb_dev_handle *d, int i) { ensure(); return p_usb_claim_interface ? p_usb_claim_interface(d, i) : -1; }
int usb_release_interface(usb_dev_handle *d, int i) { ensure(); return p_usb_release_interface ? p_usb_release_interface(d, i) : -1; }
int usb_set_altinterface(usb_dev_handle *d, int i) { ensure(); return p_usb_set_altinterface ? p_usb_set_altinterface(d, i) : -1; }
int usb_clear_halt(usb_dev_handle *d, int e) { ensure(); return p_usb_clear_halt ? p_usb_clear_halt(d, e) : -1; }
int usb_resetep(usb_dev_handle *d) { ensure(); return p_usb_resetep ? p_usb_resetep(d) : -1; }
int usb_reset(usb_dev_handle *d) { ensure(); return p_usb_reset ? p_usb_reset(d) : -1; }

int usb_bulk_write(usb_dev_handle *dev, int ep, const char *bytes, int size, int timeout) {
    ensure();
    log_bytes("BULK_WRITE", bytes, size);
    return p_usb_bulk_write ? p_usb_bulk_write(dev, ep, bytes, size, timeout) : -1;
}

int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout) {
    ensure();
    if (!p_usb_bulk_read) return -1;
    int rc = p_usb_bulk_read(dev, ep, bytes, size, timeout);
    if (rc >= 0) log_bytes("BULK_READ", bytes, rc);
    else log_bytes("BULK_READ_ERR", &rc, sizeof(rc));
    return rc;
}

int usb_interrupt_write(usb_dev_handle *dev, int ep, const char *bytes, int size, int timeout) {
    ensure();
    log_bytes("INT_WRITE", bytes, size);
    return p_usb_interrupt_write ? p_usb_interrupt_write(dev, ep, bytes, size, timeout) : -1;
}

int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout) {
    ensure();
    if (!p_usb_interrupt_read) return -1;
    int rc = p_usb_interrupt_read(dev, ep, bytes, size, timeout);
    if (rc >= 0) log_bytes("INT_READ", bytes, rc);
    return rc;
}

int usb_control_msg(usb_dev_handle *dev, int requesttype, int request, int value,
                    int index, char *bytes, int size, int timeout) {
    ensure();
    if (!p_usb_control_msg) return -1;
    int rc = p_usb_control_msg(dev, requesttype, request, value, index, bytes, size, timeout);
    char tag[80];
    sprintf(tag, "CTRL %02x:%02x v%04x i%04x", requesttype, request, value, index);
    if (rc >= 0) log_bytes(tag, bytes, rc);
    return rc;
}

const char *usb_strerror(void) { return "shim"; }
int usb_set_debug(int l) { (void)l; return 0; }
void *usb_get_version(void) { return 0; }
void *usb_device(void) { return 0; }
int usb_install_driver_np(void) { return 0; }
int usb_install_driver_np_rundll(void) { return 0; }
int usb_install_needs_restart_np(void) { return 0; }
int usb_install_npA(void) { return 0; }
int usb_install_npW(void) { return 0; }
int usb_install_np_rundll(void) { return 0; }
int usb_install_service_np(void) { return 0; }
int usb_install_service_np_rundll(void) { return 0; }
int usb_reset_ex(void) { return 0; }
int usb_touch_inf_file_np(void) { return 0; }
int usb_touch_inf_file_np_rundll(void) { return 0; }
int usb_uninstall_service_np(void) { return 0; }
int usb_uninstall_service_np_rundll(void) { return 0; }
void *usb_bulk_setup_async(usb_dev_handle *d, int e) { (void)d; (void)e; return 0; }
int usb_cancel_async(void *a) { (void)a; return 0; }
void usb_free_async(void *a) { (void)a; }
int usb_submit_async(void *a, char *b) { (void)a; (void)b; return 0; }
void *usb_reap_async(void *a, int t) { (void)a; (void)t; return 0; }
void *usb_reap_async_nocancel(void *a, int t) { (void)a; (void)t; return 0; }
int usb_get_descriptor(usb_dev_handle *d) { (void)d; return -1; }
int usb_get_descriptor_by_endpoint(usb_dev_handle *d) { (void)d; return -1; }
int usb_get_string(usb_dev_handle *d) { (void)d; return -1; }
int usb_get_string_simple(usb_dev_handle *d) { (void)d; return -1; }
void *usb_isochronous_setup_async(usb_dev_handle *d) { (void)d; return 0; }
void *usb_interrupt_setup_async(usb_dev_handle *d) { (void)d; return 0; }

BOOL WINAPI DllMain(HINSTANCE h, DWORD reason, LPVOID r) {
    (void)h; (void)r;
    if (reason == DLL_PROCESS_DETACH && g_log) {
        fclose(g_log);
        g_log = NULL;
    }
    return TRUE;
}