Compile error in Windows

[alvin1995]

When I used MSYS2 to compile usbmuxd on Windows(Before this I used ./autogen.sh and succeeded)
I encountered the following header file error.

Maybe winsock2.h should be used on Windows.
There are many similar compilation problems. I think someone may have encountered the same problem as me.
How to solve it? Looking forward to your reply, thank you

[MarijnS95]

On Windows it seems you're not supposed to build/install/use usbmuxd, because that is already provided by iTunes:

• windows error #232 (comment)
• Windows connection fails (CMD to connect to iOS devices) libimobiledevice#1371 (comment)
• [Windows] usbmuxd: Could not open device #184 (comment)

This dependency does not become clear from the various readme's (neither libimobiledevice nor libusbmuxd, the client portion for usbmuxd). I think I'll submit some improvement PRs to clarify that in both projects' READMEs.

Separately we'd love to hear/see if it's possible/feasible to port usbmuxd (the server) to Windows, so that users don't need to install iTunes and can perhaps create projects that are able to run out of the box (like how adb bundles & starts the ADB server).
EDIT: Linking in recent activity in libimobiledevice/libusbmuxd#153, which also needs usbmuxd (the reimplementation by libimobiledevice) for ARM64 Windows.

[NumberOneGit]

@MarijnS95 Is that the case for ARM64 Windows? In other words, does Windows still have usbmuxd even though it doesn’t have Apple Mobile Device Ethernet Adapter? I’m trying to write a USB tethering driver, but was hoping to use usbmuxd daemon for trust.

[MarijnS95]

@NumberOneGit I hadn't considered whether iTunes is distributed for ARM64 Windows. Regardless, we've been considering to fix/port this project to compile and run on Windows to replace the need for a full iTunes install, and that could solve the missing iTunes for ARM64 Windows as well.

[nikias]

I have a patch for Windows that would allow to compile it, but when run I get an error from libusb saying device hotplug feature is not available, so it would need to use polling. However Windows is then not able to perform it with polling instead.

https://gist.github.com/nikias/c544814c5535d08ab66f0a42afc525ae

Maybe you can get further with this.

[Amoystyle]

@nikias

There are also some problems with set_valid_configuration under Windows. libusb_kernel_driver_active and libusb_detach_kernel_driver are not supported, so it can only be handled by using libusb-win32's usb_set_configuration.

Under Windows, the USB file descriptor is not in the polling list, and you need to actively handle USB events. Currently, I add the following code to actively handle USB events. I don't know if this is the best way to add it, but it works.

#ifndef HAVE_PPOLL
#ifdef _WIN32
static int ppoll(struct pollfd *fds, nfds_t nfds, const struct timespec *timeout)
{
    int to = timeout->tv_sec * 1000 + timeout->tv_nsec / 1000000;

    int result = WSAPoll(fds, nfds, to);
    if (result == SOCKET_ERROR) {
        int error = WSAGetLastError();
        if (error == WSAEINTR) {
            return ppoll(fds, nfds, timeout);
        }
        usbmuxd_log(LL_ERROR, "WSAPoll failed with error: %d", error);
        return -1;
    }
    return result;
}
#else
static int ppoll(struct pollfd *fds, nfds_t nfds, const struct timespec *timeout, const sigset_t *sigmask)
{
    int ready;
    sigset_t origmask;
    int to = timeout->tv_sec*1000 + timeout->tv_nsec/1000000;

    sigprocmask(SIG_SETMASK, sigmask, &origmask);
    ready = poll(fds, nfds, to);
    sigprocmask(SIG_SETMASK, &origmask, NULL);

    return ready;
}
#endif // _WIN32
#endif

static int main_loop(int listenfd)
{
    int to, cnt, i, dto;
    struct fdlist pollfds;
    struct timespec tspec;

#ifndef _WIN32
    sigset_t empty_sigset;
    sigemptyset(&empty_sigset); // unmask all signals
#endif

    fdlist_create(&pollfds);
    while(!should_exit) {
        usbmuxd_log(LL_FLOOD, "main_loop iteration");
        to = usb_get_timeout();
        usbmuxd_log(LL_FLOOD, "USB timeout is %d ms", to);
        dto = device_get_timeout();
        usbmuxd_log(LL_FLOOD, "Device timeout is %d ms", dto);
        if(dto < to)
        	to = dto;

        fdlist_reset(&pollfds);
        fdlist_add(&pollfds, FD_LISTEN, listenfd, POLLIN);
#ifndef _WIN32
        usb_get_fds(&pollfds);
#endif
        client_get_fds(&pollfds);
        //usbmuxd_log(LL_FLOOD, "fd count is %d", pollfds.count);

        tspec.tv_sec = to / 1000;
        tspec.tv_nsec = (to % 1000) * 1000000;
#ifdef _WIN32
        cnt = ppoll(pollfds.fds, pollfds.count, &tspec);
#else
        cnt = ppoll(pollfds.fds, pollfds.count, &tspec, &empty_sigset);
#endif
        usbmuxd_log(LL_FLOOD, "poll() returned %d", cnt);
        if(cnt == -1) {
            if(errno == EINTR) {
                if(should_exit) {
                    usbmuxd_log(LL_INFO, "Event processing interrupted");
                    break;
                }
                if(should_discover) {
                    should_discover = 0;
                    usbmuxd_log(LL_INFO, "Device discovery triggered");
                    usb_discover();
                }
            }
        } else if(cnt == 0) {
            if(usb_process() < 0) {
                usbmuxd_log(LL_FATAL, "usb_process() failed");
                fdlist_free(&pollfds);
                return -1;
            }
            device_check_timeouts();
        } else {
            int done_usb = 0;
#ifdef _WIN32
            // *** replace usb_get_fds(&pollfds);
            // *** Under Windows, the USB file descriptor is not in the poll list and needs to actively handle USB events
            if(usb_process() < 0) {
                usbmuxd_log(LL_FATAL, "usb_process() failed");
                fdlist_free(&pollfds);
                return -1;
            }
            done_usb = 1;
#endif
            for(i=0; i<pollfds.count; i++) {
                if(pollfds.fds[i].revents) {
                    if(!done_usb && pollfds.owners[i] == FD_USB) {
                        if(usb_process() < 0) {
                            usbmuxd_log(LL_FATAL, "usb_process() failed");
                            fdlist_free(&pollfds);
                            return -1;
                        }
                        done_usb = 1;
                    }
                    if(pollfds.owners[i] == FD_LISTEN) {
                        if(client_accept(listenfd) < 0) {
                            usbmuxd_log(LL_FATAL, "client_accept() failed");
                            fdlist_free(&pollfds);
                            return -1;
                        }
                    }
                    if(pollfds.owners[i] == FD_CLIENT) {
                        client_process(pollfds.fds[i].fd, pollfds.fds[i].revents);
                    }
                }
            }
        }
        // *** Lower CPU frequency
        Sleep(10);
    }
    fdlist_free(&pollfds);
    return 0;
}

[nikias]

Ok cool, that is at least something. For usb.c I'd suggest to just add an ifdef:

diff --git a/src/usb.c b/src/usb.c
index d0e9afc..1e3b1f4 100644
--- a/src/usb.c
+++ b/src/usb.c
@@ -527,6 +525,7 @@ static int set_valid_configuration(struct libusb_device* dev, struct usb_device
                }
                if(current_config == 0 || config->bConfigurationValue != current_config) {
                        usbmuxd_log(LL_NOTICE, "Changing configuration of device %i-%i: %i -> %i", bus, address, current_config, config->bConfigurationValue);
+#ifndef _WIN32
                        for(k=0 ; k < config->bNumInterfaces ; k++) {
                                const struct libusb_interface_descriptor *intf1 = &config->interface[k].altsetting[0];
                                if((res = libusb_kernel_driver_active(handle, intf1->bInterfaceNumber)) < 0) {
@@ -541,6 +540,7 @@ static int set_valid_configuration(struct libusb_device* dev, struct usb_device
                                        }
                                }
                        }
+#endif
                        if((res = libusb_set_configuration(handle, j)) != 0) {
                                usbmuxd_log(LL_WARNING, "Could not set configuration %d for device %d-%d: %s", j, bus, address, libusb_error_name(res));
                                libusb_free_config_descriptor(config);

This would go directly and call libusb_set_configuration. Does that work?

[Amoystyle]

@nikias
It doesn't work. It always returns LIBUSB_ERROR_BUSY. This is probably because libusb_kernel_driver_active and libusb_detach_kernel_driver are not supported on Windows. Here's a workaround I used. I hope it helps with Windows support.

diff --git a/src/usb.c b/src/usb.c
index d0e9afc..43750ee 100644
--- a/src/usb.c
+++ b/src/usb.c
@@ -29,7 +29,12 @@
 #include <stdint.h>
 #include <string.h>

+#ifdef _WIN32
 #include <libusb.h>
+#include "usb_win32.h"
+#else
+#include <libusb.h>
+#endif

 #include <libimobiledevice-glue/collection.h>

@@ -527,6 +532,19 @@ static int set_valid_configuration(struct libusb_device* dev, struct usb_device
                }
                if(current_config == 0 || config->bConfigurationValue != current_config) {
                        usbmuxd_log(LL_NOTICE, "Changing configuration of device %i-%i: %i -> %i", bus, address, current_config, config->bConfigurationValue);
+#ifdef _WIN32
+                       // *** If the interface is not found, try to modify the configuration
+                       // *** After modification, -1 will be returned, allowing discover to re-enumerate)
+                       usbmuxd_log(LL_INFO, "Using Windows-specific configuration change method for device %d-%d", bus, address);
+                       res = usb_win32_set_configuration(usbdev->serial, j);
+                       if (res != 0) {
+                               usbmuxd_log(LL_WARNING, "Could not set configuration %d for device %d-%d: %s", j, bus, address, libusb_error_name(res));
+                               libusb_free_config_descriptor(config);
+                               continue;
+                       }
+                       libusb_free_config_descriptor(config);
+                       return -1;
+#else
                        for(k=0 ; k < config->bNumInterfaces ; k++) {
                                const struct libusb_interface_descriptor *intf1 = &config->interface[k].altsetting[0];
                                if((res = libusb_kernel_driver_active(handle, intf1->bInterfaceNumber)) < 0) {
@@ -546,6 +564,7 @@ static int set_valid_configuration(struct libusb_device* dev, struct usb_device
                                libusb_free_config_descriptor(config);
                                continue;
                        }
+#endif
                }

                libusb_free_config_descriptor(config);
@@ -780,6 +799,12 @@ static int usb_device_add(libusb_device* dev)
        usbdev->handle = handle;
        usbdev->alive = 1;

+       Sleep(100);
+       unsigned char _str[256] = {0};
+       libusb_get_string_descriptor_ascii(handle, devdesc.iSerialNumber, _str, sizeof(_str));
+       memcpy(usbdev->serial, _str, sizeof(_str));
+       usbmuxd_log(LL_INFO, "Get device serialnumber %d-%d: %s", bus, address, usbdev->serial);
+
        collection_init(&usbdev->tx_xfers);
        collection_init(&usbdev->rx_xfers);

@@ -1055,6 +1080,7 @@ int usb_init(void)
        libusb_set_debug(NULL, (log_level >= LL_DEBUG ? LIBUSB_LOG_LEVEL_DEBUG: (log_level >= LL_WARNING ? LIBUSB_LOG_LEVEL_WARNING: LIBUSB_LOG_LEVEL_NONE)));
 #endif

+       usb_win32_init();
        collection_init(&device_list);

 #ifdef HAVE_LIBUSB_HOTPLUG_API

Windows_USB_Support.zip

[NumberOneGit]

@Amoystyle Was this meant to be a workaround to change the USB configuration in Windows? I see that there was originally an attachment but the comment was edited to remove it.

[Amoystyle]

@NumberOneGit
It works, but it's not the optimal solution.