git.sesse.net Git - rdpsrv/blob - 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(98);
 203         printf("INITLEN: %u\n", s->p - s->iso_hdr);
 204
 205         ber_out_header(s, MCS_CONNECT_RESPONSE, 93);
 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, 59);
 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); // length?
 228         out_uint8(s, 0x01); // length?
 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, 0x81);  // one byte length
 240         out_uint8(s, 0x04);  // unknown
 241
 242         // server info -- we claim to support RDP5
 243         out_uint16_le(s, SEC_TAG_SRV_INFO);
 244         out_uint16_le(s, 8);  // length
 245         out_uint16_le(s, 4);  // version
 246         out_uint16_le(s, 8);  // unknown
 247
 248         // channel info -- open a few channels
 249         out_uint16_le(s, SEC_TAG_SRV_CHANNELS);
 250         out_uint16_le(s, 16); // length
 251         out_uint16_le(s, 1003);
 252         out_uint16_le(s, 3);
 253         out_uint16_le(s, 1004);
 254         out_uint16_le(s, 1005);
 255         out_uint16_le(s, 1006);
 256         out_uint16_le(s, 0);
 257
 258         // crypto info
 259         out_uint16_le(s, SEC_TAG_SRV_CRYPT);
 260         out_uint16_le(s, 12); // length
 261         out_uint32_le(s, 1); // 40-bit
 262         out_uint32_le(s, 0); // no encryption
 263
 264         s_mark_end(s);
 265         printf("LEN: %u\n", s->p - s->iso_hdr);
 266         iso_send(s);
 267
 268 }
 269
 270 /* Send an EDrq message (ASN.1 PER) */
 271 static void
 272 mcs_send_edrq(void)
 273 {
 274         STREAM s;
 275
 276         s = iso_init(5);
 277
 278         out_uint8(s, (MCS_EDRQ << 2));
 279         out_uint16_be(s, 1);    /* height */
 280         out_uint16_be(s, 1);    /* interval */
 281
 282         s_mark_end(s);
 283         iso_send(s);
 284 }
 285
 286 /* Send an AUrq message (ASN.1 PER) */
 287 static void
 288 mcs_send_aurq(void)
 289 {
 290         STREAM s;
 291
 292         s = iso_init(1);
 293
 294         out_uint8(s, (MCS_AURQ << 2));
 295
 296         s_mark_end(s);
 297         iso_send(s);
 298 }
 299
 300 /* Send a AUcf message (ASN.1 PER) */
 301 static void
 302 mcs_send_aucf(uint16 mcs_userid)
 303 {
 304         STREAM s;
 305
 306         s = iso_init(5);
 307
 308         out_uint8(s, (MCS_AUCF << 2) | 2);  // | 2 = send user ID
 309         out_uint8(s, 0);  // success
 310         out_uint16_be(s, 6);
 311
 312         s_mark_end(s);
 313         iso_send(s);
 314 }
 315
 316 /* Send a CJrq message (ASN.1 PER) */
 317 static void
 318 mcs_send_cjrq(uint16 chanid)
 319 {
 320         STREAM s;
 321
 322         DEBUG_RDP5(("Sending CJRQ for channel #%d\n", chanid));
 323
 324         s = iso_init(5);
 325
 326         out_uint8(s, (MCS_CJRQ << 2));
 327         out_uint16_be(s, g_mcs_userid);
 328         out_uint16_be(s, chanid);
 329
 330         s_mark_end(s);
 331         iso_send(s);
 332 }
 333
 334 /* Expect a CJcf message (ASN.1 PER) */
 335 static void
 336 mcs_send_cjcf(uint16 userid, uint16 chanid)
 337 {
 338         STREAM s;
 339
 340         s = iso_init(5);
 341
 342         out_uint8(s, (MCS_CJCF << 2) | 2);
 343         out_uint8(s, 0); // success
 344         out_uint16_be(s, 6);
 345         out_uint16_be(s, chanid);
 346         out_uint16_be(s, chanid);
 347
 348         s_mark_end(s);
 349         iso_send(s);
 350 }
 351
 352 /* Initialise an MCS transport data packet */
 353 STREAM
 354 mcs_init(int length)
 355 {
 356         STREAM s;
 357
 358         s = iso_init(length + 8);
 359         s_push_layer(s, mcs_hdr, 8);
 360
 361         return s;
 362 }
 363
 364 /* Send an MCS transport data packet to a specific channel */
 365 void
 366 mcs_send_to_channel(STREAM s, uint16 channel)
 367 {
 368         uint16 length;
 369
 370         s_pop_layer(s, mcs_hdr);
 371         length = s->end - s->p - 8;
 372         length |= 0x8000;
 373
 374         out_uint8(s, (MCS_SDIN << 2));
 375         out_uint16_be(s, g_mcs_userid);
 376         out_uint16_be(s, channel);
 377         out_uint8(s, 0x70);     /* flags */
 378         out_uint16_be(s, length);
 379
 380         iso_send(s);
 381 }
 382
 383 /* Send an MCS transport data packet to the global channel */
 384 void
 385 mcs_send(STREAM s)
 386 {
 387         mcs_send_to_channel(s, MCS_GLOBAL_CHANNEL);
 388 }
 389
 390 /* Receive an MCS transport data packet */
 391 STREAM
 392 mcs_recv(uint16 * channel)
 393 {
 394         uint8 opcode, appid, length, userid;
 395         STREAM s;
 396
 397         s = iso_recv();
 398         if (s == NULL)
 399                 return NULL;
 400
 401         in_uint8(s, opcode);
 402         appid = opcode >> 2;
 403
 404         switch (appid) {
 405         case MCS_SDRQ:
 406                 in_uint8s(s, 2);        /* userid */
 407                 in_uint16_be(s, *channel);
 408                 in_uint8s(s, 1);        /* flags */
 409                 in_uint8(s, length);
 410                 if (length & 0x80)
 411                         in_uint8s(s, 1);        /* second byte of length */
 412
 413                 return s;
 414         case MCS_DPUM:
 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 }