Handle AUrq/AUcf, and fix a type error.
[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 /* Output a DOMAIN_PARAMS structure (ASN.1 BER) */
93 static void
94 mcs_out_domain_params(STREAM s, int max_channels, int max_users, int max_tokens, int max_pdusize)
95 {
96         ber_out_header(s, MCS_TAG_DOMAIN_PARAMS, 32);
97         ber_out_integer(s, max_channels);
98         ber_out_integer(s, max_users);
99         ber_out_integer(s, max_tokens);
100         ber_out_integer(s, 1);  /* num_priorities */
101         ber_out_integer(s, 0);  /* min_throughput */
102         ber_out_integer(s, 1);  /* max_height */
103         ber_out_integer(s, max_pdusize);
104         ber_out_integer(s, 2);  /* ver_protocol */
105 }
106
107 /* Parse a DOMAIN_PARAMS structure (ASN.1 BER) */
108 static BOOL
109 mcs_parse_domain_params(STREAM s)
110 {
111         int length;
112
113         ber_parse_header(s, MCS_TAG_DOMAIN_PARAMS, &length);
114         in_uint8s(s, length);
115
116         return s_check(s);
117 }
118
119 /* Expect a MCS_CONNECT_RESPONSE message (ASN.1 BER) */
120 BOOL
121 mcs_recv_connect_initial()
122 {
123         uint8 result;
124         int length;
125         STREAM s;
126         char *buf;
127
128         s = iso_recv();
129         if (s == NULL)
130                 return False;
131
132         ber_parse_header(s, MCS_CONNECT_INITIAL, &length);
133         printf("parsing MCS_CONNECT_INITIAL (len=%u)\n", length);
134         ber_parse_header(s, BER_TAG_OCTET_STRING, &length);   /* calling domain */
135         in_uint8(s, result);
136         ber_parse_header(s, BER_TAG_OCTET_STRING, &length);   /* called domain */
137         in_uint8(s, result);
138         
139         ber_parse_header(s, BER_TAG_BOOLEAN, &length);
140         in_uint8(s, result);
141
142         mcs_parse_domain_params(s);
143         mcs_parse_domain_params(s);
144         mcs_parse_domain_params(s);
145
146         ber_parse_header(s, BER_TAG_OCTET_STRING, &length);
147         in_uint8p(s, buf, length);
148
149         printf("Data from MCS connect: '%*s'\n", length, buf);
150         
151         return s_check_end(s);
152 }
153
154 void
155 mcs_send_connect_response()
156 {
157         STREAM s;
158
159         s = iso_init(80);  // FIXME
160
161         ber_out_header(s, MCS_CONNECT_RESPONSE, 80);
162         ber_out_header(s, BER_TAG_RESULT, 1);
163         out_uint8(s, 0);
164
165         ber_out_header(s, BER_TAG_INTEGER, 1);
166         out_uint8(s, 1);  // connect id
167         
168         mcs_out_domain_params(s, 34, 2, 0, 0xffff);  // dumdidum?
169
170         ber_out_header(s, BER_TAG_OCTET_STRING, 28);
171
172         out_uint8s(s, 21);   // ick
173         out_uint8(s, 0);
174
175         // server info -- we claim to support RDP5
176         out_uint16_le(s, SEC_TAG_SRV_INFO);
177         out_uint16_le(s, 6);  // length
178         out_uint16_le(s, 5);
179
180         // aiee, no crypto info yet! :-)
181         
182         s_mark_end(s);
183         printf("LEN: %u\n", s->p - s->iso_hdr);
184         iso_send(s);
185
186 }
187
188 /* Send an EDrq message (ASN.1 PER) */
189 static void
190 mcs_send_edrq(void)
191 {
192         STREAM s;
193
194         s = iso_init(5);
195
196         out_uint8(s, (MCS_EDRQ << 2));
197         out_uint16_be(s, 1);    /* height */
198         out_uint16_be(s, 1);    /* interval */
199
200         s_mark_end(s);
201         iso_send(s);
202 }
203
204 /* Send an AUrq message (ASN.1 PER) */
205 static void
206 mcs_send_aurq(void)
207 {
208         STREAM s;
209
210         s = iso_init(1);
211
212         out_uint8(s, (MCS_AURQ << 2));
213
214         s_mark_end(s);
215         iso_send(s);
216 }
217
218 /* Send a AUcf message (ASN.1 PER) */
219 static void
220 mcs_send_aucf(uint16 mcs_userid)
221 {
222         STREAM s;
223
224         s = iso_init(5);
225
226         out_uint8(s, (MCS_AUCF << 2) | 2);  // | 2 = send user ID
227         out_uint8(s, 0);  // success
228         out_uint16_be(s, 0);
229         
230         s_mark_end(s);
231         iso_send(s);
232 }
233
234 /* Send a CJrq message (ASN.1 PER) */
235 static void
236 mcs_send_cjrq(uint16 chanid)
237 {
238         STREAM s;
239
240         DEBUG_RDP5(("Sending CJRQ for channel #%d\n", chanid));
241
242         s = iso_init(5);
243
244         out_uint8(s, (MCS_CJRQ << 2));
245         out_uint16_be(s, g_mcs_userid);
246         out_uint16_be(s, chanid);
247
248         s_mark_end(s);
249         iso_send(s);
250 }
251
252 /* Expect a CJcf message (ASN.1 PER) */
253 static BOOL
254 mcs_recv_cjcf(void)
255 {
256         uint8 opcode, result;
257         STREAM s;
258
259         s = iso_recv();
260         if (s == NULL)
261                 return False;
262
263         in_uint8(s, opcode);
264         if ((opcode >> 2) != MCS_CJCF)
265         {
266                 error("expected CJcf, got %d\n", opcode);
267                 return False;
268         }
269
270         in_uint8(s, result);
271         if (result != 0)
272         {
273                 error("CJrq: %d\n", result);
274                 return False;
275         }
276
277         in_uint8s(s, 4);        /* mcs_userid, req_chanid */
278         if (opcode & 2)
279                 in_uint8s(s, 2);        /* join_chanid */
280
281         return s_check_end(s);
282 }
283
284 /* Initialise an MCS transport data packet */
285 STREAM
286 mcs_init(int length)
287 {
288         STREAM s;
289
290         s = iso_init(length + 8);
291         s_push_layer(s, mcs_hdr, 8);
292
293         return s;
294 }
295
296 /* Send an MCS transport data packet to a specific channel */
297 void
298 mcs_send_to_channel(STREAM s, uint16 channel)
299 {
300         uint16 length;
301
302         s_pop_layer(s, mcs_hdr);
303         length = s->end - s->p - 8;
304         length |= 0x8000;
305
306         out_uint8(s, (MCS_SDRQ << 2));
307         out_uint16_be(s, g_mcs_userid);
308         out_uint16_be(s, channel);
309         out_uint8(s, 0x70);     /* flags */
310         out_uint16_be(s, length);
311
312         iso_send(s);
313 }
314
315 /* Send an MCS transport data packet to the global channel */
316 void
317 mcs_send(STREAM s)
318 {
319         mcs_send_to_channel(s, MCS_GLOBAL_CHANNEL);
320 }
321
322 /* Receive an MCS transport data packet */
323 STREAM
324 mcs_recv(uint16 * channel)
325 {
326         uint8 opcode, appid, length;
327         STREAM s;
328
329         s = iso_recv();
330         if (s == NULL)
331                 return NULL;
332
333         in_uint8(s, opcode);
334         appid = opcode >> 2;
335
336         switch (appid) {
337         case MCS_SDIN:
338                 in_uint8s(s, 2);        /* userid */
339                 in_uint16_be(s, *channel);
340                 in_uint8s(s, 1);        /* flags */
341                 in_uint8(s, length);
342                 if (length & 0x80)
343                         in_uint8s(s, 1);        /* second byte of length */
344
345                 return s;
346         case MCS_DPUM:
347                 return NULL;
348         case MCS_EDRQ:
349                 // Erect Domain (ignore)
350                 printf("Received EDrq\n");
351                 return NULL;
352         case MCS_AURQ:
353                 // Attach User Request, respond with AUcf (Attach User Confirm)
354                 printf("Received AUrq, sending AUcf\n");
355                 mcs_send_aucf(0);
356                 return NULL;
357         default:
358                 error("expected data, got %d\n", opcode);
359                 return NULL;
360         }
361
362 }
363
364 /* Disconnect from the MCS layer */
365 void
366 mcs_disconnect(void)
367 {
368         iso_disconnect();
369 }