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 /* 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 void
 254 mcs_send_cjcf(uint16 userid, uint16 chanid)
 255 {
 256         STREAM s;
 257
 258         s = iso_init(5);
 259
 260         out_uint8(s, (MCS_CJCF << 2));
 261         out_uint8(s, 0); // success
 262         out_uint16_be(s, g_mcs_userid);
 263         out_uint16_be(s, chanid);
 264
 265         s_mark_end(s);
 266         iso_send(s);
 267 }
 268
 269 /* Initialise an MCS transport data packet */
 270 STREAM
 271 mcs_init(int length)
 272 {
 273         STREAM s;
 274
 275         s = iso_init(length + 8);
 276         s_push_layer(s, mcs_hdr, 8);
 277
 278         return s;
 279 }
 280
 281 /* Send an MCS transport data packet to a specific channel */
 282 void
 283 mcs_send_to_channel(STREAM s, uint16 channel)
 284 {
 285         uint16 length;
 286
 287         s_pop_layer(s, mcs_hdr);
 288         length = s->end - s->p - 8;
 289         length |= 0x8000;
 290
 291         out_uint8(s, (MCS_SDRQ << 2));
 292         out_uint16_be(s, g_mcs_userid);
 293         out_uint16_be(s, channel);
 294         out_uint8(s, 0x70);     /* flags */
 295         out_uint16_be(s, length);
 296
 297         iso_send(s);
 298 }
 299
 300 /* Send an MCS transport data packet to the global channel */
 301 void
 302 mcs_send(STREAM s)
 303 {
 304         mcs_send_to_channel(s, MCS_GLOBAL_CHANNEL);
 305 }
 306
 307 /* Receive an MCS transport data packet */
 308 STREAM
 309 mcs_recv(uint16 * channel)
 310 {
 311         uint8 opcode, appid, length, userid;
 312         STREAM s;
 313
 314         s = iso_recv();
 315         if (s == NULL)
 316                 return NULL;
 317
 318         in_uint8(s, opcode);
 319         appid = opcode >> 2;
 320
 321         switch (appid) {
 322         case MCS_SDRQ:
 323                 in_uint8s(s, 2);        /* userid */
 324                 in_uint16_be(s, *channel);
 325                 in_uint8s(s, 1);        /* flags */
 326                 in_uint8(s, length);
 327                 if (length & 0x80)
 328                         in_uint8s(s, 1);        /* second byte of length */
 329
 330                 return s;
 331         case MCS_DPUM:
 332                 return NULL;
 333         case MCS_EDRQ:
 334                 // Erect Domain (ignore)
 335                 printf("Received EDrq\n");
 336                 return NULL;
 337         case MCS_AURQ:
 338                 // Attach User Request, respond with AUcf (Attach User Confirm)
 339                 printf("Received AUrq, sending AUcf\n");
 340                 mcs_send_aucf(0);
 341                 return NULL;
 342         case MCS_CJRQ:
 343                 // Channel Join Request, respond with CJcf (Channel Join Confirm);
 344                 in_uint16_be(s, userid);
 345                 in_uint16_be(s, *channel);
 346                 printf("Received CJrq for channel %hu, sending CJcf\n", *channel);
 347                 mcs_send_cjcf(userid, *channel);
 348                 return NULL;
 349         default:
 350                 error("expected data, got %d\n", opcode);
 351                 return NULL;
 352         }
 353
 354 }
 355
 356 /* Disconnect from the MCS layer */
 357 void
 358 mcs_disconnect(void)
 359 {
 360         iso_disconnect();
 361 }