[NTDLL]
[reactos.git] / reactos / base / applications / mstsc / 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-2005
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 along
17 with this program; if not, write to the Free Software Foundation, Inc.,
18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 #include <precomp.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 /* Send an MCS_CONNECT_INITIAL message (ASN.1 BER) */
120 static void
121 mcs_send_connect_initial(STREAM mcs_data)
122 {
123 int datalen = mcs_data->end - mcs_data->data;
124 int length = 9 + 3 * 34 + 4 + datalen;
125 STREAM s;
126
127 s = iso_init(length + 5);
128
129 ber_out_header(s, MCS_CONNECT_INITIAL, length);
130 ber_out_header(s, BER_TAG_OCTET_STRING, 1); /* calling domain */
131 out_uint8(s, 1);
132 ber_out_header(s, BER_TAG_OCTET_STRING, 1); /* called domain */
133 out_uint8(s, 1);
134
135 ber_out_header(s, BER_TAG_BOOLEAN, 1);
136 out_uint8(s, 0xff); /* upward flag */
137
138 mcs_out_domain_params(s, 34, 2, 0, 0xffff); /* target params */
139 mcs_out_domain_params(s, 1, 1, 1, 0x420); /* min params */
140 mcs_out_domain_params(s, 0xffff, 0xfc17, 0xffff, 0xffff); /* max params */
141
142 ber_out_header(s, BER_TAG_OCTET_STRING, datalen);
143 out_uint8p(s, mcs_data->data, datalen);
144
145 s_mark_end(s);
146 iso_send(s);
147 }
148
149 /* Expect a MCS_CONNECT_RESPONSE message (ASN.1 BER) */
150 static BOOL
151 mcs_recv_connect_response(STREAM mcs_data)
152 {
153 uint8 result;
154 int length;
155 STREAM s;
156
157 s = iso_recv(NULL);
158 if (s == NULL)
159 return False;
160
161 ber_parse_header(s, MCS_CONNECT_RESPONSE, &length);
162
163 ber_parse_header(s, BER_TAG_RESULT, &length);
164 in_uint8(s, result);
165 if (result != 0)
166 {
167 error("MCS connect: %d\n", result);
168 return False;
169 }
170
171 ber_parse_header(s, BER_TAG_INTEGER, &length);
172 in_uint8s(s, length); /* connect id */
173 mcs_parse_domain_params(s);
174
175 ber_parse_header(s, BER_TAG_OCTET_STRING, &length);
176
177 sec_process_mcs_data(s);
178 /*
179 if (length > mcs_data->size)
180 {
181 error("MCS data length %d, expected %d\n", length,
182 mcs_data->size);
183 length = mcs_data->size;
184 }
185
186 in_uint8a(s, mcs_data->data, length);
187 mcs_data->p = mcs_data->data;
188 mcs_data->end = mcs_data->data + length;
189 */
190 return s_check_end(s);
191 }
192
193 /* Send an EDrq message (ASN.1 PER) */
194 static void
195 mcs_send_edrq(void)
196 {
197 STREAM s;
198
199 s = iso_init(5);
200
201 out_uint8(s, (MCS_EDRQ << 2));
202 out_uint16_be(s, 1); /* height */
203 out_uint16_be(s, 1); /* interval */
204
205 s_mark_end(s);
206 iso_send(s);
207 }
208
209 /* Send an AUrq message (ASN.1 PER) */
210 static void
211 mcs_send_aurq(void)
212 {
213 STREAM s;
214
215 s = iso_init(1);
216
217 out_uint8(s, (MCS_AURQ << 2));
218
219 s_mark_end(s);
220 iso_send(s);
221 }
222
223 /* Expect a AUcf message (ASN.1 PER) */
224 static BOOL
225 mcs_recv_aucf(uint16 * mcs_userid)
226 {
227 uint8 opcode, result;
228 STREAM s;
229
230 s = iso_recv(NULL);
231 if (s == NULL)
232 return False;
233
234 in_uint8(s, opcode);
235 if ((opcode >> 2) != MCS_AUCF)
236 {
237 error("expected AUcf, got %d\n", opcode);
238 return False;
239 }
240
241 in_uint8(s, result);
242 if (result != 0)
243 {
244 error("AUrq: %d\n", result);
245 return False;
246 }
247
248 if (opcode & 2)
249 in_uint16_be(s, *mcs_userid);
250
251 return s_check_end(s);
252 }
253
254 /* Send a CJrq message (ASN.1 PER) */
255 static void
256 mcs_send_cjrq(uint16 chanid)
257 {
258 STREAM s;
259
260 DEBUG_RDP5(("Sending CJRQ for channel #%d\n", chanid));
261
262 s = iso_init(5);
263
264 out_uint8(s, (MCS_CJRQ << 2));
265 out_uint16_be(s, g_mcs_userid);
266 out_uint16_be(s, chanid);
267
268 s_mark_end(s);
269 iso_send(s);
270 }
271
272 /* Expect a CJcf message (ASN.1 PER) */
273 static BOOL
274 mcs_recv_cjcf(void)
275 {
276 uint8 opcode, result;
277 STREAM s;
278
279 s = iso_recv(NULL);
280 if (s == NULL)
281 return False;
282
283 in_uint8(s, opcode);
284 if ((opcode >> 2) != MCS_CJCF)
285 {
286 error("expected CJcf, got %d\n", opcode);
287 return False;
288 }
289
290 in_uint8(s, result);
291 if (result != 0)
292 {
293 error("CJrq: %d\n", result);
294 return False;
295 }
296
297 in_uint8s(s, 4); /* mcs_userid, req_chanid */
298 if (opcode & 2)
299 in_uint8s(s, 2); /* join_chanid */
300
301 return s_check_end(s);
302 }
303
304 /* Initialise an MCS transport data packet */
305 STREAM
306 mcs_init(int length)
307 {
308 STREAM s;
309
310 s = iso_init(length + 8);
311 s_push_layer(s, mcs_hdr, 8);
312
313 return s;
314 }
315
316 /* Send an MCS transport data packet to a specific channel */
317 void
318 mcs_send_to_channel(STREAM s, uint16 channel)
319 {
320 uint16 length;
321
322 s_pop_layer(s, mcs_hdr);
323 length = s->end - s->p - 8;
324 length |= 0x8000;
325
326 out_uint8(s, (MCS_SDRQ << 2));
327 out_uint16_be(s, g_mcs_userid);
328 out_uint16_be(s, channel);
329 out_uint8(s, 0x70); /* flags */
330 out_uint16_be(s, length);
331
332 iso_send(s);
333 }
334
335 /* Send an MCS transport data packet to the global channel */
336 void
337 mcs_send(STREAM s)
338 {
339 mcs_send_to_channel(s, MCS_GLOBAL_CHANNEL);
340 }
341
342 /* Receive an MCS transport data packet */
343 STREAM
344 mcs_recv(uint16 * channel, uint8 * rdpver)
345 {
346 uint8 opcode, appid, length;
347 STREAM s;
348
349 s = iso_recv(rdpver);
350 if (s == NULL)
351 return NULL;
352 if (rdpver != NULL)
353 if (*rdpver != 3)
354 return s;
355 in_uint8(s, opcode);
356 appid = opcode >> 2;
357 if (appid != MCS_SDIN)
358 {
359 if (appid != MCS_DPUM)
360 {
361 error("expected data, got %d\n", opcode);
362 }
363 return NULL;
364 }
365 in_uint8s(s, 2); /* userid */
366 in_uint16_be(s, *channel);
367 in_uint8s(s, 1); /* flags */
368 in_uint8(s, length);
369 if (length & 0x80)
370 in_uint8s(s, 1); /* second byte of length */
371 return s;
372 }
373
374 /* Establish a connection up to the MCS layer */
375 BOOL
376 mcs_connect(char *server, STREAM mcs_data, char *username)
377 {
378 unsigned int i;
379
380 if (!iso_connect(server, username))
381 return False;
382
383 mcs_send_connect_initial(mcs_data);
384 if (!mcs_recv_connect_response(mcs_data))
385 goto error;
386
387 mcs_send_edrq();
388
389 mcs_send_aurq();
390 if (!mcs_recv_aucf(&g_mcs_userid))
391 goto error;
392
393 mcs_send_cjrq((uint16) (g_mcs_userid + MCS_USERCHANNEL_BASE));
394
395 if (!mcs_recv_cjcf())
396 goto error;
397
398 mcs_send_cjrq(MCS_GLOBAL_CHANNEL);
399 if (!mcs_recv_cjcf())
400 goto error;
401
402 for (i = 0; i < g_num_channels; i++)
403 {
404 mcs_send_cjrq(g_channels[i].mcs_id);
405 if (!mcs_recv_cjcf())
406 goto error;
407 }
408 return True;
409
410 error:
411 iso_disconnect();
412 return False;
413 }
414
415 /* Establish a connection up to the MCS layer */
416 BOOL
417 mcs_reconnect(char *server, STREAM mcs_data)
418 {
419 unsigned int i;
420
421 if (!iso_reconnect(server))
422 return False;
423
424 mcs_send_connect_initial(mcs_data);
425 if (!mcs_recv_connect_response(mcs_data))
426 goto error;
427
428 mcs_send_edrq();
429
430 mcs_send_aurq();
431 if (!mcs_recv_aucf(&g_mcs_userid))
432 goto error;
433
434 mcs_send_cjrq((uint16) (g_mcs_userid + MCS_USERCHANNEL_BASE));
435
436 if (!mcs_recv_cjcf())
437 goto error;
438
439 mcs_send_cjrq(MCS_GLOBAL_CHANNEL);
440 if (!mcs_recv_cjcf())
441 goto error;
442
443 for (i = 0; i < g_num_channels; i++)
444 {
445 mcs_send_cjrq(g_channels[i].mcs_id);
446 if (!mcs_recv_cjcf())
447 goto error;
448 }
449 return True;
450
451 error:
452 iso_disconnect();
453 return False;
454 }
455
456 /* Disconnect from the MCS layer */
457 void
458 mcs_disconnect(void)
459 {
460 iso_disconnect();
461 }
462
463 /* reset the state of the mcs layer */
464 void
465 mcs_reset_state(void)
466 {
467 g_mcs_userid = 0;
468 iso_reset_state();
469 }