trunk/rdesktop/rdpdr.c

#include "rdesktop.h"

#define IRP_MJ_CREATE           0x00
#define IRP_MJ_CLOSE            0x02
#define IRP_MJ_READ             0x03
#define IRP_MJ_WRITE            0x04
#define IRP_MJ_DEVICE_CONTROL   0x0e

extern char hostname[16];
extern DEVICE_FNS serial_fns;
extern DEVICE_FNS printer_fns;

static VCHANNEL *rdpdr_channel;

void
rdpdr_send_connect(void)
{
        uint8 magic[4] = "rDCC";
        STREAM s;

        s = channel_init(rdpdr_channel, 12);
        out_uint8a(s, magic, 4);
        out_uint16_le(s, 1); /* unknown */
        out_uint16_le(s, 5);
        out_uint32_be(s, 0x815ed39d); /* IP address (use 127.0.0.1) 0x815ed39d */
        s_mark_end(s);
        channel_send(s, rdpdr_channel);
}

void
rdpdr_send_name(void)
{
        uint8 magic[4] = "rDNC";
        uint32 hostlen = (strlen(hostname)+1)*2;
        STREAM s;

        s = channel_init(rdpdr_channel, 16+hostlen);
        out_uint8a(s, magic, 4);
        out_uint16_le(s, 0x63); /* unknown */
        out_uint16_le(s, 0x72);
        out_uint32(s, 0);
        out_uint32_le(s, hostlen);
        rdp_out_unistr(s, hostname, hostlen-2);
        s_mark_end(s);
        channel_send(s, rdpdr_channel);
}

void
rdpdr_send_available(void)
{
        uint8 magic[4] = "rDAD";
        char *driver = "Digital turbo PrintServer 20"; /* Fairly generic PostScript driver */
        char *printer = "PostScript";
        uint32 driverlen = (strlen(driver)+1)*2;
        uint32 printerlen = (strlen(printer)+1)*2;
        STREAM s;

        s = channel_init(rdpdr_channel, 8+20);
        out_uint8a(s, magic, 4);
        out_uint32_le(s, 1); /* Number of devices */

#if 1
        out_uint32_le(s, 0x1);  /* Device type 0x1 - serial */
        out_uint32_le(s, 0);    /* Handle */
        out_uint8p(s, "COM2", 4);
        out_uint8s(s, 4);       /* Pad to 8 */
        out_uint32(s, 0);
#endif
#if 0
        out_uint32_le(s, 0x2); /* Device type 0x2 - parallel */
        out_uint32_le(s, 0);
        out_uint8p(s, "LPT2", 4);
        out_uint8s(s, 4);
        out_uint32(s, 0);
#endif
#if 1
        out_uint32_le(s, 0x4); /* Device type 0x4 - printer */
        out_uint32_le(s, 1);
        out_uint8p(s, "PRN1", 4);
        out_uint8s(s, 4);
        out_uint32_le(s, 24+driverlen+printerlen); /* length of extra info */
        out_uint32_le(s, 2); /* unknown */
        out_uint8s(s, 8); /* unknown */
        out_uint32_le(s, driverlen); /* length of driver name */
        out_uint32_le(s, printerlen); /* length of printer name */
        out_uint32(s, 0); /* unknown */
        rdp_out_unistr(s, driver, driverlen-2);
        rdp_out_unistr(s, printer, printerlen-2);
#endif
#if 0
        out_uint32_le(s, 0x8); /* Device type 0x8 - disk */
        out_uint32_le(s, 0);
        out_uint8p(s, "Z:", 2);
        out_uint8s(s, 6);
        out_uint32(s, 0);
#endif
#if 0
        out_uint32_le(s, 0x20); /* Device type 0x20 - smart card */
        out_uint32_le(s, 0);
        out_uint8p(s, "SCARD", 5);
        out_uint8s(s, 3);
        out_uint32(s, 0);
#endif

        s_mark_end(s);
        channel_send(s, rdpdr_channel);
}

void
rdpdr_send_completion(uint32 device, uint32 id, uint32 status, uint32 result, uint8 *buffer, uint32 length)
{
        uint8 magic[4] = "rDCI";
        STREAM s;

        s = channel_init(rdpdr_channel, 20 + length);
        out_uint8a(s, magic, 4);
        out_uint32_le(s, device);
        out_uint32_le(s, id);
        out_uint32_le(s, status);
        out_uint32_le(s, result);
        out_uint8p(s, buffer, length);
        s_mark_end(s);
        hexdump(s->channel_hdr+8, s->end-s->channel_hdr-8);
        channel_send(s, rdpdr_channel);
}

static void
rdpdr_process_irp(STREAM s)
{
        uint32 device, file, id, major, minor;
        NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
        uint32 result = 0, length, request, bytes_in, bytes_out;
        uint8 buffer[256];
        uint32 buffer_len = 1;
        struct stream out;
        DEVICE_FNS *fns;

        in_uint32_le(s, device);
        in_uint32_le(s, file);
        in_uint32_le(s, id);
        in_uint32_le(s, major);
        in_uint32_le(s, minor);

        memset(buffer, 0, sizeof(buffer));

        /* FIXME: this should probably be a more dynamic mapping */
        switch (device)
        {
                case 0:
                        fns = &serial_fns;
                case 1:
                        fns = &printer_fns;
                default:
                        error("IRP for bad device %ld\n", device);
                        return;
        }

        switch (major)
        {
                case IRP_MJ_CREATE:
                        if (fns->create)
                                status = fns->create(&result);
                        break;

                case IRP_MJ_CLOSE:
                        if (fns->close)
                                status = fns->close(file);
                        break;

                case IRP_MJ_READ:
                        if (fns->read)
                        {
                                if (length > sizeof(buffer))
                                        length = sizeof(buffer);
                                status = fns->read(file, buffer, length, &result);
                                buffer_len = result;
                        }
                        break;

                case IRP_MJ_WRITE:
                        if (fns->write)
                                status = fns->write(file, s->p, length, &result);
                        break;

                case IRP_MJ_DEVICE_CONTROL:
                        if (fns->device_control)
                        {
                                in_uint32_le(s, bytes_out);
                                in_uint32_le(s, bytes_in);
                                in_uint32_le(s, request);
                                in_uint8s(s, 0x14);
                                out.data = out.p = buffer;
                                out.size = sizeof(buffer);
                                status = fns->device_control(file, request, s, &out);
                                result = buffer_len = out.p - out.data;
                        }
                        break;

                default:
                        unimpl("IRP major=0x%x minor=0x%x\n", major, minor);
                        break;
        }

        rdpdr_send_completion(device, id, status, result, buffer, buffer_len);
}

static void
rdpdr_process(STREAM s)
{
        uint32 handle;
        char *magic;

        printf("rdpdr_process\n");
        hexdump(s->p, s->end-s->p);
        in_uint8p(s, magic, 4);

        if ((magic[0] == 'r') && (magic[1] == 'D'))
        {
                if ((magic[2] == 'R') && (magic[3] == 'I'))
                {
                        rdpdr_process_irp(s);
                        return;
                }
                if ((magic[2] == 'n') && (magic[3] == 'I'))
                {
                        rdpdr_send_connect();
                        rdpdr_send_name();
                        rdpdr_send_available();
                        return;
                }
                else if ((magic[2] == 'C') && (magic[3] == 'C'))
                {
                        /* connect from server */
                        return;
                }
                else if ((magic[2] == 'r') && (magic[3] == 'd'))
                {
                        /* connect to a specific resource */
                        in_uint32(s, handle);
                        printf("Server connected to resource %d\n", handle);
                        return;
                }
        }
        unimpl("RDPDR packet type %c%c%c%c\n", magic[0], magic[1], magic[2], magic[3]);
}

BOOL
rdpdr_init(void)
{
        rdpdr_channel = channel_register("rdpdr", CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_COMPRESS_RDP, rdpdr_process);
        return (rdpdr_channel != NULL);
}
1	#include "rdesktop.h"
2
3	#define IRP_MJ_CREATE 0x00
4	#define IRP_MJ_CLOSE 0x02
5	#define IRP_MJ_READ 0x03
6	#define IRP_MJ_WRITE 0x04
7	#define IRP_MJ_DEVICE_CONTROL 0x0e
8
9	extern char hostname[16];
10	extern DEVICE_FNS serial_fns;
11	extern DEVICE_FNS printer_fns;
12
13	static VCHANNEL *rdpdr_channel;
14
15	void
16	rdpdr_send_connect(void)
17	{
18	uint8 magic[4] = "rDCC";
19	STREAM s;
20
21	s = channel_init(rdpdr_channel, 12);
22	out_uint8a(s, magic, 4);
23	out_uint16_le(s, 1); /* unknown */
24	out_uint16_le(s, 5);
25	out_uint32_be(s, 0x815ed39d); /* IP address (use 127.0.0.1) 0x815ed39d */
26	s_mark_end(s);
27	channel_send(s, rdpdr_channel);
28	}
29
30	void
31	rdpdr_send_name(void)
32	{
33	uint8 magic[4] = "rDNC";
34	uint32 hostlen = (strlen(hostname)+1)*2;
35	STREAM s;
36
37	s = channel_init(rdpdr_channel, 16+hostlen);
38	out_uint8a(s, magic, 4);
39	out_uint16_le(s, 0x63); /* unknown */
40	out_uint16_le(s, 0x72);
41	out_uint32(s, 0);
42	out_uint32_le(s, hostlen);
43	rdp_out_unistr(s, hostname, hostlen-2);
44	s_mark_end(s);
45	channel_send(s, rdpdr_channel);
46	}
47
48	void
49	rdpdr_send_available(void)
50	{
51	uint8 magic[4] = "rDAD";
52	char driver = "Digital turbo PrintServer 20"; / Fairly generic PostScript driver */
53	char *printer = "PostScript";
54	uint32 driverlen = (strlen(driver)+1)*2;
55	uint32 printerlen = (strlen(printer)+1)*2;
56	STREAM s;
57
58	s = channel_init(rdpdr_channel, 8+20);
59	out_uint8a(s, magic, 4);
60	out_uint32_le(s, 1); /* Number of devices */
61
62	#if 1
63	out_uint32_le(s, 0x1); /* Device type 0x1 - serial */
64	out_uint32_le(s, 0); /* Handle */
65	out_uint8p(s, "COM2", 4);
66	out_uint8s(s, 4); /* Pad to 8 */
67	out_uint32(s, 0);
68	#endif
69	#if 0
70	out_uint32_le(s, 0x2); /* Device type 0x2 - parallel */
71	out_uint32_le(s, 0);
72	out_uint8p(s, "LPT2", 4);
73	out_uint8s(s, 4);
74	out_uint32(s, 0);
75	#endif
76	#if 1
77	out_uint32_le(s, 0x4); /* Device type 0x4 - printer */
78	out_uint32_le(s, 1);
79	out_uint8p(s, "PRN1", 4);
80	out_uint8s(s, 4);
81	out_uint32_le(s, 24+driverlen+printerlen); /* length of extra info */
82	out_uint32_le(s, 2); /* unknown */
83	out_uint8s(s, 8); /* unknown */
84	out_uint32_le(s, driverlen); /* length of driver name */
85	out_uint32_le(s, printerlen); /* length of printer name */
86	out_uint32(s, 0); /* unknown */
87	rdp_out_unistr(s, driver, driverlen-2);
88	rdp_out_unistr(s, printer, printerlen-2);
89	#endif
90	#if 0
91	out_uint32_le(s, 0x8); /* Device type 0x8 - disk */
92	out_uint32_le(s, 0);
93	out_uint8p(s, "Z:", 2);
94	out_uint8s(s, 6);
95	out_uint32(s, 0);
96	#endif
97	#if 0
98	out_uint32_le(s, 0x20); /* Device type 0x20 - smart card */
99	out_uint32_le(s, 0);
100	out_uint8p(s, "SCARD", 5);
101	out_uint8s(s, 3);
102	out_uint32(s, 0);
103	#endif
104
105	s_mark_end(s);
106	channel_send(s, rdpdr_channel);
107	}
108
109	void
110	rdpdr_send_completion(uint32 device, uint32 id, uint32 status, uint32 result, uint8 *buffer, uint32 length)
111	{
112	uint8 magic[4] = "rDCI";
113	STREAM s;
114
115	s = channel_init(rdpdr_channel, 20 + length);
116	out_uint8a(s, magic, 4);
117	out_uint32_le(s, device);
118	out_uint32_le(s, id);
119	out_uint32_le(s, status);
120	out_uint32_le(s, result);
121	out_uint8p(s, buffer, length);
122	s_mark_end(s);
123	hexdump(s->channel_hdr+8, s->end-s->channel_hdr-8);
124	channel_send(s, rdpdr_channel);
125	}
126
127	static void
128	rdpdr_process_irp(STREAM s)
129	{
130	uint32 device, file, id, major, minor;
131	NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
132	uint32 result = 0, length, request, bytes_in, bytes_out;
133	uint8 buffer[256];
134	uint32 buffer_len = 1;
135	struct stream out;
136	DEVICE_FNS *fns;
137
138	in_uint32_le(s, device);
139	in_uint32_le(s, file);
140	in_uint32_le(s, id);
141	in_uint32_le(s, major);
142	in_uint32_le(s, minor);
143
144	memset(buffer, 0, sizeof(buffer));
145
146	/* FIXME: this should probably be a more dynamic mapping */
147	switch (device)
148	{
149	case 0:
150	fns = &serial_fns;
151	case 1:
152	fns = &printer_fns;
153	default:
154	error("IRP for bad device %ld\n", device);
155	return;
156	}
157
158	switch (major)
159	{
160	case IRP_MJ_CREATE:
161	if (fns->create)
162	status = fns->create(&result);
163	break;
164
165	case IRP_MJ_CLOSE:
166	if (fns->close)
167	status = fns->close(file);
168	break;
169
170	case IRP_MJ_READ:
171	if (fns->read)
172	{
173	if (length > sizeof(buffer))
174	length = sizeof(buffer);
175	status = fns->read(file, buffer, length, &result);
176	buffer_len = result;
177	}
178	break;
179
180	case IRP_MJ_WRITE:
181	if (fns->write)
182	status = fns->write(file, s->p, length, &result);
183	break;
184
185	case IRP_MJ_DEVICE_CONTROL:
186	if (fns->device_control)
187	{
188	in_uint32_le(s, bytes_out);
189	in_uint32_le(s, bytes_in);
190	in_uint32_le(s, request);
191	in_uint8s(s, 0x14);
192	out.data = out.p = buffer;
193	out.size = sizeof(buffer);
194	status = fns->device_control(file, request, s, &out);
195	result = buffer_len = out.p - out.data;
196	}
197	break;
198
199	default:
200	unimpl("IRP major=0x%x minor=0x%x\n", major, minor);
201	break;
202	}
203
204	rdpdr_send_completion(device, id, status, result, buffer, buffer_len);
205	}
206
207	static void
208	rdpdr_process(STREAM s)
209	{
210	uint32 handle;
211	char *magic;
212
213	printf("rdpdr_process\n");
214	hexdump(s->p, s->end-s->p);
215	in_uint8p(s, magic, 4);
216
217	if ((magic[0] == 'r') && (magic[1] == 'D'))
218	{
219	if ((magic[2] == 'R') && (magic[3] == 'I'))
220	{
221	rdpdr_process_irp(s);
222	return;
223	}
224	if ((magic[2] == 'n') && (magic[3] == 'I'))
225	{
226	rdpdr_send_connect();
227	rdpdr_send_name();
228	rdpdr_send_available();
229	return;
230	}
231	else if ((magic[2] == 'C') && (magic[3] == 'C'))
232	{
233	/* connect from server */
234	return;
235	}
236	else if ((magic[2] == 'r') && (magic[3] == 'd'))
237	{
238	/* connect to a specific resource */
239	in_uint32(s, handle);
240	printf("Server connected to resource %d\n", handle);
241	return;
242	}
243	}
244	unimpl("RDPDR packet type %c%c%c%c\n", magic[0], magic[1], magic[2], magic[3]);
245	}
246
247	BOOL
248	rdpdr_init(void)
249	{
250	rdpdr_channel = channel_register("rdpdr", CHANNEL_OPTION_INITIALIZED \| CHANNEL_OPTION_COMPRESS_RDP, rdpdr_process);
251	return (rdpdr_channel != NULL);
252	}