/[rdesktop]/sourceforge.net/trunk/rdesktop/rdpdr.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Contents of /sourceforge.net/trunk/rdesktop/rdpdr.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1402 - (show annotations)
Tue Apr 10 11:22:10 2007 UTC (17 years, 2 months ago) by astrand
File MIME type: text/plain
File size: 27570 byte(s) 
Improve performance of (large) directory listings: Avoid
stat:ing each file many times.

The patch modifies rdesktop so that the g_notify_stamp is only set
when writing. Also, the stamp is not set before disk_create_notify(),
since this would mean that NotifyInfo would be called twice directly.

With this patch, the number of stat:s has dropped from 24 to 4, using
my tests.
1 /* -*- c-basic-offset: 8 -*-
2 rdesktop: A Remote Desktop Protocol client.
3 Copyright (C) Matthew Chapman 1999-2007
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 /*
21 Here are some resources, for your IRP hacking pleasure:
22
23 http://cvs.sourceforge.net/viewcvs.py/mingw/w32api/include/ddk/winddk.h?view=markup
24
25 http://win32.mvps.org/ntfs/streams.cpp
26
27 http://www.acc.umu.se/~bosse/ntifs.h
28
29 http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/NT%20Objects/File/
30
31 http://us1.samba.org/samba/ftp/specs/smb-nt01.txt
32
33 http://www.osronline.com/
34 */
35
36 #include <unistd.h>
37 #include <sys/types.h>
38 #include <sys/time.h>
39 #include <dirent.h> /* opendir, closedir, readdir */
40 #include <time.h>
41 #include <errno.h>
42 #include "rdesktop.h"
43
44 #define IRP_MJ_CREATE 0x00
45 #define IRP_MJ_CLOSE 0x02
46 #define IRP_MJ_READ 0x03
47 #define IRP_MJ_WRITE 0x04
48 #define IRP_MJ_QUERY_INFORMATION 0x05
49 #define IRP_MJ_SET_INFORMATION 0x06
50 #define IRP_MJ_QUERY_VOLUME_INFORMATION 0x0a
51 #define IRP_MJ_DIRECTORY_CONTROL 0x0c
52 #define IRP_MJ_DEVICE_CONTROL 0x0e
53 #define IRP_MJ_LOCK_CONTROL 0x11
54
55 #define IRP_MN_QUERY_DIRECTORY 0x01
56 #define IRP_MN_NOTIFY_CHANGE_DIRECTORY 0x02
57
58 extern char g_hostname[16];
59 extern DEVICE_FNS serial_fns;
60 extern DEVICE_FNS printer_fns;
61 extern DEVICE_FNS parallel_fns;
62 extern DEVICE_FNS disk_fns;
63 #ifdef WITH_SCARD
64 extern DEVICE_FNS scard_fns;
65 #endif
66 extern FILEINFO g_fileinfo[];
67 extern RD_BOOL g_notify_stamp;
68
69 static VCHANNEL *rdpdr_channel;
70
71 /* If select() times out, the request for the device with handle g_min_timeout_fd is aborted */
72 RD_NTHANDLE g_min_timeout_fd;
73 uint32 g_num_devices;
74
75 /* Table with information about rdpdr devices */
76 RDPDR_DEVICE g_rdpdr_device[RDPDR_MAX_DEVICES];
77 char *g_rdpdr_clientname = NULL;
78
79 /* Used to store incoming io request, until they are ready to be completed */
80 /* using a linked list ensures that they are processed in the right order, */
81 /* if multiple ios are being done on the same fd */
82 struct async_iorequest
83 {
84 uint32 fd, major, minor, offset, device, id, length, partial_len;
85 long timeout, /* Total timeout */
86 itv_timeout; /* Interval timeout (between serial characters) */
87 uint8 *buffer;
88 DEVICE_FNS *fns;
89
90 struct async_iorequest *next; /* next element in list */
91 };
92
93 struct async_iorequest *g_iorequest;
94
95 /* Return device_id for a given handle */
96 int
97 get_device_index(RD_NTHANDLE handle)
98 {
99 int i;
100 for (i = 0; i < RDPDR_MAX_DEVICES; i++)
101 {
102 if (g_rdpdr_device[i].handle == handle)
103 return i;
104 }
105 return -1;
106 }
107
108 /* Converts a windows path to a unix path */
109 void
110 convert_to_unix_filename(char *filename)
111 {
112 char *p;
113
114 while ((p = strchr(filename, '\\')))
115 {
116 *p = '/';
117 }
118 }
119
120 static RD_BOOL
121 rdpdr_handle_ok(int device, int handle)
122 {
123 switch (g_rdpdr_device[device].device_type)
124 {
125 case DEVICE_TYPE_PARALLEL:
126 case DEVICE_TYPE_SERIAL:
127 case DEVICE_TYPE_PRINTER:
128 case DEVICE_TYPE_SCARD:
129 if (g_rdpdr_device[device].handle != handle)
130 return False;
131 break;
132 case DEVICE_TYPE_DISK:
133 if (g_fileinfo[handle].device_id != device)
134 return False;
135 break;
136 }
137 return True;
138 }
139
140 /* Add a new io request to the table containing pending io requests so it won't block rdesktop */
141 static RD_BOOL
142 add_async_iorequest(uint32 device, uint32 file, uint32 id, uint32 major, uint32 length,
143 DEVICE_FNS * fns, uint32 total_timeout, uint32 interval_timeout, uint8 * buffer,
144 uint32 offset)
145 {
146 struct async_iorequest *iorq;
147
148 if (g_iorequest == NULL)
149 {
150 g_iorequest = (struct async_iorequest *) xmalloc(sizeof(struct async_iorequest));
151 if (!g_iorequest)
152 return False;
153 g_iorequest->fd = 0;
154 g_iorequest->next = NULL;
155 }
156
157 iorq = g_iorequest;
158
159 while (iorq->fd != 0)
160 {
161 /* create new element if needed */
162 if (iorq->next == NULL)
163 {
164 iorq->next =
165 (struct async_iorequest *) xmalloc(sizeof(struct async_iorequest));
166 if (!iorq->next)
167 return False;
168 iorq->next->fd = 0;
169 iorq->next->next = NULL;
170 }
171 iorq = iorq->next;
172 }
173 iorq->device = device;
174 iorq->fd = file;
175 iorq->id = id;
176 iorq->major = major;
177 iorq->length = length;
178 iorq->partial_len = 0;
179 iorq->fns = fns;
180 iorq->timeout = total_timeout;
181 iorq->itv_timeout = interval_timeout;
182 iorq->buffer = buffer;
183 iorq->offset = offset;
184 return True;
185 }
186
187 static void
188 rdpdr_send_connect(void)
189 {
190 uint8 magic[4] = "rDCC";
191 STREAM s;
192
193 s = channel_init(rdpdr_channel, 12);
194 out_uint8a(s, magic, 4);
195 out_uint16_le(s, 1); /* unknown */
196 out_uint16_le(s, 5);
197 out_uint32_be(s, 0x815ed39d); /* IP address (use 127.0.0.1) 0x815ed39d */
198 s_mark_end(s);
199 channel_send(s, rdpdr_channel);
200 }
201
202
203 static void
204 rdpdr_send_name(void)
205 {
206 uint8 magic[4] = "rDNC";
207 STREAM s;
208 uint32 hostlen;
209
210 if (NULL == g_rdpdr_clientname)
211 {
212 g_rdpdr_clientname = g_hostname;
213 }
214 hostlen = (strlen(g_rdpdr_clientname) + 1) * 2;
215
216 s = channel_init(rdpdr_channel, 16 + hostlen);
217 out_uint8a(s, magic, 4);
218 out_uint16_le(s, 0x63); /* unknown */
219 out_uint16_le(s, 0x72);
220 out_uint32(s, 0);
221 out_uint32_le(s, hostlen);
222 rdp_out_unistr(s, g_rdpdr_clientname, hostlen - 2);
223 s_mark_end(s);
224 channel_send(s, rdpdr_channel);
225 }
226
227 /* Returns the size of the payload of the announce packet */
228 static int
229 announcedata_size()
230 {
231 int size, i;
232 PRINTER *printerinfo;
233
234 size = 8; /* static announce size */
235 size += g_num_devices * 0x14;
236
237 for (i = 0; i < g_num_devices; i++)
238 {
239 if (g_rdpdr_device[i].device_type == DEVICE_TYPE_PRINTER)
240 {
241 printerinfo = (PRINTER *) g_rdpdr_device[i].pdevice_data;
242 printerinfo->bloblen =
243 printercache_load_blob(printerinfo->printer, &(printerinfo->blob));
244
245 size += 0x18;
246 size += 2 * strlen(printerinfo->driver) + 2;
247 size += 2 * strlen(printerinfo->printer) + 2;
248 size += printerinfo->bloblen;
249 }
250 }
251
252 return size;
253 }
254
255 static void
256 rdpdr_send_available(void)
257 {
258
259 uint8 magic[4] = "rDAD";
260 uint32 driverlen, printerlen, bloblen;
261 int i;
262 STREAM s;
263 PRINTER *printerinfo;
264
265 s = channel_init(rdpdr_channel, announcedata_size());
266 out_uint8a(s, magic, 4);
267 out_uint32_le(s, g_num_devices);
268
269 for (i = 0; i < g_num_devices; i++)
270 {
271 out_uint32_le(s, g_rdpdr_device[i].device_type);
272 out_uint32_le(s, i); /* RDP Device ID */
273 /* Is it possible to use share names longer than 8 chars?
274 /astrand */
275 out_uint8p(s, g_rdpdr_device[i].name, 8);
276
277 switch (g_rdpdr_device[i].device_type)
278 {
279 case DEVICE_TYPE_PRINTER:
280 printerinfo = (PRINTER *) g_rdpdr_device[i].pdevice_data;
281
282 driverlen = 2 * strlen(printerinfo->driver) + 2;
283 printerlen = 2 * strlen(printerinfo->printer) + 2;
284 bloblen = printerinfo->bloblen;
285
286 out_uint32_le(s, 24 + driverlen + printerlen + bloblen); /* length of extra info */
287 out_uint32_le(s, printerinfo->default_printer ? 2 : 0);
288 out_uint8s(s, 8); /* unknown */
289 out_uint32_le(s, driverlen);
290 out_uint32_le(s, printerlen);
291 out_uint32_le(s, bloblen);
292 rdp_out_unistr(s, printerinfo->driver, driverlen - 2);
293 rdp_out_unistr(s, printerinfo->printer, printerlen - 2);
294 out_uint8a(s, printerinfo->blob, bloblen);
295
296 if (printerinfo->blob)
297 xfree(printerinfo->blob); /* Blob is sent twice if reconnecting */
298 break;
299 default:
300 out_uint32(s, 0);
301 }
302 }
303 #if 0
304 out_uint32_le(s, 0x20); /* Device type 0x20 - smart card */
305 out_uint32_le(s, 0);
306 out_uint8p(s, "SCARD", 5);
307 out_uint8s(s, 3);
308 out_uint32(s, 0);
309 #endif
310
311 s_mark_end(s);
312 channel_send(s, rdpdr_channel);
313 }
314
315 void
316 rdpdr_send_completion(uint32 device, uint32 id, uint32 status, uint32 result, uint8 * buffer,
317 uint32 length)
318 {
319 uint8 magic[4] = "rDCI";
320 STREAM s;
321
322 #ifdef WITH_SCARD
323 scard_lock(SCARD_LOCK_RDPDR);
324 #endif
325 s = channel_init(rdpdr_channel, 20 + length);
326 out_uint8a(s, magic, 4);
327 out_uint32_le(s, device);
328 out_uint32_le(s, id);
329 out_uint32_le(s, status);
330 out_uint32_le(s, result);
331 out_uint8p(s, buffer, length);
332 s_mark_end(s);
333 /* JIF */
334 #ifdef WITH_DEBUG_RDP5
335 printf("--> rdpdr_send_completion\n");
336 /* hexdump(s->channel_hdr + 8, s->end - s->channel_hdr - 8); */
337 #endif
338 channel_send(s, rdpdr_channel);
339 #ifdef WITH_SCARD
340 scard_unlock(SCARD_LOCK_RDPDR);
341 #endif
342 }
343
344 static void
345 rdpdr_process_irp(STREAM s)
346 {
347 uint32 result = 0,
348 length = 0,
349 desired_access = 0,
350 request,
351 file,
352 info_level,
353 buffer_len,
354 id,
355 major,
356 minor,
357 device,
358 offset,
359 bytes_in,
360 bytes_out,
361 error_mode,
362 share_mode, disposition, total_timeout, interval_timeout, flags_and_attributes = 0;
363
364 char filename[PATH_MAX];
365 uint8 *buffer, *pst_buf;
366 struct stream out;
367 DEVICE_FNS *fns;
368 RD_BOOL rw_blocking = True;
369 RD_NTSTATUS status = RD_STATUS_INVALID_DEVICE_REQUEST;
370
371 in_uint32_le(s, device);
372 in_uint32_le(s, file);
373 in_uint32_le(s, id);
374 in_uint32_le(s, major);
375 in_uint32_le(s, minor);
376
377 buffer_len = 0;
378 buffer = (uint8 *) xmalloc(1024);
379 buffer[0] = 0;
380
381 switch (g_rdpdr_device[device].device_type)
382 {
383 case DEVICE_TYPE_SERIAL:
384
385 fns = &serial_fns;
386 rw_blocking = False;
387 break;
388
389 case DEVICE_TYPE_PARALLEL:
390
391 fns = &parallel_fns;
392 rw_blocking = False;
393 break;
394
395 case DEVICE_TYPE_PRINTER:
396
397 fns = &printer_fns;
398 break;
399
400 case DEVICE_TYPE_DISK:
401
402 fns = &disk_fns;
403 rw_blocking = False;
404 break;
405
406 case DEVICE_TYPE_SCARD:
407 #ifdef WITH_SCARD
408 fns = &scard_fns;
409 rw_blocking = False;
410 break;
411 #endif
412 default:
413
414 error("IRP for bad device %ld\n", device);
415 return;
416 }
417
418 switch (major)
419 {
420 case IRP_MJ_CREATE:
421
422 in_uint32_be(s, desired_access);
423 in_uint8s(s, 0x08); /* unknown */
424 in_uint32_le(s, error_mode);
425 in_uint32_le(s, share_mode);
426 in_uint32_le(s, disposition);
427 in_uint32_le(s, flags_and_attributes);
428 in_uint32_le(s, length);
429
430 if (length && (length / 2) < 256)
431 {
432 rdp_in_unistr(s, filename, length);
433 convert_to_unix_filename(filename);
434 }
435 else
436 {
437 filename[0] = 0;
438 }
439
440 if (!fns->create)
441 {
442 status = RD_STATUS_NOT_SUPPORTED;
443 break;
444 }
445
446 status = fns->create(device, desired_access, share_mode, disposition,
447 flags_and_attributes, filename, &result);
448 buffer_len = 1;
449 break;
450
451 case IRP_MJ_CLOSE:
452 if (!fns->close)
453 {
454 status = RD_STATUS_NOT_SUPPORTED;
455 break;
456 }
457
458 status = fns->close(file);
459 break;
460
461 case IRP_MJ_READ:
462
463 if (!fns->read)
464 {
465 status = RD_STATUS_NOT_SUPPORTED;
466 break;
467 }
468
469 in_uint32_le(s, length);
470 in_uint32_le(s, offset);
471 #if WITH_DEBUG_RDP5
472 DEBUG(("RDPDR IRP Read (length: %d, offset: %d)\n", length, offset));
473 #endif
474 if (!rdpdr_handle_ok(device, file))
475 {
476 status = RD_STATUS_INVALID_HANDLE;
477 break;
478 }
479
480 if (rw_blocking) /* Complete read immediately */
481 {
482 buffer = (uint8 *) xrealloc((void *) buffer, length);
483 if (!buffer)
484 {
485 status = RD_STATUS_CANCELLED;
486 break;
487 }
488 status = fns->read(file, buffer, length, offset, &result);
489 buffer_len = result;
490 break;
491 }
492
493 /* Add request to table */
494 pst_buf = (uint8 *) xmalloc(length);
495 if (!pst_buf)
496 {
497 status = RD_STATUS_CANCELLED;
498 break;
499 }
500 serial_get_timeout(file, length, &total_timeout, &interval_timeout);
501 if (add_async_iorequest
502 (device, file, id, major, length, fns, total_timeout, interval_timeout,
503 pst_buf, offset))
504 {
505 status = RD_STATUS_PENDING;
506 break;
507 }
508
509 status = RD_STATUS_CANCELLED;
510 break;
511 case IRP_MJ_WRITE:
512
513 buffer_len = 1;
514
515 if (!fns->write)
516 {
517 status = RD_STATUS_NOT_SUPPORTED;
518 break;
519 }
520
521 in_uint32_le(s, length);
522 in_uint32_le(s, offset);
523 in_uint8s(s, 0x18);
524 #if WITH_DEBUG_RDP5
525 DEBUG(("RDPDR IRP Write (length: %d)\n", result));
526 #endif
527 if (!rdpdr_handle_ok(device, file))
528 {
529 status = RD_STATUS_INVALID_HANDLE;
530 break;
531 }
532
533 if (rw_blocking) /* Complete immediately */
534 {
535 status = fns->write(file, s->p, length, offset, &result);
536 break;
537 }
538
539 /* Add to table */
540 pst_buf = (uint8 *) xmalloc(length);
541 if (!pst_buf)
542 {
543 status = RD_STATUS_CANCELLED;
544 break;
545 }
546
547 in_uint8a(s, pst_buf, length);
548
549 if (add_async_iorequest
550 (device, file, id, major, length, fns, 0, 0, pst_buf, offset))
551 {
552 status = RD_STATUS_PENDING;
553 break;
554 }
555
556 status = RD_STATUS_CANCELLED;
557 break;
558
559 case IRP_MJ_QUERY_INFORMATION:
560
561 if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
562 {
563 status = RD_STATUS_INVALID_HANDLE;
564 break;
565 }
566 in_uint32_le(s, info_level);
567
568 out.data = out.p = buffer;
569 out.size = sizeof(buffer);
570 status = disk_query_information(file, info_level, &out);
571 result = buffer_len = out.p - out.data;
572
573 break;
574
575 case IRP_MJ_SET_INFORMATION:
576
577 if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
578 {
579 status = RD_STATUS_INVALID_HANDLE;
580 break;
581 }
582
583 in_uint32_le(s, info_level);
584
585 out.data = out.p = buffer;
586 out.size = sizeof(buffer);
587 status = disk_set_information(file, info_level, s, &out);
588 result = buffer_len = out.p - out.data;
589 break;
590
591 case IRP_MJ_QUERY_VOLUME_INFORMATION:
592
593 if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
594 {
595 status = RD_STATUS_INVALID_HANDLE;
596 break;
597 }
598
599 in_uint32_le(s, info_level);
600
601 out.data = out.p = buffer;
602 out.size = sizeof(buffer);
603 status = disk_query_volume_information(file, info_level, &out);
604 result = buffer_len = out.p - out.data;
605 break;
606
607 case IRP_MJ_DIRECTORY_CONTROL:
608
609 if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
610 {
611 status = RD_STATUS_INVALID_HANDLE;
612 break;
613 }
614
615 switch (minor)
616 {
617 case IRP_MN_QUERY_DIRECTORY:
618
619 in_uint32_le(s, info_level);
620 in_uint8s(s, 1);
621 in_uint32_le(s, length);
622 in_uint8s(s, 0x17);
623 if (length && length < 2 * 255)
624 {
625 rdp_in_unistr(s, filename, length);
626 convert_to_unix_filename(filename);
627 }
628 else
629 {
630 filename[0] = 0;
631 }
632 out.data = out.p = buffer;
633 out.size = sizeof(buffer);
634 status = disk_query_directory(file, info_level, filename,
635 &out);
636 result = buffer_len = out.p - out.data;
637 if (!buffer_len)
638 buffer_len++;
639 break;
640
641 case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
642
643 /* JIF
644 unimpl("IRP major=0x%x minor=0x%x: IRP_MN_NOTIFY_CHANGE_DIRECTORY\n", major, minor); */
645
646 in_uint32_le(s, info_level); /* notify mask */
647
648 status = disk_create_notify(file, info_level);
649 result = 0;
650
651 if (status == RD_STATUS_PENDING)
652 add_async_iorequest(device, file, id, major, length,
653 fns, 0, 0, NULL, 0);
654 break;
655
656 default:
657
658 status = RD_STATUS_INVALID_PARAMETER;
659 /* JIF */
660 unimpl("IRP major=0x%x minor=0x%x\n", major, minor);
661 }
662 break;
663
664 case IRP_MJ_DEVICE_CONTROL:
665
666 if (!fns->device_control)
667 {
668 status = RD_STATUS_NOT_SUPPORTED;
669 break;
670 }
671
672 in_uint32_le(s, bytes_out);
673 in_uint32_le(s, bytes_in);
674 in_uint32_le(s, request);
675 in_uint8s(s, 0x14);
676
677 buffer = (uint8 *) xrealloc((void *) buffer, bytes_out + 0x14);
678 if (!buffer)
679 {
680 status = RD_STATUS_CANCELLED;
681 break;
682 }
683
684 out.data = out.p = buffer;
685 out.size = sizeof(buffer);
686
687 DEBUG_SCARD(("[SMART-CARD TRACE]\n"));
688 DEBUG_SCARD(("device 0x%.8x\n", device));
689 DEBUG_SCARD(("file 0x%.8x\n", file));
690 DEBUG_SCARD(("id 0x%.8x\n", id));
691 #ifdef WITH_SCARD
692 scardSetInfo(device, id, bytes_out + 0x14);
693 #endif
694 status = fns->device_control(file, request, s, &out);
695 result = buffer_len = out.p - out.data;
696
697 DEBUG_SCARD(("[SMART-CARD TRACE] OUT 0x%.8x\n", status));
698
699 /* Serial SERIAL_WAIT_ON_MASK */
700 if (status == RD_STATUS_PENDING)
701 {
702 if (add_async_iorequest
703 (device, file, id, major, length, fns, 0, 0, NULL, 0))
704 {
705 status = RD_STATUS_PENDING;
706 break;
707 }
708 }
709 #ifdef WITH_SCARD
710 else if (status == (RD_STATUS_PENDING | 0xC0000000))
711 status = RD_STATUS_PENDING;
712 #endif
713 break;
714
715
716 case IRP_MJ_LOCK_CONTROL:
717
718 if (g_rdpdr_device[device].device_type != DEVICE_TYPE_DISK)
719 {
720 status = RD_STATUS_INVALID_HANDLE;
721 break;
722 }
723
724 in_uint32_le(s, info_level);
725
726 out.data = out.p = buffer;
727 out.size = sizeof(buffer);
728 /* FIXME: Perhaps consider actually *do*
729 something here :-) */
730 status = RD_STATUS_SUCCESS;
731 result = buffer_len = out.p - out.data;
732 break;
733
734 default:
735 unimpl("IRP major=0x%x minor=0x%x\n", major, minor);
736 break;
737 }
738
739 if (status != RD_STATUS_PENDING)
740 {
741 rdpdr_send_completion(device, id, status, result, buffer, buffer_len);
742 }
743 if (buffer)
744 xfree(buffer);
745 buffer = NULL;
746 }
747
748 static void
749 rdpdr_send_clientcapabilty(void)
750 {
751 uint8 magic[4] = "rDPC";
752 STREAM s;
753
754 s = channel_init(rdpdr_channel, 0x50);
755 out_uint8a(s, magic, 4);
756 out_uint32_le(s, 5); /* count */
757 out_uint16_le(s, 1); /* first */
758 out_uint16_le(s, 0x28); /* length */
759 out_uint32_le(s, 1);
760 out_uint32_le(s, 2);
761 out_uint16_le(s, 2);
762 out_uint16_le(s, 5);
763 out_uint16_le(s, 1);
764 out_uint16_le(s, 5);
765 out_uint16_le(s, 0xFFFF);
766 out_uint16_le(s, 0);
767 out_uint32_le(s, 0);
768 out_uint32_le(s, 3);
769 out_uint32_le(s, 0);
770 out_uint32_le(s, 0);
771 out_uint16_le(s, 2); /* second */
772 out_uint16_le(s, 8); /* length */
773 out_uint32_le(s, 1);
774 out_uint16_le(s, 3); /* third */
775 out_uint16_le(s, 8); /* length */
776 out_uint32_le(s, 1);
777 out_uint16_le(s, 4); /* fourth */
778 out_uint16_le(s, 8); /* length */
779 out_uint32_le(s, 1);
780 out_uint16_le(s, 5); /* fifth */
781 out_uint16_le(s, 8); /* length */
782 out_uint32_le(s, 1);
783
784 s_mark_end(s);
785 channel_send(s, rdpdr_channel);
786 }
787
788 static void
789 rdpdr_process(STREAM s)
790 {
791 uint32 handle;
792 uint8 *magic;
793
794 #if WITH_DEBUG_RDP5
795 printf("--- rdpdr_process ---\n");
796 hexdump(s->p, s->end - s->p);
797 #endif
798 in_uint8p(s, magic, 4);
799
800 if ((magic[0] == 'r') && (magic[1] == 'D'))
801 {
802 if ((magic[2] == 'R') && (magic[3] == 'I'))
803 {
804 rdpdr_process_irp(s);
805 return;
806 }
807 if ((magic[2] == 'n') && (magic[3] == 'I'))
808 {
809 rdpdr_send_connect();
810 rdpdr_send_name();
811 return;
812 }
813 if ((magic[2] == 'C') && (magic[3] == 'C'))
814 {
815 /* connect from server */
816 rdpdr_send_clientcapabilty();
817 rdpdr_send_available();
818 return;
819 }
820 if ((magic[2] == 'r') && (magic[3] == 'd'))
821 {
822 /* connect to a specific resource */
823 in_uint32(s, handle);
824 #if WITH_DEBUG_RDP5
825 DEBUG(("RDPDR: Server connected to resource %d\n", handle));
826 #endif
827 return;
828 }
829 if ((magic[2] == 'P') && (magic[3] == 'S'))
830 {
831 /* server capability */
832 return;
833 }
834 }
835 if ((magic[0] == 'R') && (magic[1] == 'P'))
836 {
837 if ((magic[2] == 'C') && (magic[3] == 'P'))
838 {
839 printercache_process(s);
840 return;
841 }
842 }
843 unimpl("RDPDR packet type %c%c%c%c\n", magic[0], magic[1], magic[2], magic[3]);
844 }
845
846 RD_BOOL
847 rdpdr_init()
848 {
849 if (g_num_devices > 0)
850 {
851 rdpdr_channel =
852 channel_register("rdpdr",
853 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_COMPRESS_RDP,
854 rdpdr_process);
855 }
856
857 return (rdpdr_channel != NULL);
858 }
859
860 /* Add file descriptors of pending io request to select() */
861 void
862 rdpdr_add_fds(int *n, fd_set * rfds, fd_set * wfds, struct timeval *tv, RD_BOOL * timeout)
863 {
864 uint32 select_timeout = 0; /* Timeout value to be used for select() (in millisecons). */
865 struct async_iorequest *iorq;
866 char c;
867
868 iorq = g_iorequest;
869 while (iorq != NULL)
870 {
871 if (iorq->fd != 0)
872 {
873 switch (iorq->major)
874 {
875 case IRP_MJ_READ:
876 /* Is this FD valid? FDs will
877 be invalid when
878 reconnecting. FIXME: Real
879 support for reconnects. */
880
881 FD_SET(iorq->fd, rfds);
882 *n = MAX(*n, iorq->fd);
883
884 /* Check if io request timeout is smaller than current (but not 0). */
885 if (iorq->timeout
886 && (select_timeout == 0
887 || iorq->timeout < select_timeout))
888 {
889 /* Set new timeout */
890 select_timeout = iorq->timeout;
891 g_min_timeout_fd = iorq->fd; /* Remember fd */
892 tv->tv_sec = select_timeout / 1000;
893 tv->tv_usec = (select_timeout % 1000) * 1000;
894 *timeout = True;
895 break;
896 }
897 if (iorq->itv_timeout && iorq->partial_len > 0
898 && (select_timeout == 0
899 || iorq->itv_timeout < select_timeout))
900 {
901 /* Set new timeout */
902 select_timeout = iorq->itv_timeout;
903 g_min_timeout_fd = iorq->fd; /* Remember fd */
904 tv->tv_sec = select_timeout / 1000;
905 tv->tv_usec = (select_timeout % 1000) * 1000;
906 *timeout = True;
907 break;
908 }
909 break;
910
911 case IRP_MJ_WRITE:
912 /* FD still valid? See above. */
913 if ((write(iorq->fd, &c, 0) != 0) && (errno == EBADF))
914 break;
915
916 FD_SET(iorq->fd, wfds);
917 *n = MAX(*n, iorq->fd);
918 break;
919
920 case IRP_MJ_DEVICE_CONTROL:
921 if (select_timeout > 5)
922 select_timeout = 5; /* serial event queue */
923 break;
924
925 }
926
927 }
928
929 iorq = iorq->next;
930 }
931 }
932
933 struct async_iorequest *
934 rdpdr_remove_iorequest(struct async_iorequest *prev, struct async_iorequest *iorq)
935 {
936 if (!iorq)
937 return NULL;
938
939 if (iorq->buffer)
940 xfree(iorq->buffer);
941 if (prev)
942 {
943 prev->next = iorq->next;
944 xfree(iorq);
945 iorq = prev->next;
946 }
947 else
948 {
949 /* Even if NULL */
950 g_iorequest = iorq->next;
951 xfree(iorq);
952 iorq = NULL;
953 }
954 return iorq;
955 }
956
957 /* Check if select() returned with one of the rdpdr file descriptors, and complete io if it did */
958 static void
959 _rdpdr_check_fds(fd_set * rfds, fd_set * wfds, RD_BOOL timed_out)
960 {
961 RD_NTSTATUS status;
962 uint32 result = 0;
963 DEVICE_FNS *fns;
964 struct async_iorequest *iorq;
965 struct async_iorequest *prev;
966 uint32 req_size = 0;
967 uint32 buffer_len;
968 struct stream out;
969 uint8 *buffer = NULL;
970
971
972 if (timed_out)
973 {
974 /* check serial iv_timeout */
975
976 iorq = g_iorequest;
977 prev = NULL;
978 while (iorq != NULL)
979 {
980 if (iorq->fd == g_min_timeout_fd)
981 {
982 if ((iorq->partial_len > 0) &&
983 (g_rdpdr_device[iorq->device].device_type ==
984 DEVICE_TYPE_SERIAL))
985 {
986
987 /* iv_timeout between 2 chars, send partial_len */
988 /*printf("RDPDR: IVT total %u bytes read of %u\n", iorq->partial_len, iorq->length); */
989 rdpdr_send_completion(iorq->device,
990 iorq->id, RD_STATUS_SUCCESS,
991 iorq->partial_len,
992 iorq->buffer, iorq->partial_len);
993 iorq = rdpdr_remove_iorequest(prev, iorq);
994 return;
995 }
996 else
997 {
998 break;
999 }
1000
1001 }
1002 else
1003 {
1004 break;
1005 }
1006
1007
1008 prev = iorq;
1009 if (iorq)
1010 iorq = iorq->next;
1011
1012 }
1013
1014 rdpdr_abort_io(g_min_timeout_fd, 0, RD_STATUS_TIMEOUT);
1015 return;
1016 }
1017
1018 iorq = g_iorequest;
1019 prev = NULL;
1020 while (iorq != NULL)
1021 {
1022 if (iorq->fd != 0)
1023 {
1024 switch (iorq->major)
1025 {
1026 case IRP_MJ_READ:
1027 if (FD_ISSET(iorq->fd, rfds))
1028 {
1029 /* Read the data */
1030 fns = iorq->fns;
1031
1032 req_size =
1033 (iorq->length - iorq->partial_len) >
1034 8192 ? 8192 : (iorq->length -
1035 iorq->partial_len);
1036 /* never read larger chunks than 8k - chances are that it will block */
1037 status = fns->read(iorq->fd,
1038 iorq->buffer + iorq->partial_len,
1039 req_size, iorq->offset, &result);
1040
1041 if ((long) result > 0)
1042 {
1043 iorq->partial_len += result;
1044 iorq->offset += result;
1045 }
1046 #if WITH_DEBUG_RDP5
1047 DEBUG(("RDPDR: %d bytes of data read\n", result));
1048 #endif
1049 /* only delete link if all data has been transfered */
1050 /* or if result was 0 and status success - EOF */
1051 if ((iorq->partial_len == iorq->length) ||
1052 (result == 0))
1053 {
1054 #if WITH_DEBUG_RDP5
1055 DEBUG(("RDPDR: AIO total %u bytes read of %u\n", iorq->partial_len, iorq->length));
1056 #endif
1057 rdpdr_send_completion(iorq->device,
1058 iorq->id, status,
1059 iorq->partial_len,
1060 iorq->buffer,
1061 iorq->partial_len);
1062 iorq = rdpdr_remove_iorequest(prev, iorq);
1063 }
1064 }
1065 break;
1066 case IRP_MJ_WRITE:
1067 if (FD_ISSET(iorq->fd, wfds))
1068 {
1069 /* Write data. */
1070 fns = iorq->fns;
1071
1072 req_size =
1073 (iorq->length - iorq->partial_len) >
1074 8192 ? 8192 : (iorq->length -
1075 iorq->partial_len);
1076
1077 /* never write larger chunks than 8k - chances are that it will block */
1078 status = fns->write(iorq->fd,
1079 iorq->buffer +
1080 iorq->partial_len, req_size,
1081 iorq->offset, &result);
1082
1083 if ((long) result > 0)
1084 {
1085 iorq->partial_len += result;
1086 iorq->offset += result;
1087 }
1088
1089 #if WITH_DEBUG_RDP5
1090 DEBUG(("RDPDR: %d bytes of data written\n",
1091 result));
1092 #endif
1093 /* only delete link if all data has been transfered */
1094 /* or we couldn't write */
1095 if ((iorq->partial_len == iorq->length)
1096 || (result == 0))
1097 {
1098 #if WITH_DEBUG_RDP5
1099 DEBUG(("RDPDR: AIO total %u bytes written of %u\n", iorq->partial_len, iorq->length));
1100 #endif
1101 rdpdr_send_completion(iorq->device,
1102 iorq->id, status,
1103 iorq->partial_len,
1104 (uint8 *) "", 1);
1105
1106 iorq = rdpdr_remove_iorequest(prev, iorq);
1107 }
1108 }
1109 break;
1110 case IRP_MJ_DEVICE_CONTROL:
1111 if (serial_get_event(iorq->fd, &result))
1112 {
1113 buffer = (uint8 *) xrealloc((void *) buffer, 0x14);
1114 out.data = out.p = buffer;
1115 out.size = sizeof(buffer);
1116 out_uint32_le(&out, result);
1117 result = buffer_len = out.p - out.data;
1118 status = RD_STATUS_SUCCESS;
1119 rdpdr_send_completion(iorq->device, iorq->id,
1120 status, result, buffer,
1121 buffer_len);
1122 xfree(buffer);
1123 iorq = rdpdr_remove_iorequest(prev, iorq);
1124 }
1125
1126 break;
1127 }
1128
1129 }
1130 prev = iorq;
1131 if (iorq)
1132 iorq = iorq->next;
1133 }
1134
1135 /* Check notify */
1136 iorq = g_iorequest;
1137 prev = NULL;
1138 while (iorq != NULL)
1139 {
1140 if (iorq->fd != 0)
1141 {
1142 switch (iorq->major)
1143 {
1144
1145 case IRP_MJ_DIRECTORY_CONTROL:
1146 if (g_rdpdr_device[iorq->device].device_type ==
1147 DEVICE_TYPE_DISK)
1148 {
1149
1150 if (g_notify_stamp)
1151 {
1152 g_notify_stamp = False;
1153 status = disk_check_notify(iorq->fd);
1154 if (status != RD_STATUS_PENDING)
1155 {
1156 rdpdr_send_completion(iorq->device,
1157 iorq->id,
1158 status, 0,
1159 NULL, 0);
1160 iorq = rdpdr_remove_iorequest(prev,
1161 iorq);
1162 }
1163 }
1164 }
1165 break;
1166
1167
1168
1169 }
1170 }
1171
1172 prev = iorq;
1173 if (iorq)
1174 iorq = iorq->next;
1175 }
1176
1177 }
1178
1179 void
1180 rdpdr_check_fds(fd_set * rfds, fd_set * wfds, RD_BOOL timed_out)
1181 {
1182 fd_set dummy;
1183
1184
1185 FD_ZERO(&dummy);
1186
1187
1188 /* fist check event queue only,
1189 any serial wait event must be done before read block will be sent
1190 */
1191
1192 _rdpdr_check_fds(&dummy, &dummy, False);
1193 _rdpdr_check_fds(rfds, wfds, timed_out);
1194 }
1195
1196
1197 /* Abort a pending io request for a given handle and major */
1198 RD_BOOL
1199 rdpdr_abort_io(uint32 fd, uint32 major, RD_NTSTATUS status)
1200 {
1201 uint32 result;
1202 struct async_iorequest *iorq;
1203 struct async_iorequest *prev;
1204
1205 iorq = g_iorequest;
1206 prev = NULL;
1207 while (iorq != NULL)
1208 {
1209 /* Only remove from table when major is not set, or when correct major is supplied.
1210 Abort read should not abort a write io request. */
1211 if ((iorq->fd == fd) && (major == 0 || iorq->major == major))
1212 {
1213 result = 0;
1214 rdpdr_send_completion(iorq->device, iorq->id, status, result, (uint8 *) "",
1215 1);
1216
1217 iorq = rdpdr_remove_iorequest(prev, iorq);
1218 return True;
1219 }
1220
1221 prev = iorq;
1222 iorq = iorq->next;
1223 }
1224
1225 return False;
1226 }
  ViewVC Help
Powered by ViewVC 1.1.26