libfreerdp-core/gcc.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol Client
   3  * T.124 Generic Conference Control (GCC)
   4  *
   5  * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 #include <freerdp/utils/print.h>
  21
  22 #include "gcc.h"
  23 #include "certificate.h"
  24
  25 /**
  26  * T.124 GCC is defined in:
  27  *
  28  * http://www.itu.int/rec/T-REC-T.124-199802-S/en
  29  * ITU-T T.124 (02/98): Generic Conference Control
  30  */
  31
  32 /**
  33  * ConnectData ::= SEQUENCE
  34  * {
  35  *      t124Identifier  Key,
  36  *      connectPDU      OCTET_STRING
  37  * }
  38  *
  39  * Key ::= CHOICE
  40  * {
  41  *      object                          OBJECT_IDENTIFIER,
  42  *      h221NonStandard                 H221NonStandardIdentifier
  43  * }
  44  *
  45  * ConnectGCCPDU ::= CHOICE
  46  * {
  47  *      conferenceCreateRequest         ConferenceCreateRequest,
  48  *      conferenceCreateResponse        ConferenceCreateResponse,
  49  *      conferenceQueryRequest          ConferenceQueryRequest,
  50  *      conferenceQueryResponse         ConferenceQueryResponse,
  51  *      conferenceJoinRequest           ConferenceJoinRequest,
  52  *      conferenceJoinResponse          ConferenceJoinResponse,
  53  *      conferenceInviteRequest         ConferenceInviteRequest,
  54  *      conferenceInviteResponse        ConferenceInviteResponse,
  55  *      ...
  56  * }
  57  *
  58  * ConferenceCreateRequest ::= SEQUENCE
  59  * {
  60  *      conferenceName                  ConferenceName,
  61  *      convenerPassword                Password OPTIONAL,
  62  *      password                        Password OPTIONAL,
  63  *      lockedConference                BOOLEAN,
  64  *      listedConference                BOOLEAN,
  65  *      conductibleConference           BOOLEAN,
  66  *      terminationMethod               TerminationMethod,
  67  *      conductorPrivileges             SET OF Privilege OPTIONAL,
  68  *      conductedPrivileges             SET OF Privilege OPTIONAL,
  69  *      nonConductedPrivileges          SET OF Privilege OPTIONAL,
  70  *      conferenceDescription           TextString OPTIONAL,
  71  *      callerIdentifier                TextString OPTIONAL,
  72  *      userData                        UserData OPTIONAL,
  73  *      ...,
  74  *      conferencePriority              ConferencePriority OPTIONAL,
  75  *      conferenceMode                  ConferenceMode OPTIONAL
  76  * }
  77  *
  78  * ConferenceCreateResponse ::= SEQUENCE
  79  * {
  80  *      nodeID                          UserID,
  81  *      tag                             INTEGER,
  82  *      result                          ENUMERATED
  83  *      {
  84  *              success                         (0),
  85  *              userRejected                    (1),
  86  *              resourcesNotAvailable           (2),
  87  *              rejectedForSymmetryBreaking     (3),
  88  *              lockedConferenceNotSupported    (4)
  89  *      },
  90  *      userData                        UserData OPTIONAL,
  91  *      ...
  92  * }
  93  *
  94  * ConferenceName ::= SEQUENCE
  95  * {
  96  *      numeric                         SimpleNumericString
  97  *      text                            SimpleTextString OPTIONAL,
  98  *      ...
  99  * }
 100  *
 101  * SimpleNumericString ::= NumericString (SIZE (1..255)) (FROM ("0123456789"))
 102  *
 103  * UserData ::= SET OF SEQUENCE
 104  * {
 105  *      key                             Key,
 106  *      value                           OCTET_STRING OPTIONAL
 107  * }
 108  *
 109  * H221NonStandardIdentifier ::= OCTET STRING (SIZE (4..255))
 110  *
 111  * UserID ::= DynamicChannelID
 112  *
 113  * ChannelID ::= INTEGER (1..65535)
 114  * StaticChannelID ::= INTEGER (1..1000)
 115  * DynamicChannelID ::= INTEGER (1001..65535)
 116  *
 117  */
 118
 119 /*
 120  * OID = 0.0.20.124.0.1
 121  * { itu-t(0) recommendation(0) t(20) t124(124) version(0) 1 }
 122  * v.1 of ITU-T Recommendation T.124 (Feb 1998): "Generic Conference Control"
 123  */
 124 uint8 t124_02_98_oid[6] = { 0, 0, 20, 124, 0, 1 };
 125
 126 uint8 h221_cs_key[4] = "Duca";
 127 uint8 h221_sc_key[4] = "McDn";
 128
 129 /**
 130  * Read a GCC Conference Create Request.\n
 131  * @msdn{cc240836}
 132  * @param s stream
 133  * @param settings rdp settings
 134  */
 135
 136 boolean gcc_read_conference_create_request(STREAM* s, rdpSettings* settings)
 137 {
 138         uint16 length;
 139         uint8 choice;
 140         uint8 number;
 141         uint8 selection;
 142
 143         /* ConnectData */
 144         if (!per_read_choice(s, &choice))
 145                 return false;
 146         if (!per_read_object_identifier(s, t124_02_98_oid))
 147                 return false;
 148
 149         /* ConnectData::connectPDU (OCTET_STRING) */
 150         if (!per_read_length(s, &length))
 151                 return false;
 152
 153         /* ConnectGCCPDU */
 154         if (!per_read_choice(s, &choice))
 155                 return false;
 156         if (!per_read_selection(s, &selection))
 157                 return false;
 158
 159         /* ConferenceCreateRequest::conferenceName */
 160         if (!per_read_numeric_string(s, 1)) /* ConferenceName::numeric */
 161                 return false;
 162         if (!per_read_padding(s, 1)) /* padding */
 163                 return false;
 164
 165         /* UserData (SET OF SEQUENCE) */
 166         if (!per_read_number_of_sets(s, &number) || number != 1) /* one set of UserData */
 167                 return false;
 168         if (!per_read_choice(s, &choice) || choice != 0xC0) /* UserData::value present + select h221NonStandard (1) */
 169                 return false;
 170
 171         /* h221NonStandard */
 172         if (!per_read_octet_string(s, h221_cs_key, 4, 4)) /* h221NonStandard, client-to-server H.221 key, "Duca" */
 173                 return false;
 174
 175         /* userData::value (OCTET_STRING) */
 176         if (!per_read_length(s, &length))
 177                 return false;
 178         if (stream_get_left(s) < length)
 179                 return false;
 180         if (!gcc_read_client_data_blocks(s, settings, length))
 181                 return false;
 182
 183         return true;
 184 }
 185
 186 /**
 187  * Write a GCC Conference Create Request.\n
 188  * @msdn{cc240836}
 189  * @param s stream
 190  * @param user_data client data blocks
 191  */
 192
 193 void gcc_write_conference_create_request(STREAM* s, STREAM* user_data)
 194 {
 195         /* ConnectData */
 196         per_write_choice(s, 0); /* From Key select object (0) of type OBJECT_IDENTIFIER */
 197         per_write_object_identifier(s, t124_02_98_oid); /* ITU-T T.124 (02/98) OBJECT_IDENTIFIER */
 198
 199         /* ConnectData::connectPDU (OCTET_STRING) */
 200         per_write_length(s, stream_get_length(user_data) + 14); /* connectPDU length */
 201
 202         /* ConnectGCCPDU */
 203         per_write_choice(s, 0); /* From ConnectGCCPDU select conferenceCreateRequest (0) of type ConferenceCreateRequest */
 204         per_write_selection(s, 0x08); /* select optional userData from ConferenceCreateRequest */
 205
 206         /* ConferenceCreateRequest::conferenceName */
 207         per_write_numeric_string(s, (uint8*)"1", 1, 1); /* ConferenceName::numeric */
 208         per_write_padding(s, 1); /* padding */
 209
 210         /* UserData (SET OF SEQUENCE) */
 211         per_write_number_of_sets(s, 1); /* one set of UserData */
 212         per_write_choice(s, 0xC0); /* UserData::value present + select h221NonStandard (1) */
 213
 214         /* h221NonStandard */
 215         per_write_octet_string(s, h221_cs_key, 4, 4); /* h221NonStandard, client-to-server H.221 key, "Duca" */
 216
 217         /* userData::value (OCTET_STRING) */
 218         per_write_octet_string(s, user_data->data, stream_get_length(user_data), 0); /* array of client data blocks */
 219 }
 220
 221 boolean gcc_read_conference_create_response(STREAM* s, rdpSettings* settings)
 222 {
 223         uint16 length;
 224         uint32 tag;
 225         uint16 nodeID;
 226         uint8 result;
 227         uint8 choice;
 228         uint8 number;
 229
 230         /* ConnectData */
 231         per_read_choice(s, &choice);
 232         per_read_object_identifier(s, t124_02_98_oid);
 233
 234         /* ConnectData::connectPDU (OCTET_STRING) */
 235         per_read_length(s, &length);
 236
 237         /* ConnectGCCPDU */
 238         per_read_choice(s, &choice);
 239
 240         /* ConferenceCreateResponse::nodeID (UserID) */
 241         per_read_integer16(s, &nodeID, 1001);
 242
 243         /* ConferenceCreateResponse::tag (INTEGER) */
 244         per_read_integer(s, &tag);
 245
 246         /* ConferenceCreateResponse::result (ENUMERATED) */
 247         per_read_enumerated(s, &result, MCS_Result_enum_length);
 248
 249         /* number of UserData sets */
 250         per_read_number_of_sets(s, &number);
 251
 252         /* UserData::value present + select h221NonStandard (1) */
 253         per_read_choice(s, &choice);
 254
 255         /* h221NonStandard */
 256         if (!per_read_octet_string(s, h221_sc_key, 4, 4)) /* h221NonStandard, server-to-client H.221 key, "McDn" */
 257                 return false;
 258
 259         /* userData (OCTET_STRING) */
 260         per_read_length(s, &length);
 261         if (!gcc_read_server_data_blocks(s, settings, length))
 262         {
 263                 printf("gcc_read_conference_create_response: gcc_read_server_data_blocks failed\n");
 264                 return false;
 265         }
 266
 267         return true;
 268 }
 269
 270 void gcc_write_conference_create_response(STREAM* s, STREAM* user_data)
 271 {
 272         /* ConnectData */
 273         per_write_choice(s, 0);
 274         per_write_object_identifier(s, t124_02_98_oid);
 275
 276         /* ConnectData::connectPDU (OCTET_STRING) */
 277         per_write_length(s, stream_get_length(user_data) + 2);
 278
 279         /* ConnectGCCPDU */
 280         per_write_choice(s, 0x14);
 281
 282         /* ConferenceCreateResponse::nodeID (UserID) */
 283         per_write_integer16(s, 0x79F3, 1001);
 284
 285         /* ConferenceCreateResponse::tag (INTEGER) */
 286         per_write_integer(s, 1);
 287
 288         /* ConferenceCreateResponse::result (ENUMERATED) */
 289         per_write_enumerated(s, 0, MCS_Result_enum_length);
 290
 291         /* number of UserData sets */
 292         per_write_number_of_sets(s, 1);
 293
 294         /* UserData::value present + select h221NonStandard (1) */
 295         per_write_choice(s, 0xC0);
 296
 297         /* h221NonStandard */
 298         per_write_octet_string(s, h221_sc_key, 4, 4); /* h221NonStandard, server-to-client H.221 key, "McDn" */
 299
 300         /* userData (OCTET_STRING) */
 301         per_write_octet_string(s, user_data->data, stream_get_length(user_data), 0); /* array of server data blocks */
 302 }
 303
 304 boolean gcc_read_client_data_blocks(STREAM* s, rdpSettings *settings, int length)
 305 {
 306         uint16 type;
 307         uint16 blockLength;
 308         int pos;
 309
 310         while (length > 0)
 311         {
 312                 pos = stream_get_pos(s);
 313                 gcc_read_user_data_header(s, &type, &blockLength);
 314
 315                 switch (type)
 316                 {
 317                         case CS_CORE:
 318                                 if (!gcc_read_client_core_data(s, settings, blockLength - 4))
 319                                         return false;
 320                                 break;
 321
 322                         case CS_SECURITY:
 323                                 if (!gcc_read_client_security_data(s, settings, blockLength - 4))
 324                                         return false;
 325                                 break;
 326
 327                         case CS_NET:
 328                                 if (!gcc_read_client_network_data(s, settings, blockLength - 4))
 329                                         return false;
 330                                 break;
 331
 332                         case CS_CLUSTER:
 333                                 if (!gcc_read_client_cluster_data(s, settings, blockLength - 4))
 334                                         return false;
 335                                 break;
 336
 337                         case CS_MONITOR:
 338                                 if (!gcc_read_client_monitor_data(s, settings, blockLength - 4))
 339                                         return false;
 340                                 break;
 341
 342                         default:
 343                                 break;
 344                 }
 345
 346                 length -= blockLength;
 347                 stream_set_pos(s, pos + blockLength);
 348         }
 349
 350         return true;
 351 }
 352
 353 void gcc_write_client_data_blocks(STREAM* s, rdpSettings* settings)
 354 {
 355         gcc_write_client_core_data(s, settings);
 356         gcc_write_client_cluster_data(s, settings);
 357         gcc_write_client_security_data(s, settings);
 358         gcc_write_client_network_data(s, settings);
 359
 360         /* extended client data supported */
 361
 362         if (settings->negotiationFlags)
 363                 gcc_write_client_monitor_data(s, settings);
 364 }
 365
 366 boolean gcc_read_server_data_blocks(STREAM* s, rdpSettings* settings, int length)
 367 {
 368         uint16 type;
 369         uint16 offset = 0;
 370         uint16 blockLength;
 371         uint8* holdp;
 372
 373         while (offset < length)
 374         {
 375                 holdp = s->p;
 376
 377                 if (!gcc_read_user_data_header(s, &type, &blockLength))
 378                 {
 379                         printf("gcc_read_server_data_blocks: gcc_read_user_data_header failed\n");
 380                         return false;
 381                 }
 382
 383                 switch (type)
 384                 {
 385                         case SC_CORE:
 386                                 if (!gcc_read_server_core_data(s, settings))
 387                                 {
 388                                         printf("gcc_read_server_data_blocks: gcc_read_server_core_data failed\n");
 389                                         return false;
 390                                 }
 391                                 break;
 392
 393                         case SC_SECURITY:
 394                                 if (!gcc_read_server_security_data(s, settings))
 395                                 {
 396                                         printf("gcc_read_server_data_blocks: gcc_read_server_security_data failed\n");
 397                                         return false;
 398                                 }
 399                                 break;
 400
 401                         case SC_NET:
 402                                 if (!gcc_read_server_network_data(s, settings))
 403                                 {
 404                                         printf("gcc_read_server_data_blocks: gcc_read_server_network_data failed\n");
 405                                         return false;
 406                                 }
 407                                 break;
 408
 409                         default:
 410                                 break;
 411                 }
 412                 offset += blockLength;
 413                 s->p = holdp + blockLength;
 414         }
 415
 416         return true;
 417 }
 418
 419 void gcc_write_server_data_blocks(STREAM* s, rdpSettings *settings)
 420 {
 421         gcc_write_server_core_data(s, settings);
 422         gcc_write_server_network_data(s, settings);
 423         gcc_write_server_security_data(s, settings);
 424 }
 425
 426 boolean gcc_read_user_data_header(STREAM* s, uint16* type, uint16* length)
 427 {
 428         stream_read_uint16(s, *type); /* type */
 429         stream_read_uint16(s, *length); /* length */
 430
 431         if (*length < 4)
 432                 return false;
 433
 434         if (stream_get_left(s) < *length - 4)
 435                 return false;
 436
 437         return true;
 438 }
 439
 440 /**
 441  * Write a user data header (TS_UD_HEADER).\n
 442  * @msdn{cc240509}
 443  * @param s stream
 444  * @param type data block type
 445  * @param length data block length
 446  */
 447
 448 void gcc_write_user_data_header(STREAM* s, uint16 type, uint16 length)
 449 {
 450         stream_write_uint16(s, type); /* type */
 451         stream_write_uint16(s, length); /* length */
 452 }
 453
 454 /**
 455  * Read a client core data block (TS_UD_CS_CORE).\n
 456  * @msdn{cc240510}
 457  * @param s stream
 458  * @param settings rdp settings
 459  */
 460
 461 boolean gcc_read_client_core_data(STREAM* s, rdpSettings *settings, uint16 blockLength)
 462 {
 463         uint32 version;
 464         uint16 colorDepth = 0;
 465         uint16 postBeta2ColorDepth = 0;
 466         uint16 highColorDepth = 0;
 467         uint16 supportedColorDepths = 0;
 468         uint16 earlyCapabilityFlags = 0;
 469         uint32 serverSelectedProtocol = 0;
 470         char* str;
 471
 472         /* Length of all required fields, until imeFileName */
 473         if (blockLength < 128)
 474                 return false;
 475
 476         stream_read_uint32(s, version); /* version */
 477         settings->rdp_version = (version == RDP_VERSION_4 ? 4 : 7);
 478
 479         stream_read_uint16(s, settings->width); /* desktopWidth */
 480         stream_read_uint16(s, settings->height); /* desktopHeight */
 481         stream_read_uint16(s, colorDepth); /* colorDepth */
 482         stream_seek_uint16(s); /* SASSequence (Secure Access Sequence) */
 483         stream_read_uint32(s, settings->kbd_layout); /* keyboardLayout */
 484         stream_read_uint32(s, settings->client_build); /* clientBuild */
 485
 486         /* clientName (32 bytes, null-terminated unicode, truncated to 15 characters) */
 487         str = freerdp_uniconv_in(settings->uniconv, stream_get_tail(s), 32);
 488         stream_seek(s, 32);
 489         snprintf(settings->client_hostname, sizeof(settings->client_hostname), "%s", str);
 490         xfree(str);
 491
 492         stream_read_uint32(s, settings->kbd_type); /* keyboardType */
 493         stream_read_uint32(s, settings->kbd_subtype); /* keyboardSubType */
 494         stream_read_uint32(s, settings->kbd_fn_keys); /* keyboardFunctionKey */
 495
 496         stream_seek(s, 64); /* imeFileName */
 497
 498         blockLength -= 128;
 499
 500         /**
 501          * The following fields are all optional. If one field is present, all of the preceding
 502          * fields MUST also be present. If one field is not present, all of the subsequent fields
 503          * MUST NOT be present.
 504          * We must check the bytes left before reading each field.
 505          */
 506
 507         do
 508         {
 509                 if (blockLength < 2)
 510                         break;
 511                 stream_read_uint16(s, postBeta2ColorDepth); /* postBeta2ColorDepth */
 512                 blockLength -= 2;
 513
 514                 if (blockLength < 2)
 515                         break;
 516                 stream_seek_uint16(s); /* clientProductID */
 517                 blockLength -= 2;
 518
 519                 if (blockLength < 4)
 520                         break;
 521                 stream_seek_uint32(s); /* serialNumber */
 522                 blockLength -= 4;
 523
 524                 if (blockLength < 2)
 525                         break;
 526                 stream_read_uint16(s, highColorDepth); /* highColorDepth */
 527                 blockLength -= 2;
 528
 529                 if (blockLength < 2)
 530                         break;
 531                 stream_read_uint16(s, supportedColorDepths); /* supportedColorDepths */
 532                 blockLength -= 2;
 533
 534                 if (blockLength < 2)
 535                         break;
 536                 stream_read_uint16(s, earlyCapabilityFlags); /* earlyCapabilityFlags */
 537                 blockLength -= 2;
 538
 539                 if (blockLength < 64)
 540                         break;
 541                 str = freerdp_uniconv_in(settings->uniconv, stream_get_tail(s), 64);
 542                 stream_seek(s, 64);
 543                 snprintf(settings->client_product_id, sizeof(settings->client_product_id), "%s", str);
 544                 xfree(str);
 545                 blockLength -= 64;
 546
 547                 if (blockLength < 1)
 548                         break;
 549                 stream_read_uint8(s, settings->performance_flags); /* connectionType */
 550                 blockLength -= 1;
 551
 552                 if (blockLength < 1)
 553                         break;
 554                 stream_seek_uint8(s); /* pad1octet */
 555                 blockLength -= 1;
 556
 557                 if (blockLength < 4)
 558                         break;
 559                 stream_read_uint32(s, serverSelectedProtocol); /* serverSelectedProtocol */
 560                 blockLength -= 4;
 561
 562                 if (settings->selected_protocol != serverSelectedProtocol)
 563                         return false;
 564         } while (0);
 565
 566         if (highColorDepth > 0)
 567                 settings->color_depth = highColorDepth;
 568         else if (postBeta2ColorDepth > 0)
 569         {
 570                 switch (postBeta2ColorDepth)
 571                 {
 572                         case RNS_UD_COLOR_4BPP:
 573                                 settings->color_depth = 4;
 574                                 break;
 575                         case RNS_UD_COLOR_8BPP:
 576                                 settings->color_depth = 8;
 577                                 break;
 578                         case RNS_UD_COLOR_16BPP_555:
 579                                 settings->color_depth = 15;
 580                                 break;
 581                         case RNS_UD_COLOR_16BPP_565:
 582                                 settings->color_depth = 16;
 583                                 break;
 584                         case RNS_UD_COLOR_24BPP:
 585                                 settings->color_depth = 24;
 586                                 break;
 587                         default:
 588                                 return false;
 589                 }
 590         }
 591         else
 592         {
 593                 switch (colorDepth)
 594                 {
 595                         case RNS_UD_COLOR_4BPP:
 596                                 settings->color_depth = 4;
 597                                 break;
 598                         case RNS_UD_COLOR_8BPP:
 599                                 settings->color_depth = 8;
 600                                 break;
 601                         default:
 602                                 return false;
 603                 }
 604         }
 605
 606         return true;
 607 }
 608
 609 /**
 610  * Write a client core data block (TS_UD_CS_CORE).\n
 611  * @msdn{cc240510}
 612  * @param s stream
 613  * @param settings rdp settings
 614  */
 615
 616 void gcc_write_client_core_data(STREAM* s, rdpSettings *settings)
 617 {
 618         uint32 version;
 619         char* clientName;
 620         size_t clientNameLength;
 621         uint8 connectionType;
 622         uint16 highColorDepth;
 623         uint16 supportedColorDepths;
 624         uint16 earlyCapabilityFlags;
 625         char* clientDigProductId;
 626         size_t clientDigProductIdLength;
 627
 628         gcc_write_user_data_header(s, CS_CORE, 216);
 629
 630         version = settings->rdp_version >= 5 ? RDP_VERSION_5_PLUS : RDP_VERSION_4;
 631         clientName = freerdp_uniconv_out(settings->uniconv, settings->client_hostname, &clientNameLength);
 632         clientDigProductId = freerdp_uniconv_out(settings->uniconv, settings->client_product_id, &clientDigProductIdLength);
 633
 634         stream_write_uint32(s, version); /* version */
 635         stream_write_uint16(s, settings->width); /* desktopWidth */
 636         stream_write_uint16(s, settings->height); /* desktopHeight */
 637         stream_write_uint16(s, RNS_UD_COLOR_8BPP); /* colorDepth, ignored because of postBeta2ColorDepth */
 638         stream_write_uint16(s, RNS_UD_SAS_DEL); /* SASSequence (Secure Access Sequence) */
 639         stream_write_uint32(s, settings->kbd_layout); /* keyboardLayout */
 640         stream_write_uint32(s, settings->client_build); /* clientBuild */
 641
 642         /* clientName (32 bytes, null-terminated unicode, truncated to 15 characters) */
 643         if (clientNameLength > 30)
 644         {
 645                 clientNameLength = 30;
 646                 clientName[clientNameLength] = 0;
 647                 clientName[clientNameLength + 1] = 0;
 648         }
 649         stream_write(s, clientName, clientNameLength + 2);
 650         stream_write_zero(s, 32 - clientNameLength - 2);
 651         xfree(clientName);
 652
 653         stream_write_uint32(s, settings->kbd_type); /* keyboardType */
 654         stream_write_uint32(s, settings->kbd_subtype); /* keyboardSubType */
 655         stream_write_uint32(s, settings->kbd_fn_keys); /* keyboardFunctionKey */
 656
 657         stream_write_zero(s, 64); /* imeFileName */
 658
 659         stream_write_uint16(s, RNS_UD_COLOR_8BPP); /* postBeta2ColorDepth */
 660         stream_write_uint16(s, 1); /* clientProductID */
 661         stream_write_uint32(s, 0); /* serialNumber (should be initialized to 0) */
 662
 663         highColorDepth = MIN(settings->color_depth, 24);
 664
 665         supportedColorDepths =
 666                         RNS_UD_24BPP_SUPPORT |
 667                         RNS_UD_16BPP_SUPPORT |
 668                         RNS_UD_15BPP_SUPPORT;
 669
 670         connectionType = settings->connection_type;
 671         earlyCapabilityFlags = RNS_UD_CS_SUPPORT_ERRINFO_PDU;
 672
 673         if (settings->rfx_codec)
 674                 connectionType = CONNECTION_TYPE_LAN;
 675
 676         if (connectionType != 0)
 677                 earlyCapabilityFlags |= RNS_UD_CS_VALID_CONNECTION_TYPE;
 678
 679         if (settings->color_depth == 32)
 680         {
 681                 supportedColorDepths |= RNS_UD_32BPP_SUPPORT;
 682                 earlyCapabilityFlags |= RNS_UD_CS_WANT_32BPP_SESSION;
 683         }
 684
 685         stream_write_uint16(s, highColorDepth); /* highColorDepth */
 686         stream_write_uint16(s, supportedColorDepths); /* supportedColorDepths */
 687
 688         stream_write_uint16(s, earlyCapabilityFlags); /* earlyCapabilityFlags */
 689
 690         /* clientDigProductId (64 bytes, null-terminated unicode, truncated to 30 characters) */
 691         if (clientDigProductIdLength > 62)
 692         {
 693                 clientDigProductIdLength = 62;
 694                 clientDigProductId[clientDigProductIdLength] = 0;
 695                 clientDigProductId[clientDigProductIdLength + 1] = 0;
 696         }
 697         stream_write(s, clientDigProductId, clientDigProductIdLength + 2);
 698         stream_write_zero(s, 64 - clientDigProductIdLength - 2);
 699         xfree(clientDigProductId);
 700
 701         stream_write_uint8(s, connectionType); /* connectionType */
 702         stream_write_uint8(s, 0); /* pad1octet */
 703
 704         stream_write_uint32(s, settings->selected_protocol); /* serverSelectedProtocol */
 705 }
 706
 707 boolean gcc_read_server_core_data(STREAM* s, rdpSettings *settings)
 708 {
 709         uint32 version;
 710         uint32 clientRequestedProtocols;
 711
 712         stream_read_uint32(s, version); /* version */
 713         stream_read_uint32(s, clientRequestedProtocols); /* clientRequestedProtocols */
 714
 715         if (version == RDP_VERSION_4 && settings->rdp_version > 4)
 716                 settings->rdp_version = 4;
 717         else if (version == RDP_VERSION_5_PLUS && settings->rdp_version < 5)
 718                 settings->rdp_version = 7;
 719
 720         return true;
 721 }
 722
 723 void gcc_write_server_core_data(STREAM* s, rdpSettings *settings)
 724 {
 725         gcc_write_user_data_header(s, SC_CORE, 12);
 726
 727         stream_write_uint32(s, settings->rdp_version == 4 ? RDP_VERSION_4 : RDP_VERSION_5_PLUS);
 728         stream_write_uint32(s, settings->requested_protocols); /* clientRequestedProtocols */
 729 }
 730
 731 /**
 732  * Read a client security data block (TS_UD_CS_SEC).\n
 733  * @msdn{cc240511}
 734  * @param s stream
 735  * @param settings rdp settings
 736  */
 737
 738 boolean gcc_read_client_security_data(STREAM* s, rdpSettings *settings, uint16 blockLength)
 739 {
 740         if (blockLength < 8)
 741                 return false;
 742
 743         stream_read_uint32(s, settings->encryption_method); /* encryptionMethods */
 744         if (settings->encryption_method == 0)
 745                 stream_read_uint32(s, settings->encryption_method); /* extEncryptionMethods */
 746
 747         return true;
 748 }
 749
 750 /**
 751  * Write a client security data block (TS_UD_CS_SEC).\n
 752  * @msdn{cc240511}
 753  * @param s stream
 754  * @param settings rdp settings
 755  */
 756
 757 void gcc_write_client_security_data(STREAM* s, rdpSettings *settings)
 758 {
 759         gcc_write_user_data_header(s, CS_SECURITY, 12);
 760
 761         if (settings->encryption)
 762         {
 763                 stream_write_uint32(s, settings->encryption_method); /* encryptionMethods */
 764                 stream_write_uint32(s, 0); /* extEncryptionMethods */
 765         }
 766         else
 767         {
 768                 /* French locale, disable encryption */
 769                 stream_write_uint32(s, 0); /* encryptionMethods */
 770                 stream_write_uint32(s, settings->encryption_method); /* extEncryptionMethods */
 771         }
 772 }
 773
 774 boolean gcc_read_server_security_data(STREAM* s, rdpSettings *settings)
 775 {
 776         uint8* data;
 777         uint32 length;
 778         uint32 serverRandomLen;
 779         uint32 serverCertLen;
 780
 781         stream_read_uint32(s, settings->encryption_method); /* encryptionMethod */
 782         stream_read_uint32(s, settings->encryption_level); /* encryptionLevel */
 783
 784         if (settings->encryption_method == 0 && settings->encryption_level == 0)
 785         {
 786                 /* serverRandom and serverRandom must not be present */
 787                 settings->encryption = false;
 788                 settings->encryption_method = ENCRYPTION_METHOD_NONE;
 789                 settings->encryption_level = ENCRYPTION_LEVEL_NONE;
 790                 return true;
 791         }
 792
 793         stream_read_uint32(s, serverRandomLen); /* serverRandomLen */
 794         stream_read_uint32(s, serverCertLen); /* serverCertLen */
 795
 796         if (serverRandomLen > 0)
 797         {
 798                 /* serverRandom */
 799                 freerdp_blob_alloc(settings->server_random, serverRandomLen);
 800                 stream_read(s, settings->server_random->data, serverRandomLen);
 801         }
 802         else
 803         {
 804                 return false;
 805         }
 806
 807         if (serverCertLen > 0)
 808         {
 809                 /* serverCertificate */
 810                 freerdp_blob_alloc(settings->server_certificate, serverCertLen);
 811                 stream_read(s, settings->server_certificate->data, serverCertLen);
 812                 certificate_free(settings->server_cert);
 813                 settings->server_cert = certificate_new();
 814                 data = settings->server_certificate->data;
 815                 length = settings->server_certificate->length;
 816
 817                 if (!certificate_read_server_certificate(settings->server_cert, data, length))
 818                         return false;
 819         }
 820         else
 821         {
 822                 return false;
 823         }
 824
 825         return true;
 826 }
 827
 828 void gcc_write_server_security_data(STREAM* s, rdpSettings *settings)
 829 {
 830         gcc_write_user_data_header(s, SC_SECURITY, 12);
 831
 832         stream_write_uint32(s, ENCRYPTION_METHOD_NONE); /* encryptionMethod */
 833         stream_write_uint32(s, ENCRYPTION_LEVEL_NONE); /* encryptionLevel */
 834 #if 0
 835         stream_write_uint32(s, 0); /* serverRandomLen */
 836         stream_write_uint32(s, 0); /* serverCertLen */
 837 #endif
 838 }
 839
 840 /**
 841  * Read a client network data block (TS_UD_CS_NET).\n
 842  * @msdn{cc240512}
 843  * @param s stream
 844  * @param settings rdp settings
 845  */
 846
 847 boolean gcc_read_client_network_data(STREAM* s, rdpSettings *settings, uint16 blockLength)
 848 {
 849         int i;
 850
 851         if (blockLength < 4)
 852                 return false;
 853
 854         stream_read_uint32(s, settings->num_channels); /* channelCount */
 855         if (blockLength < 4 + settings->num_channels * 12)
 856                 return false;
 857         if (settings->num_channels > 16)
 858                 return false;
 859
 860         /* channelDefArray */
 861         for (i = 0; i < settings->num_channels; i++)
 862         {
 863                 /* CHANNEL_DEF */
 864                 stream_read(s, settings->channels[i].name, 8); /* name (8 bytes) */
 865                 stream_read_uint32(s, settings->channels[i].options); /* options (4 bytes) */
 866                 settings->channels[i].channel_id = MCS_GLOBAL_CHANNEL_ID + 1 + i;
 867         }
 868
 869         return true;
 870 }
 871
 872 /**
 873  * Write a client network data block (TS_UD_CS_NET).\n
 874  * @msdn{cc240512}
 875  * @param s stream
 876  * @param settings rdp settings
 877  */
 878
 879 void gcc_write_client_network_data(STREAM* s, rdpSettings *settings)
 880 {
 881         int i;
 882         uint16 length;
 883
 884         if (settings->num_channels > 0)
 885         {
 886                 length = settings->num_channels * 12 + 8;
 887                 gcc_write_user_data_header(s, CS_NET, length);
 888
 889                 stream_write_uint32(s, settings->num_channels); /* channelCount */
 890
 891                 /* channelDefArray */
 892                 for (i = 0; i < settings->num_channels; i++)
 893                 {
 894                         /* CHANNEL_DEF */
 895                         stream_write(s, settings->channels[i].name, 8); /* name (8 bytes) */
 896                         stream_write_uint32(s, settings->channels[i].options); /* options (4 bytes) */
 897                 }
 898         }
 899 }
 900
 901 boolean gcc_read_server_network_data(STREAM* s, rdpSettings *settings)
 902 {
 903         int i;
 904         uint16 MCSChannelId;
 905         uint16 channelCount;
 906         uint16 channelId;
 907
 908         stream_read_uint16(s, MCSChannelId); /* MCSChannelId */
 909         stream_read_uint16(s, channelCount); /* channelCount */
 910
 911         if (channelCount != settings->num_channels)
 912         {
 913                 printf("requested %d channels, got %d instead\n",
 914                                 settings->num_channels, channelCount);
 915         }
 916
 917         for (i = 0; i < channelCount; i++)
 918         {
 919                 stream_read_uint16(s, channelId); /* channelId */
 920                 settings->channels[i].channel_id = channelId;
 921         }
 922
 923         if (channelCount % 2 == 1)
 924                 stream_seek(s, 2); /* padding */
 925
 926         return true;
 927 }
 928
 929 void gcc_write_server_network_data(STREAM* s, rdpSettings *settings)
 930 {
 931         int i;
 932
 933         gcc_write_user_data_header(s, SC_NET, 8 + settings->num_channels * 2 + (settings->num_channels % 2 == 1 ? 2 : 0));
 934
 935         stream_write_uint16(s, MCS_GLOBAL_CHANNEL_ID); /* MCSChannelId */
 936         stream_write_uint16(s, settings->num_channels); /* channelCount */
 937
 938         for (i = 0; i < settings->num_channels; i++)
 939         {
 940                 stream_write_uint16(s, settings->channels[i].channel_id);
 941         }
 942
 943         if (settings->num_channels % 2 == 1)
 944                 stream_write_uint16(s, 0);
 945 }
 946
 947 /**
 948  * Read a client cluster data block (TS_UD_CS_CLUSTER).\n
 949  * @msdn{cc240514}
 950  * @param s stream
 951  * @param settings rdp settings
 952  */
 953
 954 boolean gcc_read_client_cluster_data(STREAM* s, rdpSettings *settings, uint16 blockLength)
 955 {
 956         uint32 flags;
 957
 958         if (blockLength < 8)
 959                 return false;
 960
 961         stream_read_uint32(s, flags); /* flags */
 962
 963         if ((flags | REDIRECTED_SESSIONID_FIELD_VALID))
 964                 stream_read_uint32(s, settings->redirected_session_id); /* redirectedSessionID */
 965
 966         return true;
 967 }
 968
 969 /**
 970  * Write a client cluster data block (TS_UD_CS_CLUSTER).\n
 971  * @msdn{cc240514}
 972  * @param s stream
 973  * @param settings rdp settings
 974  */
 975
 976 void gcc_write_client_cluster_data(STREAM* s, rdpSettings *settings)
 977 {
 978         uint32 flags;
 979
 980         gcc_write_user_data_header(s, CS_CLUSTER, 12);
 981
 982         flags = REDIRECTION_SUPPORTED | (REDIRECTION_VERSION4 << 2);
 983
 984         if (settings->console_session || settings->redirected_session_id)
 985                 flags |= REDIRECTED_SESSIONID_FIELD_VALID;
 986
 987         stream_write_uint32(s, flags); /* flags */
 988         stream_write_uint32(s, settings->redirected_session_id); /* redirectedSessionID */
 989 }
 990
 991 /**
 992  * Read a client monitor data block (TS_UD_CS_MONITOR).\n
 993  * @msdn{dd305336}
 994  * @param s stream
 995  * @param settings rdp settings
 996  */
 997
 998 boolean gcc_read_client_monitor_data(STREAM* s, rdpSettings *settings, uint16 blockLength)
 999 {
1000         printf("CS_MONITOR\n");
1001         return true;
1002 }
1003
1004 /**
1005  * Write a client monitor data block (TS_UD_CS_MONITOR).\n
1006  * @msdn{dd305336}
1007  * @param s stream
1008  * @param settings rdp settings
1009  */
1010
1011 void gcc_write_client_monitor_data(STREAM* s, rdpSettings *settings)
1012 {
1013         int i;
1014         uint16 length;
1015         uint32 left, top, right, bottom, flags;
1016
1017         if (settings->num_monitors > 1)
1018         {
1019                 length = (20 * settings->num_monitors) + 12;
1020                 gcc_write_user_data_header(s, CS_MONITOR, length);
1021
1022                 stream_write_uint32(s, 0); /* flags */
1023                 stream_write_uint32(s, settings->num_monitors); /* monitorCount */
1024
1025                 for (i = 0; i < settings->num_monitors; i++)
1026                 {
1027                         left = settings->monitors[i].x;
1028                         top = settings->monitors[i].y;
1029                         right = settings->monitors[i].x + settings->monitors[i].width - 1;
1030                         bottom = settings->monitors[i].y + settings->monitors[i].height - 1;
1031                         flags = settings->monitors[i].is_primary ? MONITOR_PRIMARY : 0;
1032
1033                         stream_write_uint32(s, left); /* left */
1034                         stream_write_uint32(s, top); /* top */
1035                         stream_write_uint32(s, right); /* right */
1036                         stream_write_uint32(s, bottom); /* bottom */
1037                         stream_write_uint32(s, flags); /* flags */
1038                 }
1039         }
1040 }
1041