f15910f6d994c5e839dd41058cf7343f688dce81
[usb-driver] / 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
Impressum, Datenschutz