Import X server from vnc-3.3.7.
[rdpsrv] / mcs.c
1 /* -*- c-basic-offset: 8 -*-
2    rdesktop: A Remote Desktop Protocol client.
3    Protocol services - Multipoint Communications Service
4    Copyright (C) Matthew Chapman 1999-2002
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "rdesktop.h"
22
23 uint16 g_mcs_userid;
24 extern VCHANNEL g_channels[];
25 extern unsigned int g_num_channels;
26
27 /* Parse an ASN.1 BER header */
28 static BOOL
29 ber_parse_header(STREAM s, int tagval, int *length)
30 {
31         int tag, len;
32
33         if (tagval > 0xff)
34         {
35                 in_uint16_be(s, tag);
36         }
37         else
38         {
39         in_uint8(s, tag)}
40
41         if (tag != tagval)
42         {
43                 error("expected tag %d, got %d\n", tagval, tag);
44                 return False;
45         }
46
47         in_uint8(s, len);
48
49         if (len & 0x80)
50         {
51                 len &= ~0x80;
52                 *length = 0;
53                 while (len--)
54                         next_be(s, *length);
55         }
56         else
57                 *length = len;
58
59         return s_check(s);
60 }
61
62 /* Output an ASN.1 BER header */
63 static void
64 ber_out_header(STREAM s, int tagval, int length)
65 {
66         if (tagval > 0xff)
67         {
68                 out_uint16_be(s, tagval);
69         }
70         else
71         {
72                 out_uint8(s, tagval);
73         }
74
75         if (length >= 0x80)
76         {
77                 out_uint8(s, 0x82);
78                 out_uint16_be(s, length);
79         }
80         else
81                 out_uint8(s, length);
82 }
83
84 /* Output an ASN.1 BER integer */
85 static void
86 ber_out_integer(STREAM s, int value)
87 {
88         ber_out_header(s, BER_TAG_INTEGER, 2);
89         out_uint16_be(s, value);
90 }
91
92 static void
93 ber_in_integer(STREAM s, int *value)
94 {
95         int length;
96         ber_parse_header(s, BER_TAG_INTEGER, &length);
97         in_uint16_be(s, *value);
98 }
99
100 /* Output a DOMAIN_PARAMS structure (ASN.1 BER) */
101 static void
102 mcs_out_domain_params(STREAM s, int max_channels, int max_users, int max_tokens, int max_pdusize)
103 {
104         ber_out_header(s, MCS_TAG_DOMAIN_PARAMS, 32);
105         ber_out_integer(s, max_channels);
106         ber_out_integer(s, max_users);
107         ber_out_integer(s, max_tokens);
108         ber_out_integer(s, 1);  /* num_priorities */
109         ber_out_integer(s, 0);  /* min_throughput */
110         ber_out_integer(s, 1);  /* max_height */
111         ber_out_integer(s, max_pdusize);
112         ber_out_integer(s, 2);  /* ver_protocol */
113 }
114
115 /* Parse a DOMAIN_PARAMS structure (ASN.1 BER) */
116 static BOOL
117 mcs_parse_domain_params(STREAM s)
118 {
119         int length;
120         int max_channels, max_users, max_tokens, max_pdusize;
121         int num_priorities, min_throughput, max_height;
122         int ver_protocol;
123
124         ber_parse_header(s, MCS_TAG_DOMAIN_PARAMS, &length);
125         printf("MCS_TAG_DOMAIN_PARAMS, len %u (expected 32)\n", length);
126         if (length == 32) {
127                 ber_in_integer(s, &max_channels);
128                 ber_in_integer(s, &max_users);
129                 ber_in_integer(s, &max_tokens);
130                 ber_in_integer(s, &num_priorities);
131                 ber_in_integer(s, &min_throughput);
132                 ber_in_integer(s, &max_height);
133                 ber_in_integer(s, &max_pdusize);
134                 ber_in_integer(s, &ver_protocol);
135
136                 printf("max_channels=%u\n", max_channels);
137                 printf("max_users=%u\n", max_users);
138                 printf("max_tokens=%u\n", max_tokens);
139                 printf("num_priorities=%u\n", num_priorities);
140                 printf("min_throughput=%u\n", min_throughput);
141                 printf("max_pdusize=%u\n", max_pdusize);
142                 printf("ver_protocol=%u\n", ver_protocol);
143         } else {
144                 in_uint8s(s, length);
145         }
146         
147         return s_check(s);
148 }
149
150 /* Expect a MCS_CONNECT_RESPONSE message (ASN.1 BER) */
151 BOOL
152 mcs_recv_connect_initial()
153 {
154         uint8 result;
155         int length;
156         STREAM s;
157         char *buf;
158
159         s = iso_recv();
160         if (s == NULL)
161                 return False;
162
163         ber_parse_header(s, MCS_CONNECT_INITIAL, &length);
164         printf("parsing MCS_CONNECT_INITIAL (len=%u)\n", length);
165         ber_parse_header(s, BER_TAG_OCTET_STRING, &length);   /* calling domain */
166         in_uint8(s, result);
167         ber_parse_header(s, BER_TAG_OCTET_STRING, &length);   /* called domain */
168         in_uint8(s, result);
169         
170         ber_parse_header(s, BER_TAG_BOOLEAN, &length);
171         in_uint8(s, result);
172
173         mcs_parse_domain_params(s);
174         mcs_parse_domain_params(s);
175         mcs_parse_domain_params(s);
176
177         ber_parse_header(s, BER_TAG_OCTET_STRING, &length);
178         in_uint8p(s, buf, length);
179
180         printf("Data from MCS connect: '%*s'\n", length, buf);
181         
182         return s_check_end(s);
183 }
184
185 void
186 mcs_send_connect_response()
187 {
188         STREAM s;
189         int i;
190
191         s = iso_init(92);
192
193         ber_out_header(s, MCS_CONNECT_RESPONSE, 80);
194         ber_out_header(s, BER_TAG_RESULT, 1);
195         out_uint8(s, 0);
196
197         ber_out_header(s, BER_TAG_INTEGER, 1);
198         out_uint8(s, 1);  // connect id
199         
200         mcs_out_domain_params(s, 34, 2, 0, 0xffff);  // dumdidum?
201
202         ber_out_header(s, BER_TAG_OCTET_STRING, 40);
203
204         out_uint8s(s, 21);   // ick
205         out_uint8(s, 0);
206
207         // server info -- we claim to support RDP1
208         out_uint16_le(s, SEC_TAG_SRV_INFO);
209         out_uint16_le(s, 6);  // length
210         out_uint16_le(s, 1);
211
212         // crypto info
213         out_uint16_le(s, SEC_TAG_SRV_CRYPT);
214         out_uint16_le(s, 12); // length
215         out_uint32_le(s, 1); // 40-bit
216         out_uint32_le(s, 0); // no encryption
217         
218         s_mark_end(s);
219         printf("LEN: %u\n", s->p - s->iso_hdr);
220         iso_send(s);
221
222 }
223
224 /* Send an EDrq message (ASN.1 PER) */
225 static void
226 mcs_send_edrq(void)
227 {
228         STREAM s;
229
230         s = iso_init(5);
231
232         out_uint8(s, (MCS_EDRQ << 2));
233         out_uint16_be(s, 1);    /* height */
234         out_uint16_be(s, 1);    /* interval */
235
236         s_mark_end(s);
237         iso_send(s);
238 }
239
240 /* Send an AUrq message (ASN.1 PER) */
241 static void
242 mcs_send_aurq(void)
243 {
244         STREAM s;
245
246         s = iso_init(1);
247
248         out_uint8(s, (MCS_AURQ << 2));
249
250         s_mark_end(s);
251         iso_send(s);
252 }
253
254 /* Send a AUcf message (ASN.1 PER) */
255 static void
256 mcs_send_aucf(uint16 mcs_userid)
257 {
258         STREAM s;
259
260         s = iso_init(5);
261
262         out_uint8(s, (MCS_AUCF << 2) | 2);  // | 2 = send user ID
263         out_uint8(s, 0);  // success
264         out_uint16_be(s, 0);
265         
266         s_mark_end(s);
267         iso_send(s);
268 }
269
270 /* Send a CJrq message (ASN.1 PER) */
271 static void
272 mcs_send_cjrq(uint16 chanid)
273 {
274         STREAM s;
275
276         DEBUG_RDP5(("Sending CJRQ for channel #%d\n", chanid));
277
278         s = iso_init(5);
279
280         out_uint8(s, (MCS_CJRQ << 2));
281         out_uint16_be(s, g_mcs_userid);
282         out_uint16_be(s, chanid);
283
284         s_mark_end(s);
285         iso_send(s);
286 }
287
288 /* Expect a CJcf message (ASN.1 PER) */
289 static void
290 mcs_send_cjcf(uint16 userid, uint16 chanid)
291 {
292         STREAM s;
293
294         s = iso_init(5);
295
296         out_uint8(s, (MCS_CJCF << 2));
297         out_uint8(s, 0); // success
298         out_uint16_be(s, g_mcs_userid);
299         out_uint16_be(s, chanid);
300
301         s_mark_end(s);
302         iso_send(s);
303 }
304
305 /* Initialise an MCS transport data packet */
306 STREAM
307 mcs_init(int length)
308 {
309         STREAM s;
310
311         s = iso_init(length + 8);
312         s_push_layer(s, mcs_hdr, 8);
313
314         return s;
315 }
316
317 /* Send an MCS transport data packet to a specific channel */
318 void
319 mcs_send_to_channel(STREAM s, uint16 channel)
320 {
321         uint16 length;
322
323         s_pop_layer(s, mcs_hdr);
324         length = s->end - s->p - 8;
325         length |= 0x8000;
326
327         out_uint8(s, (MCS_SDIN << 2));
328         out_uint16_be(s, g_mcs_userid);
329         out_uint16_be(s, channel);
330         out_uint8(s, 0x70);     /* flags */
331         out_uint16_be(s, length);
332
333         iso_send(s);
334 }
335
336 /* Send an MCS transport data packet to the global channel */
337 void
338 mcs_send(STREAM s)
339 {
340         mcs_send_to_channel(s, MCS_GLOBAL_CHANNEL);
341 }
342
343 /* Receive an MCS transport data packet */
344 STREAM
345 mcs_recv(uint16 * channel)
346 {
347         uint8 opcode, appid, length, userid;
348         STREAM s;
349
350         s = iso_recv();
351         if (s == NULL)
352                 return NULL;
353
354         in_uint8(s, opcode);
355         appid = opcode >> 2;
356
357         switch (appid) {
358         case MCS_SDRQ:
359                 in_uint8s(s, 2);        /* userid */
360                 in_uint16_be(s, *channel);
361                 in_uint8s(s, 1);        /* flags */
362                 in_uint8(s, length);
363                 if (length & 0x80)
364                         in_uint8s(s, 1);        /* second byte of length */
365
366                 return s;
367         case MCS_DPUM:
368                 return NULL;
369         case MCS_EDRQ:
370                 // Erect Domain (ignore)
371                 printf("Received EDrq\n");
372                 return NULL;
373         case MCS_AURQ:
374                 // Attach User Request, respond with AUcf (Attach User Confirm)
375                 printf("Received AUrq, sending AUcf\n");
376                 mcs_send_aucf(0);
377                 return NULL;
378         case MCS_CJRQ:
379                 // Channel Join Request, respond with CJcf (Channel Join Confirm);
380                 in_uint16_be(s, userid);
381                 in_uint16_be(s, *channel);
382                 printf("Received CJrq for channel %hu, sending CJcf\n", *channel);
383                 mcs_send_cjcf(userid, *channel);
384                 return NULL;
385         default:
386                 error("expected data, got %d\n", opcode);
387                 return NULL;
388         }
389
390 }
391
392 /* Disconnect from the MCS layer */
393 void
394 mcs_disconnect(void)
395 {
396         iso_disconnect();
397 }