Fix another length.
[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_out_uint8(STREAM s, uint8 value)
94 {
95         ber_out_header(s, BER_TAG_INTEGER, 1);
96         out_uint8(s, value);
97 }
98
99 static void
100 ber_in_integer(STREAM s, int *value)
101 {
102         int length;
103         ber_parse_header(s, BER_TAG_INTEGER, &length);
104         in_uint16_be(s, *value);
105 }
106
107 /* Output a DOMAIN_PARAMS structure (ASN.1 BER) */
108 static void
109 mcs_out_domain_params(STREAM s, int max_channels, int max_users, int max_tokens, int max_pdusize)
110 {
111         ber_out_header(s, MCS_TAG_DOMAIN_PARAMS, 26);
112         ber_out_uint8(s, 34); // max_channels
113         ber_out_uint8(s, 3);  // max_users
114         ber_out_uint8(s, 0);  // max_tokens
115         ber_out_uint8(s, 1);  // num_priorities 
116         ber_out_uint8(s, 0);  // min_throughput
117         ber_out_uint8(s, 1);  // max_height
118         ber_out_header(s, BER_TAG_INTEGER, 3); // pdu size
119         out_uint8(s, 0x00);
120         out_uint8(s, 0xff);
121         out_uint8(s, 0xf8);
122         ber_out_uint8(s, 2);  // ver_protocol
123 }
124
125 /* Parse a DOMAIN_PARAMS structure (ASN.1 BER) */
126 static BOOL
127 mcs_parse_domain_params(STREAM s)
128 {
129         int length;
130         int max_channels, max_users, max_tokens, max_pdusize;
131         int num_priorities, min_throughput, max_height;
132         int ver_protocol;
133
134         ber_parse_header(s, MCS_TAG_DOMAIN_PARAMS, &length);
135         printf("MCS_TAG_DOMAIN_PARAMS, len %u (expected 32)\n", length);
136         if (length == 32) {
137                 ber_in_integer(s, &max_channels);
138                 ber_in_integer(s, &max_users);
139                 ber_in_integer(s, &max_tokens);
140                 ber_in_integer(s, &num_priorities);
141                 ber_in_integer(s, &min_throughput);
142                 ber_in_integer(s, &max_height);
143                 ber_in_integer(s, &max_pdusize);
144                 ber_in_integer(s, &ver_protocol);
145
146                 printf("max_channels=%u\n", max_channels);
147                 printf("max_users=%u\n", max_users);
148                 printf("max_tokens=%u\n", max_tokens);
149                 printf("num_priorities=%u\n", num_priorities);
150                 printf("min_throughput=%u\n", min_throughput);
151                 printf("max_pdusize=%u\n", max_pdusize);
152                 printf("ver_protocol=%u\n", ver_protocol);
153         } else {
154                 hexdump(s->p, length);
155                 in_uint8s(s, length);
156         }
157         
158         return s_check(s);
159 }
160
161 /* Expect a MCS_CONNECT_RESPONSE message (ASN.1 BER) */
162 BOOL
163 mcs_recv_connect_initial()
164 {
165         uint8 result;
166         int length;
167         STREAM s;
168         char *buf;
169
170         s = iso_recv();
171         if (s == NULL)
172                 return False;
173
174         ber_parse_header(s, MCS_CONNECT_INITIAL, &length);
175         printf("parsing MCS_CONNECT_INITIAL (len=%u)\n", length);
176         ber_parse_header(s, BER_TAG_OCTET_STRING, &length);   /* calling domain */
177         in_uint8(s, result);
178         ber_parse_header(s, BER_TAG_OCTET_STRING, &length);   /* called domain */
179         in_uint8(s, result);
180         
181         ber_parse_header(s, BER_TAG_BOOLEAN, &length);
182         in_uint8(s, result);
183
184         mcs_parse_domain_params(s);
185         mcs_parse_domain_params(s);
186         mcs_parse_domain_params(s);
187
188         ber_parse_header(s, BER_TAG_OCTET_STRING, &length);
189         in_uint8p(s, buf, length);
190
191         printf("Data from MCS connect: '%*s'\n", length, buf);
192         
193         return s_check_end(s);
194 }
195
196 void
197 mcs_send_connect_response()
198 {
199         STREAM s;
200         int i;
201
202         s = iso_init(97);
203         printf("INITLEN: %u\n", s->p - s->iso_hdr);
204
205         ber_out_header(s, MCS_CONNECT_RESPONSE, 94);
206         ber_out_header(s, BER_TAG_RESULT, 1);
207         out_uint8(s, 0);
208
209         ber_out_header(s, BER_TAG_INTEGER, 1);
210         out_uint8(s, 0);  // connect id
211         
212         mcs_out_domain_params(s, 34, 2, 0, 0xffff);  // dumdidum?
213
214         ber_out_header(s, BER_TAG_OCTET_STRING, 58);
215
216         // some unknown header of sorts
217         out_uint8(s, 0x00);
218         out_uint8(s, 0x05);
219         out_uint8(s, 0x00);
220         out_uint8(s, 0x14);
221         out_uint8(s, 0x7c);
222         out_uint8(s, 0x00);
223         out_uint8(s, 0x01);
224         out_uint8(s, 0x2a);
225         out_uint8(s, 0x14);
226         out_uint8(s, 0x76);
227         out_uint8(s, 0x0a); 
228         out_uint8(s, 0x01);
229         out_uint8(s, 0x01);
230         out_uint8(s, 0x00);
231         out_uint8(s, 0x01);
232         out_uint8(s, 0xc0);
233         out_uint8(s, 0x00);
234         out_uint8(s, 0x4d);
235         out_uint8(s, 0x63);
236         out_uint8(s, 0x44);
237         out_uint8(s, 0x6e);
238         
239         out_uint8(s, 36);  // one byte length
240
241         // server info -- we claim to support RDP5
242         out_uint16_le(s, SEC_TAG_SRV_INFO);
243         out_uint16_le(s, 8);  // length
244         out_uint16_le(s, 4);  // version
245         out_uint16_le(s, 8);  // unknown
246
247         // channel info -- open a few channels
248         out_uint16_le(s, SEC_TAG_SRV_CHANNELS);
249         out_uint16_le(s, 16); // length
250         out_uint16_le(s, 1003);
251         out_uint16_le(s, 3);
252         out_uint16_le(s, 1004);
253         out_uint16_le(s, 1005);
254         out_uint16_le(s, 1006);
255         out_uint16_le(s, 0);
256         
257         // crypto info
258         out_uint16_le(s, SEC_TAG_SRV_CRYPT);
259         out_uint16_le(s, 12); // length
260         out_uint32_le(s, 1); // 40-bit
261         out_uint32_le(s, 0); // no encryption 
262         
263         s_mark_end(s);
264         printf("LEN: %u\n", s->p - s->iso_hdr);
265         iso_send(s);
266
267 }
268
269 /* Send an EDrq message (ASN.1 PER) */
270 static void
271 mcs_send_edrq(void)
272 {
273         STREAM s;
274
275         s = iso_init(5);
276
277         out_uint8(s, (MCS_EDRQ << 2));
278         out_uint16_be(s, 1);    /* height */
279         out_uint16_be(s, 1);    /* interval */
280
281         s_mark_end(s);
282         iso_send(s);
283 }
284
285 /* Send an AUrq message (ASN.1 PER) */
286 static void
287 mcs_send_aurq(void)
288 {
289         STREAM s;
290
291         s = iso_init(1);
292
293         out_uint8(s, (MCS_AURQ << 2));
294
295         s_mark_end(s);
296         iso_send(s);
297 }
298
299 /* Send a AUcf message (ASN.1 PER) */
300 static void
301 mcs_send_aucf(uint16 mcs_userid)
302 {
303         STREAM s;
304
305         s = iso_init(4);
306
307         out_uint8(s, (MCS_AUCF << 2) | 2);  // | 2 = send user ID
308         out_uint8(s, 0);  // success
309         out_uint16_be(s, 6);
310         
311         s_mark_end(s);
312         iso_send(s);
313 }
314
315 /* Send a CJrq message (ASN.1 PER) */
316 static void
317 mcs_send_cjrq(uint16 chanid)
318 {
319         STREAM s;
320
321         DEBUG_RDP5(("Sending CJRQ for channel #%d\n", chanid));
322
323         s = iso_init(5);
324
325         out_uint8(s, (MCS_CJRQ << 2));
326         out_uint16_be(s, g_mcs_userid);
327         out_uint16_be(s, chanid);
328
329         s_mark_end(s);
330         iso_send(s);
331 }
332
333 /* Expect a CJcf message (ASN.1 PER) */
334 static void
335 mcs_send_cjcf(uint16 userid, uint16 chanid)
336 {
337         STREAM s;
338
339         s = iso_init(8);
340
341         out_uint8(s, (MCS_CJCF << 2) | 2);
342         out_uint8(s, 0); // success
343         out_uint16_be(s, 6);
344         out_uint16_be(s, chanid);
345         out_uint16_be(s, chanid);
346
347         s_mark_end(s);
348         iso_send(s);
349 }
350
351 /* Initialise an MCS transport data packet */
352 STREAM
353 mcs_init(int length)
354 {
355         STREAM s;
356
357         s = iso_init(length + 8);
358         s_push_layer(s, mcs_hdr, 8);
359
360         return s;
361 }
362
363 /* Send an MCS transport data packet to a specific channel */
364 void
365 mcs_send_to_channel(STREAM s, uint16 channel)
366 {
367         uint16 length;
368
369         s_pop_layer(s, mcs_hdr);
370         length = s->end - s->p - 8;
371         length |= 0x8000;
372
373         out_uint8(s, (MCS_SDIN << 2));
374         out_uint16_be(s, g_mcs_userid);
375         out_uint16_be(s, channel);
376         out_uint8(s, 0x70);     /* flags */
377         out_uint16_be(s, length);
378
379         iso_send(s);
380 }
381
382 /* Send an MCS transport data packet to the global channel */
383 void
384 mcs_send(STREAM s)
385 {
386         mcs_send_to_channel(s, MCS_GLOBAL_CHANNEL);
387 }
388
389 /* Receive an MCS transport data packet */
390 STREAM
391 mcs_recv(uint16 * channel)
392 {
393         uint8 opcode, appid, length, userid;
394         STREAM s;
395
396         s = iso_recv();
397         if (s == NULL)
398                 return NULL;
399
400         in_uint8(s, opcode);
401         appid = opcode >> 2;
402
403         switch (appid) {
404         case MCS_SDRQ:
405                 in_uint8s(s, 2);        /* userid */
406                 in_uint16_be(s, *channel);
407                 in_uint8s(s, 1);        /* flags */
408                 in_uint8(s, length);
409                 if (length & 0x80)
410                         in_uint8s(s, 1);        /* second byte of length */
411
412                 return s;
413         case MCS_DPUM:
414                 printf("Received DPUM (?)\n");
415                 return NULL;
416         case MCS_EDRQ:
417                 // Erect Domain (ignore)
418                 printf("Received EDrq\n");
419                 return NULL;
420         case MCS_AURQ:
421                 // Attach User Request, respond with AUcf (Attach User Confirm)
422                 printf("Received AUrq, sending AUcf\n");
423                 mcs_send_aucf(0);
424                 return NULL;
425         case MCS_CJRQ:
426                 // Channel Join Request, respond with CJcf (Channel Join Confirm);
427                 in_uint16_be(s, userid);
428                 in_uint16_be(s, *channel);
429                 printf("Received CJrq for channel %hu, sending CJcf\n", *channel);
430                 mcs_send_cjcf(userid, *channel);
431                 return NULL;
432         default:
433                 error("expected data, got %d\n", opcode);
434                 return NULL;
435         }
436
437 }
438
439 /* Disconnect from the MCS layer */
440 void
441 mcs_disconnect(void)
442 {
443         iso_disconnect();
444 }