git.zerfleddert.de Git - usb-driver/blob - usb-driver.c

   1 #if defined(__GNUC__) && !defined(__STRICT_ANSI__)
   2
   3 #define _GNU_SOURCE 1
   4
   5 #if defined(RTLD_NEXT)
   6 #define REAL_LIBC RTLD_NEXT
   7 #else
   8 #define REAL_LIBC ((void *) -1L)
   9 #endif
  10
  11 #include <dlfcn.h>
  12 #include <stdarg.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <unistd.h>
  16 #include <fcntl.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <sys/time.h>
  20 #include <stdio.h>
  21 #include <usb.h>
  22 #include "xilinx.h"
  23
  24 static int (*ioctl_func) (int, int, void *) = NULL;
  25 static int windrvrfd = 0;
  26 static struct usb_bus *busses = NULL;
  27 static struct usb_device *usb_cable;
  28 static unsigned long card_type;
  29
  30 #define NO_WINDRVR 1
  31
  32 void hexdump(unsigned char *buf, int len);
  33 void diff(unsigned char *buf1, unsigned char *buf2, int len);
  34
  35 int do_wdioctl(int fd, unsigned int request, unsigned char *wdioctl) {
  36         struct header_struct* wdheader = (struct header_struct*)wdioctl;
  37         struct version_struct *version;
  38         int ret = 0;
  39
  40         if (wdheader->magic != MAGIC) {
  41                 fprintf(stderr,"!!!ERROR: magic header does not match!!!\n");
  42                 return (*ioctl_func) (fd, request, wdioctl);
  43         }
  44
  45         switch(request) {
  46                 case VERSION:
  47                         version = (struct version_struct*)(wdheader->data);
  48                         strcpy(version->version, "WinDriver no more");
  49                         version->versionul = 999;
  50                         fprintf(stderr,"faking VERSION\n");
  51                         break;
  52
  53                 case LICENSE:
  54                         fprintf(stderr,"faking LICENSE\n");
  55                         break;
  56
  57                 case CARD_REGISTER:
  58                         {
  59                                 //struct card_register* cr = (struct card_register*)(wdheader->data);
  60                                 /* Todo: LPT-Port already in use */
  61                         }
  62                         fprintf(stderr,"faking CARD_REGISTER\n");
  63                         break;
  64
  65                 case USB_TRANSFER:
  66                         fprintf(stderr,"in USB_TRANSFER");
  67                         {
  68                                 struct usb_transfer *ut = (struct usb_transfer*)(wdheader->data);
  69
  70                                 fprintf(stderr," unique: %lu, pipe: %lu, read: %lu, options: %lx, size: %lu, timeout: %lx\n", ut->dwUniqueID, ut->dwPipeNum, ut->fRead, ut->dwOptions, ut->dwBufferSize, ut->dwTimeout);
  71                                 fprintf(stderr,"setup packet: ");
  72                                 hexdump(ut->SetupPacket, 8);
  73                                 fprintf(stderr,"\n");
  74                                 if (!ut->fRead && ut->dwBufferSize)
  75                                 {
  76                                         hexdump(ut->pBuffer, ut->dwBufferSize);
  77                                         fprintf(stderr,"\n");
  78                                 }
  79
  80 #ifndef NO_WINDRVR
  81                                 ret = (*ioctl_func) (fd, request, wdioctl);
  82 #endif
  83
  84                                 fprintf(stderr,"Transferred: %lu (%s)\n",ut->dwBytesTransferred, (ut->fRead?"read":"write"));
  85                                 if (ut->fRead && ut->dwBytesTransferred)
  86                                 {
  87                                         fprintf(stderr,"Read: ");
  88                                         hexdump(ut->pBuffer, ut->dwBytesTransferred);
  89                                 }
  90                                 fprintf(stderr,"\n");
  91                         }
  92                         break;
  93
  94                 case INT_ENABLE:
  95                         fprintf(stderr,"faking INT_ENABLE");
  96                         {
  97                                 struct interrupt *it = (struct interrupt*)(wdheader->data);
  98
  99                                 fprintf(stderr,"Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 100
 101                                 it->fEnableOk = 1;
 102                                 //ret = (*ioctl_func) (fd, request, wdioctl);
 103                         }
 104
 105                         break;
 106
 107                 case INT_DISABLE:
 108                         fprintf(stderr,"INT_DISABLE\n");
 109                         {
 110                                 struct interrupt *it = (struct interrupt*)(wdheader->data);
 111
 112                                 fprintf(stderr,"Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 113 #ifndef NO_WINDRVR
 114                                 ret = (*ioctl_func) (fd, request, wdioctl);
 115 #else
 116                                 it->dwCounter = 0;
 117                                 it->fStopped = 1;
 118 #endif
 119                                 fprintf(stderr,"Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 120                         }
 121                         break;
 122
 123                 case USB_SET_INTERFACE:
 124                         fprintf(stderr,"USB_SET_INTERFACE\n");
 125                         {
 126                                 struct usb_set_interface *usi = (struct usb_set_interface*)(wdheader->data);
 127
 128                                 fprintf(stderr,"unique: %lu, interfacenum: %lu, alternatesetting: %lu, options: %lx\n", usi->dwUniqueID, usi->dwInterfaceNum, usi->dwAlternateSetting, usi->dwOptions);
 129 #ifndef NO_WINDRVR
 130                                 ret = (*ioctl_func) (fd, request, wdioctl);
 131 #endif
 132                         }
 133                         break;
 134
 135                 case USB_GET_DEVICE_DATA:
 136                         fprintf(stderr,"USB_GET_DEVICE_DATA\n");
 137                         {
 138                                 struct usb_get_device_data *ugdd = (struct usb_get_device_data*)(wdheader->data);
 139                                 int pSize;
 140
 141                                 fprintf(stderr, "unique: %lu, bytes: %lu, options: %lx\n", ugdd->dwUniqueID, ugdd->dwBytes, ugdd->dwOptions);
 142                                 pSize = ugdd->dwBytes;
 143                                 if (pSize) {
 144                                         hexdump(ugdd->pBuf, pSize);
 145                                 }
 146 #ifndef NO_WINDRVR
 147                                 ret = (*ioctl_func) (fd, request, wdioctl);
 148 #else
 149                                 if (!ugdd->dwBytes) {
 150                                         if (usb_cable) {
 151                                                 int i,j,k;
 152                                                 ugdd->dwBytes = sizeof(struct usb_device_info);
 153
 154                                                 for (i=0; i<usb_cable->descriptor.bNumConfigurations; i++)
 155                                                 {
 156                                                         struct usb_config_descriptor *conf_desc = &usb_cable->config[i];
 157                                                         ugdd->dwBytes+=sizeof(WDU_CONFIGURATION);
 158                                                         ugdd->dwBytes+=sizeof(WDU_INTERFACE) * conf_desc->bNumInterfaces;
 159
 160                                                         for (j=0; j<conf_desc->bNumInterfaces; j++)
 161                                                         {
 162                                                                 struct usb_interface *interface = &usb_cable->config[i].interface[j];
 163                                                                 for(k=0; k<interface->num_altsetting; k++)
 164                                                                 {
 165                                                                         unsigned char bNumEndpoints;
 166                                                                         bNumEndpoints = interface->altsetting[k].bNumEndpoints;
 167                                                                         ugdd->dwBytes+=sizeof(WDU_ALTERNATE_SETTING);
 168                                                                         ugdd->dwBytes+=(sizeof(WDU_ENDPOINT_DESCRIPTOR)+sizeof(WDU_PIPE_INFO))*bNumEndpoints;
 169                                                                 }
 170                                                         }
 171                                                 }
 172
 173
 174                                         }
 175                                 } else {
 176                                         struct usb_device_info_get *udi = (struct usb_device_info_get*)ugdd->pBuf;
 177                                         struct usb_endpoint_descriptor *ep;
 178 unsigned char dings[] = {0x12, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0xfd, 0x03, 0x08, 0x00, 0x00, 0x00, 0x01, 0x02,
 179 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 180 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x45, 0x21, 0x08, 0x38, 0x45, 0x21, 0x08,
 181 0x4c, 0x45, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 182 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 183 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 184 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 185 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 186 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 187 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 188 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x02, 0x20, 0x00, 0x01, 0x02, 0x00, 0x80,
 189 0x8c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x4c, 0x45, 0x21, 0x08, 0x58, 0x45, 0x21, 0x08,
 190 0x01, 0x00, 0x00, 0x00, 0x58, 0x45, 0x21, 0x08, 0x09, 0x04, 0x00, 0x00, 0x02, 0xff, 0x00, 0x00,
 191 0x00, 0x00, 0x00, 0x00, 0x6c, 0x45, 0x21, 0x08, 0x7c, 0x45, 0x21, 0x08, 0x07, 0x05, 0x02, 0x02,
 192 0x00, 0x02, 0x00, 0x00, 0x07, 0x05, 0x86, 0x02, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
 193 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 194 0x86, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 195 0x00, 0x00, 0x00, 0x00};
 196
 197 //unique: 94, bytes: 276, options: 0
 198 //Vendor: 3fd
 199 //12 01 00 02 00 00 00 40 fd 03 08 00 00 00 01 02                              12 01 00 02 00 00 00 40 fd 03 08 00 00 00 01 02
 200 //00 01 00 00 00 00 00 00 40 00 00 00 00 00 00 00                              00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 201 //03 00 00 00 00 00 00 00 38 45 21 08 38 45 21 08                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 202 //4c 45 21 08 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 203 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 204 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 205 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 206 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 207 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 208 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 209 //00 00 00 00 00 00 00 00 09 02 20 00 01 02 00 80                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 210 //8c 00 00 00 01 00 00 00 4c 45 21 08 58 45 21 08                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 211 //01 00 00 00 58 45 21 08 09 04 00 00 02 ff 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 212 //00 00 00 00 6c 45 21 08 7c 45 21 08 07 05 02 02                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 213 //00 02 00 00 07 05 86 02 00 02 00 00 02 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 214 //00 02 00 00 02 00 00 00 02 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 215 //86 00 00 00 00 02 00 00 02 00 00 00 01 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 216 //00 00 00 00                                                                  00 00 00 00
 217
 218                                         bzero(udi, ugdd->dwBytes);
 219                                         //memcpy(udi, dings, 276);
 220                                         udi->Descriptor.bLength = sizeof(WDU_DEVICE_DESCRIPTOR);
 221                                         udi->Descriptor.bDescriptorType = usb_cable->descriptor.bDescriptorType;
 222                                         udi->Descriptor.bcdUSB = usb_cable->descriptor.bcdUSB;
 223                                         udi->Descriptor.bDeviceClass = usb_cable->descriptor.bDeviceClass;
 224                                         udi->Descriptor.bDeviceSubClass = usb_cable->descriptor.bDeviceSubClass;
 225                                         udi->Descriptor.bDeviceProtocol = usb_cable->descriptor.bDeviceProtocol;
 226                                         udi->Descriptor.bMaxPacketSize0 = usb_cable->descriptor.bMaxPacketSize0;
 227                                         udi->Descriptor.idVendor = usb_cable->descriptor.idVendor;
 228                                         udi->Descriptor.idProduct = usb_cable->descriptor.idProduct;
 229                                         udi->Descriptor.bcdDevice = usb_cable->descriptor.bcdDevice;
 230                                         udi->Descriptor.iManufacturer = usb_cable->descriptor.iManufacturer;
 231                                         udi->Descriptor.iProduct = usb_cable->descriptor.iProduct;
 232                                         udi->Descriptor.iSerialNumber = usb_cable->descriptor.iSerialNumber;
 233                                         udi->Descriptor.bNumConfigurations = usb_cable->descriptor.bNumConfigurations;
 234
 235                                         ep = usb_cable->config->interface->altsetting[0].endpoint;
 236
 237                                         udi->Pipe0.dwNumber = 0x00;
 238                                         udi->Pipe0.dwMaximumPacketSize = usb_cable->descriptor.bMaxPacketSize0;
 239                                         udi->Pipe0.type = 0;
 240                                         udi->Pipe0.direction = 3;
 241                                         udi->Pipe0.dwInterval = 0;
 242
 243                                         udi->cfg.Descriptor.bLength = usb_cable->config->bLength;
 244                                         udi->cfg.Descriptor.bDescriptorType = usb_cable->config->bDescriptorType;
 245                                         udi->cfg.Descriptor.wTotalLength = usb_cable->config->wTotalLength;
 246                                         udi->cfg.Descriptor.bNumInterfaces = usb_cable->config->bNumInterfaces;
 247                                         udi->cfg.Descriptor.bConfigurationValue = usb_cable->config->bConfigurationValue;
 248                                         udi->cfg.Descriptor.iConfiguration = usb_cable->config->iConfiguration;
 249                                         udi->cfg.Descriptor.bmAttributes = usb_cable->config->bmAttributes;
 250                                         udi->cfg.Descriptor.MaxPower = usb_cable->config->MaxPower;
 251
 252                                         // ab offset 168 config desc
 253                                 }
 254 #endif
 255                                 if (pSize) {
 256                                         struct usb_device_info *udi = (struct usb_device_info*)ugdd->pBuf;
 257
 258                                         fprintf(stderr, "Vendor: %x\n", udi->Descriptor.idVendor);
 259
 260                                         hexdump(ugdd->pBuf, pSize);
 261                                         fprintf(stderr, "\n");
 262                                 }
 263                         }
 264                         break;
 265
 266                 case EVENT_REGISTER:
 267                         fprintf(stderr,"EVENT_REGISTER\n");
 268                         {
 269                                 struct event *e = (struct event*)(wdheader->data);
 270                                 struct usb_bus *bus;
 271                                 int i;
 272
 273                                 fprintf(stderr,"handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lu, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n", e->handle, e->dwAction, e->dwStatus, e->dwEventId, e->dwCardType, e->hKernelPlugIn, e->dwOptions, e->u.Usb.deviceId.dwVendorId, e->u.Usb.deviceId.dwProductId, e->u.Usb.dwUniqueID, e->dwEventVer, e->dwNumMatchTables);
 274                                 for (i = 0; i < e->dwNumMatchTables; i++) {
 275                                         fprintf(stderr,"match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n", e->matchTables[i].VendorId, e->matchTables[i].ProductId, e->matchTables[i].bDeviceClass, e->matchTables[i].bDeviceSubClass, e->matchTables[i].bInterfaceClass, e->matchTables[i].bInterfaceSubClass, e->matchTables[i].bInterfaceProtocol);
 276
 277                                         for (bus = busses; bus; bus = bus->next) {
 278                                                 struct usb_device *dev;
 279
 280                                                 for (dev = bus->devices; dev; dev = dev->next) {
 281                                                         struct usb_device_descriptor *desc = &(dev->descriptor);
 282
 283                                                         if((desc->idVendor == e->matchTables[i].VendorId) &&
 284                                                            (desc->idProduct == e->matchTables[i].ProductId) &&
 285                                                            (desc->bDeviceClass == e->matchTables[i].bDeviceClass) &&
 286                                                            (desc->bDeviceSubClass == e->matchTables[i].bDeviceSubClass)) {
 287                                                                 struct usb_interface *interface = dev->config->interface;
 288                                                                 int ai;
 289
 290                                                                 for (ai = 0; ai < interface->num_altsetting; ai++) {
 291                                                                         fprintf(stderr, "intclass: %x, intsubclass: %x, intproto: %x\n", interface->altsetting[i].bInterfaceClass, interface->altsetting[i].bInterfaceSubClass, interface->altsetting[i].bInterfaceProtocol);
 292                                                                         if ((interface->altsetting[i].bInterfaceSubClass == e->matchTables[i].bInterfaceSubClass) &&
 293                                                                             (interface->altsetting[i].bInterfaceProtocol == e->matchTables[i].bInterfaceProtocol)){
 294                                                                                 /* TODO: check interfaceClass! */
 295                                                                                 fprintf(stderr,"!!!FOUND DEVICE WITH LIBUSB!!!\n");
 296                                                                                 usb_cable = dev;
 297                                                                                 card_type = e->dwCardType;
 298                                                                         }
 299                                                                 }
 300                                                         }
 301                                                 }
 302                                         }
 303                                 }
 304
 305 #ifndef NO_WINDRVR
 306                                 ret = (*ioctl_func) (fd, request, wdioctl);
 307 #endif
 308
 309                                 fprintf(stderr,"handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lu, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n", e->handle, e->dwAction, e->dwStatus, e->dwEventId, e->dwCardType, e->hKernelPlugIn, e->dwOptions, e->u.Usb.deviceId.dwVendorId, e->u.Usb.deviceId.dwProductId, e->u.Usb.dwUniqueID, e->dwEventVer, e->dwNumMatchTables);
 310                                 for (i = 0; i < e->dwNumMatchTables; i++)
 311                                         fprintf(stderr,"match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n", e->matchTables[i].VendorId, e->matchTables[i].ProductId, e->matchTables[i].bDeviceClass, e->matchTables[i].bDeviceSubClass, e->matchTables[i].bInterfaceClass, e->matchTables[i].bInterfaceSubClass, e->matchTables[i].bInterfaceProtocol);
 312                         }
 313                         break;
 314
 315                 case TRANSFER:
 316                         fprintf(stderr,"TRANSFER\n");
 317 #ifndef NO_WINDRVR
 318                         ret = (*ioctl_func) (fd, request, wdioctl);
 319 #endif
 320                         break;
 321
 322                 case EVENT_UNREGISTER:
 323                         fprintf(stderr,"EVENT_UNREGISTER\n");
 324 #ifndef NO_WINDRVR
 325                         ret = (*ioctl_func) (fd, request, wdioctl);
 326 #endif
 327                         break;
 328
 329                 case INT_WAIT:
 330                         fprintf(stderr,"INT_WAIT\n");
 331                         {
 332                                 struct interrupt *it = (struct interrupt*)(wdheader->data);
 333
 334                                 fprintf(stderr,"Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 335
 336 #ifndef NO_WINDRVR
 337                                 ret = (*ioctl_func) (fd, request, wdioctl);
 338 #else
 339                                 if (usb_cable)
 340                                         it->dwCounter++;
 341 #endif
 342
 343                                 fprintf(stderr,"Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 344                         }
 345                         break;
 346
 347                 case CARD_UNREGISTER:
 348                         fprintf(stderr,"CARD_UNREGISTER\n");
 349 #ifndef NO_WINDRVR
 350                         ret = (*ioctl_func) (fd, request, wdioctl);
 351 #endif
 352                         break;
 353
 354                 case EVENT_PULL:
 355                         fprintf(stderr,"EVENT_PULL\n");
 356                         {
 357                                 struct event *e = (struct event*)(wdheader->data);
 358                                 int i;
 359
 360                                 fprintf(stderr,"handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lu, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n", e->handle, e->dwAction, e->dwStatus, e->dwEventId, e->dwCardType, e->hKernelPlugIn, e->dwOptions, e->u.Usb.deviceId.dwVendorId, e->u.Usb.deviceId.dwProductId, e->u.Usb.dwUniqueID, e->dwEventVer, e->dwNumMatchTables);
 361                                 for (i = 0; i < e->dwNumMatchTables; i++)
 362                                         fprintf(stderr,"match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n", e->matchTables[i].VendorId, e->matchTables[i].ProductId, e->matchTables[i].bDeviceClass, e->matchTables[i].bDeviceSubClass, e->matchTables[i].bInterfaceClass, e->matchTables[i].bInterfaceSubClass, e->matchTables[i].bInterfaceProtocol);
 363
 364 #ifndef NO_WINDRVR
 365                                 ret = (*ioctl_func) (fd, request, wdioctl);
 366 #else
 367 //EVENT_PULL
 368 //handle: 1, action: 0, status: 0, eventid: 0, cardtype: 0, kplug: 0, options: 0, dev: 0:0, unique: 0, ver: 1, nummatch: 1
 369 //match: dev: 0:0, class: 0, subclass: 0, intclass: 0, intsubclass: 0, intproto: 0
 370 //handle: 1, action: 1, status: 0, eventid: 109, cardtype: 4294967294, kplug: 0, options: 0, dev: 0:0, unique: 90, ver: 1, nummatch: 1
 371 //match: dev: 3fd:8, class: 0, subclass: 0, intclass: ff, intsubclass: 0, intproto: 0
 372                                 if (usb_cable) {
 373                                         struct usb_interface *interface = usb_cable->config->interface;
 374
 375                                         e->dwCardType = card_type;
 376                                         e->dwAction = 1;
 377                                         e->dwEventId = 109;
 378                                         e->u.Usb.dwUniqueID = 4711;
 379                                         e->matchTables[0].VendorId = usb_cable->descriptor.idVendor;
 380                                         e->matchTables[0].ProductId = usb_cable->descriptor.idProduct;
 381                                         e->matchTables[0].bDeviceClass = usb_cable->descriptor.bDeviceClass;
 382                                         e->matchTables[0].bDeviceSubClass = usb_cable->descriptor.bDeviceSubClass;
 383                                         e->matchTables[0].bInterfaceClass = interface->altsetting[0].bInterfaceClass;
 384                                         e->matchTables[0].bInterfaceSubClass = interface->altsetting[0].bInterfaceSubClass;
 385                                         e->matchTables[0].bInterfaceProtocol = interface->altsetting[0].bInterfaceProtocol;
 386                                 }
 387 #endif
 388
 389                                 fprintf(stderr,"handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lu, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n", e->handle, e->dwAction, e->dwStatus, e->dwEventId, e->dwCardType, e->hKernelPlugIn, e->dwOptions, e->u.Usb.deviceId.dwVendorId, e->u.Usb.deviceId.dwProductId, e->u.Usb.dwUniqueID, e->dwEventVer, e->dwNumMatchTables);
 390                                 for (i = 0; i < e->dwNumMatchTables; i++)
 391                                         fprintf(stderr,"match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n", e->matchTables[i].VendorId, e->matchTables[i].ProductId, e->matchTables[i].bDeviceClass, e->matchTables[i].bDeviceSubClass, e->matchTables[i].bInterfaceClass, e->matchTables[i].bInterfaceSubClass, e->matchTables[i].bInterfaceProtocol);
 392                         }
 393                         break;
 394
 395                 default:
 396                         fprintf(stderr,"!!!Unsupported IOCTL: %x!!!\n", request);
 397 #ifndef NO_WINDRVR
 398                         ret = (*ioctl_func) (fd, request, wdioctl);
 399 #endif
 400                         break;
 401         }
 402
 403         return ret;
 404 }
 405
 406
 407 typedef int (*open_funcptr_t) (const char *, int, mode_t);
 408
 409 int open (const char *pathname, int flags, ...)
 410 {
 411         static open_funcptr_t func = NULL;
 412         mode_t mode = 0;
 413         va_list args;
 414         int fd;
 415
 416         if (!func)
 417                 func = (open_funcptr_t) dlsym (REAL_LIBC, "open");
 418
 419         if (flags & O_CREAT) {
 420                 va_start(args, flags);
 421                 mode = va_arg(args, mode_t);
 422                 va_end(args);
 423         }
 424
 425         if (!strcmp (pathname, "/dev/windrvr6")) {
 426                 fprintf(stderr,"opening windrvr6\n");
 427 #ifdef NO_WINDRVR
 428                 windrvrfd = fd = (*func) ("/dev/null", flags, mode);
 429 #else
 430                 windrvrfd = fd = (*func) (pathname, flags, mode);
 431 #endif
 432                 if (!busses) {
 433                         usb_init();
 434                         usb_find_busses();
 435                         usb_find_devices();
 436
 437                         busses = usb_get_busses();
 438                 }
 439         } else {
 440                 fd = (*func) (pathname, flags, mode);
 441         }
 442
 443         return fd;
 444 }
 445
 446 void diff(unsigned char *buf1, unsigned char *buf2, int len) {
 447         int i;
 448
 449         for(i=0; i<len; i++) {
 450                 if (buf1[i] != buf2[i]) {
 451                         fprintf(stderr,"Diff at %d: %02x(%c)->%02x(%c)\n", i, buf1[i], ((buf1[i] >= 31 && buf1[i] <= 126)?buf1[i]:'.'), buf2[i], ((buf2[i] >= 31 && buf2[i] <= 126)?buf2[i]:'.'));
 452                 }
 453         }
 454 }
 455
 456 void hexdump(unsigned char *buf, int len) {
 457         int i;
 458
 459         for(i=0; i<len; i++) {
 460                 fprintf(stderr,"%02x ", buf[i]);
 461                 if ((i % 16) == 15)
 462                         fprintf(stderr,"\n");
 463         }
 464 }
 465
 466 int ioctl(int fd, int request, ...)
 467 {
 468         va_list args;
 469         void *argp;
 470         int ret;
 471
 472         if (!ioctl_func)
 473                 ioctl_func = (int (*) (int, int, void *)) dlsym (REAL_LIBC, "ioctl");
 474
 475         va_start (args, request);
 476         argp = va_arg (args, void *);
 477         va_end (args);
 478
 479         if (fd == windrvrfd)
 480                 ret = do_wdioctl(fd, request, argp);
 481         else
 482                 ret = (*ioctl_func) (fd, request, argp);
 483
 484         return ret;
 485 }
 486
 487 #if 0
 488 void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset)
 489 {
 490         static void* (*func) (void *, size_t, int, int, int, off_t) = NULL;
 491         void *ret;
 492
 493         if (!func)
 494                 func = (void* (*) (void *, size_t, int, int, int, off_t)) dlsym (REAL_LIBC, "mmap");
 495
 496         ret = (*func) (start, length, prot, flags, fd, offset);
 497         fprintf(stderr,"MMAP: %x, %d, %d, %d, %d, %d -> %x\n", (unsigned int)start, length, prot, flags, fd, offset, (unsigned int)ret);
 498         mmapped = ret;
 499         mmapplen = length;
 500
 501         return ret;
 502 }
 503
 504 void *mmap64(void *start, size_t length, int prot, int flags, int fd, off64_t offset)
 505 {
 506         static void* (*func) (void *, size_t, int, int, int, off64_t) = NULL;
 507         void *ret;
 508
 509         if (!func)
 510                 func = (void* (*) (void *, size_t, int, int, int, off64_t)) dlsym (REAL_LIBC, "mmap64");
 511
 512         ret = (*func) (start, length, prot, flags, fd, offset);
 513         fprintf(stderr,"MMAP64: %x, %d, %d, %d, %d, %lld -> %x\n", (unsigned int)start, length, prot, flags, fd, offset, (unsigned int)ret);
 514         mmapped = ret;
 515         mmapplen = length;
 516
 517         return ret;
 518 }
 519
 520 void *mmap2(void *start, size_t length, int prot, int flags, int fd, off_t pgoffset)
 521 {
 522         static void* (*func) (void *, size_t, int, int, int, off_t) = NULL;
 523         void *ret;
 524
 525         if (!func)
 526                 func = (void* (*) (void *, size_t, int, int, int, off_t)) dlsym (REAL_LIBC, "mmap2");
 527
 528         ret = (*func) (start, length, prot, flags, fd, pgoffset);
 529         fprintf(stderr,"MMAP2: %x, %d, %d, %d, %d, %d -> %x\n", (unsigned int)start, length, prot, flags, fd, pgoffset, (unsigned int)ret);
 530         mmapped = ret;
 531         mmapplen = length;
 532
 533         return ret;
 534 }
 535
 536 void *malloc(size_t size)
 537 {
 538         static void* (*func) (size_t) = NULL;
 539         void *ret;
 540
 541         if (!func)
 542                 func = (void* (*) (size_t)) dlsym(REAL_LIBC, "malloc");
 543
 544         ret = (*func) (size);
 545
 546         //fprintf(stderr,"MALLOC: %d -> %x\n", size, (unsigned int) ret);
 547
 548         return ret;
 549 }
 550 #endif
 551
 552
 553 #endif