libfreerdp-core/rdp.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol Client
   3  * RDP Core
   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 "rdp.h"
  21
  22 #include "info.h"
  23 #include "per.h"
  24 #include "redirection.h"
  25
  26 static const char* const DATA_PDU_TYPE_STRINGS[] =
  27 {
  28                 "", "", /* 0x00 - 0x01 */
  29                 "Update", /* 0x02 */
  30                 "", "", "", "", "", "", "", "", /* 0x03 - 0x0A */
  31                 "", "", "", "", "", "", "", "", "", /* 0x0B - 0x13 */
  32                 "Control", /* 0x14 */
  33                 "", "", "", "", "", "", /* 0x15 - 0x1A */
  34                 "Pointer", /* 0x1B */
  35                 "Input", /* 0x1C */
  36                 "", "", /* 0x1D - 0x1E */
  37                 "Synchronize", /* 0x1F */
  38                 "", /* 0x20 */
  39                 "Refresh Rect", /* 0x21 */
  40                 "Play Sound", /* 0x22 */
  41                 "Suppress Output", /* 0x23 */
  42                 "Shutdown Request", /* 0x24 */
  43                 "Shutdown Denied", /* 0x25 */
  44                 "Save Session Info", /* 0x26 */
  45                 "Font List", /* 0x27 */
  46                 "Font Map", /* 0x28 */
  47                 "Set Keyboard Indicators", /* 0x29 */
  48                 "", /* 0x2A */
  49                 "Bitmap Cache Persistent List", /* 0x2B */
  50                 "Bitmap Cache Error", /* 0x2C */
  51                 "Set Keyboard IME Status", /* 0x2D */
  52                 "Offscreen Cache Error", /* 0x2E */
  53                 "Set Error Info", /* 0x2F */
  54                 "Draw Nine Grid Error", /* 0x30 */
  55                 "Draw GDI+ Error", /* 0x31 */
  56                 "ARC Status", /* 0x32 */
  57                 "", "", "", /* 0x33 - 0x35 */
  58                 "Status Info", /* 0x36 */
  59                 "Monitor Layout" /* 0x37 */
  60                 "", "", "", /* 0x38 - 0x40 */
  61                 "", "", "", "", "", "" /* 0x41 - 0x46 */
  62 };
  63
  64 /**
  65  * Read RDP Security Header.\n
  66  * @msdn{cc240579}
  67  * @param s stream
  68  * @param flags security flags
  69  */
  70
  71 void rdp_read_security_header(STREAM* s, uint16* flags)
  72 {
  73         /* Basic Security Header */
  74         stream_read_uint16(s, *flags); /* flags */
  75         stream_seek(s, 2); /* flagsHi (unused) */
  76 }
  77
  78 /**
  79  * Write RDP Security Header.\n
  80  * @msdn{cc240579}
  81  * @param s stream
  82  * @param flags security flags
  83  */
  84
  85 void rdp_write_security_header(STREAM* s, uint16 flags)
  86 {
  87         /* Basic Security Header */
  88         stream_write_uint16(s, flags); /* flags */
  89         stream_write_uint16(s, 0); /* flagsHi (unused) */
  90 }
  91
  92 boolean rdp_read_share_control_header(STREAM* s, uint16* length, uint16* type, uint16* channel_id)
  93 {
  94         /* Share Control Header */
  95         stream_read_uint16(s, *length); /* totalLength */
  96         stream_read_uint16(s, *type); /* pduType */
  97         stream_read_uint16(s, *channel_id); /* pduSource */
  98         *type &= 0x0F; /* type is in the 4 least significant bits */
  99
 100         if (*length - 6 > stream_get_left(s))
 101                 return false;
 102
 103         return true;
 104 }
 105
 106 void rdp_write_share_control_header(STREAM* s, uint16 length, uint16 type, uint16 channel_id)
 107 {
 108         length -= (s->p - s->data);
 109
 110         /* Share Control Header */
 111         stream_write_uint16(s, length); /* totalLength */
 112         stream_write_uint16(s, type | 0x10); /* pduType */
 113         stream_write_uint16(s, channel_id); /* pduSource */
 114 }
 115
 116 boolean rdp_read_share_data_header(STREAM* s, uint16* length, uint8* type, uint32* share_id,
 117                                         uint8 *compressed_type, uint16 *compressed_len)
 118 {
 119         if (stream_get_left(s) < 12)
 120                 return false;
 121
 122         /* Share Data Header */
 123         stream_read_uint32(s, *share_id); /* shareId (4 bytes) */
 124         stream_seek_uint8(s); /* pad1 (1 byte) */
 125         stream_seek_uint8(s); /* streamId (1 byte) */
 126         stream_read_uint16(s, *length); /* uncompressedLength (2 bytes) */
 127         stream_read_uint8(s, *type); /* pduType2, Data PDU Type (1 byte) */
 128         if (*type & 0x80)
 129         {
 130                 stream_read_uint8(s, *compressed_type); /* compressedType (1 byte) */
 131                 stream_read_uint16(s, *compressed_len); /* compressedLength (2 bytes) */
 132         }
 133         else
 134         {
 135                 stream_seek(s, 3);
 136                 *compressed_type = 0;
 137                 *compressed_len = 0;
 138         }
 139
 140         return true;
 141 }
 142
 143 void rdp_write_share_data_header(STREAM* s, uint16 length, uint8 type, uint32 share_id)
 144 {
 145         length -= RDP_PACKET_HEADER_LENGTH;
 146         length -= RDP_SHARE_CONTROL_HEADER_LENGTH;
 147         length -= RDP_SHARE_DATA_HEADER_LENGTH;
 148
 149         /* Share Data Header */
 150         stream_write_uint32(s, share_id); /* shareId (4 bytes) */
 151         stream_write_uint8(s, 0); /* pad1 (1 byte) */
 152         stream_write_uint8(s, STREAM_LOW); /* streamId (1 byte) */
 153         stream_write_uint16(s, length); /* uncompressedLength (2 bytes) */
 154         stream_write_uint8(s, type); /* pduType2, Data PDU Type (1 byte) */
 155         stream_write_uint8(s, 0); /* compressedType (1 byte) */
 156         stream_write_uint16(s, 0); /* compressedLength (2 bytes) */
 157 }
 158
 159 static int rdp_security_stream_init(rdpRdp* rdp, STREAM* s)
 160 {
 161         if (rdp->do_crypt)
 162         {
 163                 stream_seek(s, 12);
 164                 if (rdp->settings->encryption_method == ENCRYPTION_METHOD_FIPS)
 165                         stream_seek(s, 4);
 166                 rdp->sec_flags |= SEC_ENCRYPT;
 167         }
 168         else if (rdp->sec_flags != 0)
 169         {
 170                 stream_seek(s, 4);
 171         }
 172         return 0;
 173 }
 174
 175 /**
 176  * Initialize an RDP packet stream.\n
 177  * @param rdp rdp module
 178  * @return
 179  */
 180
 181 STREAM* rdp_send_stream_init(rdpRdp* rdp)
 182 {
 183         STREAM* s;
 184
 185         s = transport_send_stream_init(rdp->transport, 2048);
 186         stream_seek(s, RDP_PACKET_HEADER_LENGTH);
 187         rdp_security_stream_init(rdp, s);
 188
 189         return s;
 190 }
 191
 192 STREAM* rdp_pdu_init(rdpRdp* rdp)
 193 {
 194         STREAM* s;
 195         s = transport_send_stream_init(rdp->transport, 2048);
 196         stream_seek(s, RDP_PACKET_HEADER_LENGTH);
 197         rdp_security_stream_init(rdp, s);
 198         stream_seek(s, RDP_SHARE_CONTROL_HEADER_LENGTH);
 199         return s;
 200 }
 201
 202 STREAM* rdp_data_pdu_init(rdpRdp* rdp)
 203 {
 204         STREAM* s;
 205         s = transport_send_stream_init(rdp->transport, 2048);
 206         stream_seek(s, RDP_PACKET_HEADER_LENGTH);
 207         rdp_security_stream_init(rdp, s);
 208         stream_seek(s, RDP_SHARE_CONTROL_HEADER_LENGTH);
 209         stream_seek(s, RDP_SHARE_DATA_HEADER_LENGTH);
 210         return s;
 211 }
 212
 213 /**
 214  * Read an RDP packet header.\n
 215  * @param rdp rdp module
 216  * @param s stream
 217  * @param length RDP packet length
 218  * @param channel_id channel id
 219  */
 220
 221 boolean rdp_read_header(rdpRdp* rdp, STREAM* s, uint16* length, uint16* channel_id)
 222 {
 223         uint16 initiator;
 224         enum DomainMCSPDU MCSPDU;
 225
 226         MCSPDU = (rdp->settings->server_mode) ? DomainMCSPDU_SendDataRequest : DomainMCSPDU_SendDataIndication;
 227         mcs_read_domain_mcspdu_header(s, &MCSPDU, length);
 228
 229         per_read_integer16(s, &initiator, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
 230         per_read_integer16(s, channel_id, 0); /* channelId */
 231         stream_seek(s, 1); /* dataPriority + Segmentation (0x70) */
 232         per_read_length(s, length); /* userData (OCTET_STRING) */
 233
 234         if (*length > stream_get_left(s))
 235                 return false;
 236
 237         return true;
 238 }
 239
 240 /**
 241  * Write an RDP packet header.\n
 242  * @param rdp rdp module
 243  * @param s stream
 244  * @param length RDP packet length
 245  * @param channel_id channel id
 246  */
 247
 248 void rdp_write_header(rdpRdp* rdp, STREAM* s, uint16 length, uint16 channel_id)
 249 {
 250         int body_length;
 251         enum DomainMCSPDU MCSPDU;
 252
 253         MCSPDU = (rdp->settings->server_mode) ? DomainMCSPDU_SendDataIndication : DomainMCSPDU_SendDataRequest;
 254
 255         if ((rdp->sec_flags & SEC_ENCRYPT) && (rdp->settings->encryption_method == ENCRYPTION_METHOD_FIPS))
 256         {
 257                 int pad;
 258
 259                 body_length = length - RDP_PACKET_HEADER_LENGTH - 16;
 260                 pad = 8 - (body_length % 8);
 261                 if (pad != 8)
 262                         length += pad;
 263         }
 264
 265         mcs_write_domain_mcspdu_header(s, MCSPDU, length, 0);
 266         per_write_integer16(s, rdp->mcs->user_id, MCS_BASE_CHANNEL_ID); /* initiator */
 267         per_write_integer16(s, channel_id, 0); /* channelId */
 268         stream_write_uint8(s, 0x70); /* dataPriority + segmentation */
 269
 270         length = (length - RDP_PACKET_HEADER_LENGTH) | 0x8000;
 271         stream_write_uint16_be(s, length); /* userData (OCTET_STRING) */
 272 }
 273
 274 static uint32 rdp_security_stream_out(rdpRdp* rdp, STREAM* s, int length)
 275 {
 276         uint32 ml;
 277         uint8* mk;
 278         uint8* data;
 279         uint32 sec_flags;
 280         uint32 pad = 0;
 281
 282         sec_flags = rdp->sec_flags;
 283
 284         if (sec_flags != 0)
 285         {
 286                 rdp_write_security_header(s, sec_flags);
 287
 288                 if (sec_flags & SEC_ENCRYPT)
 289                 {
 290                         if (rdp->settings->encryption_method == ENCRYPTION_METHOD_FIPS)
 291                         {
 292                                 data = s->p + 12;
 293
 294                                 length = length - (data - s->data);
 295                                 stream_write_uint16(s, 0x10); /* length */
 296                                 stream_write_uint8(s, 0x1); /* TSFIPS_VERSION 1*/
 297
 298                                 /* handle padding */
 299                                 pad = 8 - (length % 8);
 300
 301                                 if (pad == 8)
 302                                         pad = 0;
 303                                 if (pad)
 304                                         memset(data+length, 0, pad);
 305
 306                                 stream_write_uint8(s, pad);
 307
 308                                 security_hmac_signature(data, length, s->p, rdp);
 309                                 stream_seek(s, 8);
 310                                 security_fips_encrypt(data, length + pad, rdp);
 311                         }
 312                         else
 313                         {
 314                                 data = s->p + 8;
 315                                 length = length - (data - s->data);
 316
 317                                 mk = rdp->sign_key;
 318                                 ml = rdp->rc4_key_len;
 319                                 security_mac_signature(mk, ml, data, length, s->p);
 320                                 stream_seek(s, 8);
 321                                 security_encrypt(s->p, length, rdp);
 322                         }
 323                 }
 324
 325                 rdp->sec_flags = 0;
 326         }
 327
 328         return pad;
 329 }
 330
 331 static uint32 rdp_get_sec_bytes(rdpRdp* rdp)
 332 {
 333         uint32 sec_bytes;
 334
 335         if (rdp->sec_flags & SEC_ENCRYPT)
 336         {
 337                 sec_bytes = 12;
 338
 339                 if (rdp->settings->encryption_method == ENCRYPTION_METHOD_FIPS)
 340                         sec_bytes += 4;
 341         }
 342         else if (rdp->sec_flags != 0)
 343         {
 344                 sec_bytes = 4;
 345         }
 346         else
 347         {
 348                 sec_bytes = 0;
 349         }
 350
 351         return sec_bytes;
 352 }
 353
 354 /**
 355  * Send an RDP packet.\n
 356  * @param rdp RDP module
 357  * @param s stream
 358  * @param channel_id channel id
 359  */
 360
 361 boolean rdp_send(rdpRdp* rdp, STREAM* s, uint16 channel_id)
 362 {
 363         uint16 length;
 364         uint32 sec_bytes;
 365         uint8* sec_hold;
 366
 367         length = stream_get_length(s);
 368         stream_set_pos(s, 0);
 369
 370         rdp_write_header(rdp, s, length, channel_id);
 371
 372         sec_bytes = rdp_get_sec_bytes(rdp);
 373         sec_hold = s->p;
 374         stream_seek(s, sec_bytes);
 375
 376         s->p = sec_hold;
 377         length += rdp_security_stream_out(rdp, s, length);
 378
 379         stream_set_pos(s, length);
 380         if (transport_write(rdp->transport, s) < 0)
 381                 return false;
 382
 383         return true;
 384 }
 385
 386 boolean rdp_send_pdu(rdpRdp* rdp, STREAM* s, uint16 type, uint16 channel_id)
 387 {
 388         uint16 length;
 389         uint32 sec_bytes;
 390         uint8* sec_hold;
 391
 392         length = stream_get_length(s);
 393         stream_set_pos(s, 0);
 394
 395         rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID);
 396
 397         sec_bytes = rdp_get_sec_bytes(rdp);
 398         sec_hold = s->p;
 399         stream_seek(s, sec_bytes);
 400
 401         rdp_write_share_control_header(s, length, type, channel_id);
 402
 403         s->p = sec_hold;
 404         length += rdp_security_stream_out(rdp, s, length);
 405
 406         stream_set_pos(s, length);
 407         if (transport_write(rdp->transport, s) < 0)
 408                 return false;
 409
 410         return true;
 411 }
 412
 413 boolean rdp_send_data_pdu(rdpRdp* rdp, STREAM* s, uint8 type, uint16 channel_id)
 414 {
 415         uint16 length;
 416         uint32 sec_bytes;
 417         uint8* sec_hold;
 418
 419         length = stream_get_length(s);
 420         stream_set_pos(s, 0);
 421
 422         rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID);
 423
 424         sec_bytes = rdp_get_sec_bytes(rdp);
 425         sec_hold = s->p;
 426         stream_seek(s, sec_bytes);
 427
 428         rdp_write_share_control_header(s, length, PDU_TYPE_DATA, channel_id);
 429         rdp_write_share_data_header(s, length, type, rdp->settings->share_id);
 430
 431         s->p = sec_hold;
 432         length += rdp_security_stream_out(rdp, s, length);
 433
 434         stream_set_pos(s, length);
 435         if (transport_write(rdp->transport, s) < 0)
 436                 return false;
 437
 438         return true;
 439 }
 440
 441 void rdp_recv_set_error_info_data_pdu(rdpRdp* rdp, STREAM* s)
 442 {
 443         stream_read_uint32(s, rdp->errorInfo); /* errorInfo (4 bytes) */
 444
 445         if (rdp->errorInfo != ERRINFO_SUCCESS)
 446                 rdp_print_errinfo(rdp->errorInfo);
 447 }
 448
 449 void rdp_recv_data_pdu(rdpRdp* rdp, STREAM* s)
 450 {
 451         uint8 type;
 452         uint16 length;
 453         uint32 share_id;
 454         uint8 compressed_type;
 455         uint16 compressed_len;
 456
 457         rdp_read_share_data_header(s, &length, &type, &share_id, &compressed_type, &compressed_len);
 458
 459 #ifdef WITH_DEBUG_RDP
 460         if (type != DATA_PDU_TYPE_UPDATE)
 461                 printf("recv %s Data PDU (0x%02X), length:%d\n", DATA_PDU_TYPE_STRINGS[type], type, length);
 462 #endif
 463
 464         switch (type)
 465         {
 466                 case DATA_PDU_TYPE_UPDATE:
 467                         update_recv(rdp->update, s);
 468                         break;
 469
 470                 case DATA_PDU_TYPE_CONTROL:
 471                         rdp_recv_server_control_pdu(rdp, s);
 472                         break;
 473
 474                 case DATA_PDU_TYPE_POINTER:
 475                         update_recv_pointer(rdp->update, s);
 476                         break;
 477
 478                 case DATA_PDU_TYPE_INPUT:
 479                         break;
 480
 481                 case DATA_PDU_TYPE_SYNCHRONIZE:
 482                         rdp_recv_synchronize_pdu(rdp, s);
 483                         break;
 484
 485                 case DATA_PDU_TYPE_REFRESH_RECT:
 486                         break;
 487
 488                 case DATA_PDU_TYPE_PLAY_SOUND:
 489                         update_recv_play_sound(rdp->update, s);
 490                         break;
 491
 492                 case DATA_PDU_TYPE_SUPPRESS_OUTPUT:
 493                         break;
 494
 495                 case DATA_PDU_TYPE_SHUTDOWN_REQUEST:
 496                         break;
 497
 498                 case DATA_PDU_TYPE_SHUTDOWN_DENIED:
 499                         break;
 500
 501                 case DATA_PDU_TYPE_SAVE_SESSION_INFO:
 502                         rdp_recv_save_session_info(rdp, s);
 503                         break;
 504
 505                 case DATA_PDU_TYPE_FONT_LIST:
 506                         break;
 507
 508                 case DATA_PDU_TYPE_FONT_MAP:
 509                         rdp_recv_font_map_pdu(rdp, s);
 510                         break;
 511
 512                 case DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS:
 513                         break;
 514
 515                 case DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST:
 516                         break;
 517
 518                 case DATA_PDU_TYPE_BITMAP_CACHE_ERROR:
 519                         break;
 520
 521                 case DATA_PDU_TYPE_SET_KEYBOARD_IME_STATUS:
 522                         break;
 523
 524                 case DATA_PDU_TYPE_OFFSCREEN_CACHE_ERROR:
 525                         break;
 526
 527                 case DATA_PDU_TYPE_SET_ERROR_INFO:
 528                         rdp_recv_set_error_info_data_pdu(rdp, s);
 529                         break;
 530
 531                 case DATA_PDU_TYPE_DRAW_NINEGRID_ERROR:
 532                         break;
 533
 534                 case DATA_PDU_TYPE_DRAW_GDIPLUS_ERROR:
 535                         break;
 536
 537                 case DATA_PDU_TYPE_ARC_STATUS:
 538                         break;
 539
 540                 case DATA_PDU_TYPE_STATUS_INFO:
 541                         break;
 542
 543                 case DATA_PDU_TYPE_MONITOR_LAYOUT:
 544                         break;
 545
 546                 default:
 547                         break;
 548         }
 549 }
 550
 551 boolean rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, STREAM* s)
 552 {
 553         uint16 type;
 554         uint16 length;
 555         uint16 channelId;
 556
 557         rdp_read_share_control_header(s, &length, &type, &channelId);
 558
 559         if (type == PDU_TYPE_DATA)
 560         {
 561                 rdp_recv_data_pdu(rdp, s);
 562                 return true;
 563         }
 564         else if (type == PDU_TYPE_SERVER_REDIRECTION)
 565         {
 566                 rdp_recv_enhanced_security_redirection_packet(rdp, s);
 567                 return true;
 568         }
 569         else
 570         {
 571                 return false;
 572         }
 573 }
 574
 575 /**
 576  * Decrypt an RDP packet.\n
 577  * @param rdp RDP module
 578  * @param s stream
 579  * @param length int
 580  */
 581
 582 boolean rdp_decrypt(rdpRdp* rdp, STREAM* s, int length)
 583 {
 584         uint8 cmac[8], wmac[8];
 585         uint32 ml;
 586         uint8* mk;
 587
 588         if (rdp->settings->encryption_method == ENCRYPTION_METHOD_FIPS)
 589         {
 590                 uint16 len;
 591                 uint8 version, pad;
 592                 uint8 *sig;
 593
 594                 stream_read_uint16(s, len); /* 0x10 */
 595                 stream_read_uint8(s, version); /* 0x1 */
 596                 stream_read_uint8(s, pad);
 597
 598                 sig = s->p;
 599                 stream_seek(s, 8);      /* signature */
 600
 601                 length -= 12;
 602
 603                 if (!security_fips_decrypt(s->p, length, rdp))
 604                 {
 605                         printf("FATAL: cannot decrypt\n");
 606                         return false; /* TODO */
 607                 }
 608
 609                 if (!security_fips_check_signature(s->p, length - pad, sig, rdp))
 610                 {
 611                         printf("FATAL: invalid packet signature\n");
 612                         return false; /* TODO */
 613                 }
 614
 615                 /* is this what needs adjusting? */
 616                 s->size -= pad;
 617                 return true;
 618         }
 619
 620         stream_read(s, wmac, sizeof(wmac));
 621         length -= sizeof(wmac);
 622         security_decrypt(s->p, length, rdp);
 623         mk = rdp->sign_key;
 624         ml = rdp->rc4_key_len;
 625         security_mac_signature(mk, ml, s->p, length, cmac);
 626         if (memcmp(wmac, cmac, sizeof(wmac)) != 0) {
 627                 printf("FATAL: invalid packet signature\n");
 628                 return false;
 629         }
 630         return true;
 631 }
 632
 633 /**
 634  * Process an RDP packet.\n
 635  * @param rdp RDP module
 636  * @param s stream
 637  */
 638
 639 static boolean rdp_recv_tpkt_pdu(rdpRdp* rdp, STREAM* s)
 640 {
 641         uint16 length;
 642         uint16 pduType;
 643         uint16 pduLength;
 644         uint16 pduSource;
 645         uint16 channelId;
 646         uint32 securityHeader;
 647
 648         if (!rdp_read_header(rdp, s, &length, &channelId))
 649         {
 650                 printf("Incorrect RDP header.\n");
 651                 return false;
 652         }
 653
 654         if (rdp->settings->encryption)
 655         {
 656                 stream_read_uint32(s, securityHeader);
 657                 if (securityHeader & SEC_SECURE_CHECKSUM)
 658                 {
 659                         printf("Error: TODO\n");
 660                         return false;
 661                 }
 662                 if (securityHeader & (SEC_ENCRYPT|SEC_REDIRECTION_PKT))
 663                 {
 664                         if (!rdp_decrypt(rdp, s, length - 4))
 665                         {
 666                                 printf("rdp_decrypt failed\n");
 667                                 return false;
 668                         }
 669                 }
 670                 if (securityHeader & SEC_REDIRECTION_PKT)
 671                 {
 672                         /*
 673                          * [MS-RDPBCGR] 2.2.13.2.1
 674                          *  - no share control header, nor the 2 byte pad
 675                          */
 676                         s->p -= 2;
 677                         rdp_recv_enhanced_security_redirection_packet(rdp, s);
 678                         return true;
 679                 }
 680         }
 681
 682         if (channelId != MCS_GLOBAL_CHANNEL_ID)
 683         {
 684                 freerdp_channel_process(rdp->instance, s, channelId);
 685         }
 686         else
 687         {
 688                 rdp_read_share_control_header(s, &pduLength, &pduType, &pduSource);
 689
 690                 rdp->settings->pdu_source = pduSource;
 691
 692                 switch (pduType)
 693                 {
 694                         case PDU_TYPE_DATA:
 695                                 rdp_recv_data_pdu(rdp, s);
 696                                 break;
 697
 698                         case PDU_TYPE_DEACTIVATE_ALL:
 699                                 if (!rdp_recv_deactivate_all(rdp, s))
 700                                         return false;
 701                                 break;
 702
 703                         case PDU_TYPE_SERVER_REDIRECTION:
 704                                 rdp_recv_enhanced_security_redirection_packet(rdp, s);
 705                                 break;
 706
 707                         default:
 708                                 printf("incorrect PDU type: 0x%04X\n", pduType);
 709                                 break;
 710                 }
 711         }
 712
 713         return true;
 714 }
 715
 716 static boolean rdp_recv_fastpath_pdu(rdpRdp* rdp, STREAM* s)
 717 {
 718         uint16 length;
 719         rdpFastPath* fastpath;
 720
 721         fastpath = rdp->fastpath;
 722         length = fastpath_read_header_rdp(fastpath, s);
 723
 724         if (length == 0 || length > stream_get_left(s))
 725         {
 726                 printf("incorrect FastPath PDU header length %d\n", length);
 727                 return false;
 728         }
 729
 730         if (fastpath->encryptionFlags & FASTPATH_OUTPUT_ENCRYPTED)
 731         {
 732                 rdp_decrypt(rdp, s, length);
 733         }
 734
 735         return fastpath_recv_updates(rdp->fastpath, s);
 736 }
 737
 738 static boolean rdp_recv_pdu(rdpRdp* rdp, STREAM* s)
 739 {
 740         if (tpkt_verify_header(s))
 741                 return rdp_recv_tpkt_pdu(rdp, s);
 742         else
 743                 return rdp_recv_fastpath_pdu(rdp, s);
 744 }
 745
 746 /**
 747  * Receive an RDP packet.\n
 748  * @param rdp RDP module
 749  */
 750
 751 void rdp_recv(rdpRdp* rdp)
 752 {
 753         STREAM* s;
 754
 755         s = transport_recv_stream_init(rdp->transport, 4096);
 756         transport_read(rdp->transport, s);
 757
 758         rdp_recv_pdu(rdp, s);
 759 }
 760
 761 static boolean rdp_recv_callback(rdpTransport* transport, STREAM* s, void* extra)
 762 {
 763         rdpRdp* rdp = (rdpRdp*) extra;
 764
 765         switch (rdp->state)
 766         {
 767                 case CONNECTION_STATE_NEGO:
 768                         if (!rdp_client_connect_mcs_connect_response(rdp, s))
 769                                 return false;
 770                         break;
 771
 772                 case CONNECTION_STATE_MCS_ATTACH_USER:
 773                         if (!rdp_client_connect_mcs_attach_user_confirm(rdp, s))
 774                                 return false;
 775                         break;
 776
 777                 case CONNECTION_STATE_MCS_CHANNEL_JOIN:
 778                         if (!rdp_client_connect_mcs_channel_join_confirm(rdp, s))
 779                                 return false;
 780                         break;
 781
 782                 case CONNECTION_STATE_LICENSE:
 783                         if (!rdp_client_connect_license(rdp, s))
 784                                 return false;
 785                         break;
 786
 787                 case CONNECTION_STATE_CAPABILITY:
 788                         if (!rdp_client_connect_demand_active(rdp, s))
 789                         {
 790                                 printf("rdp_client_connect_demand_active failed\n");
 791                                 return false;
 792                         }
 793                         break;
 794
 795                 case CONNECTION_STATE_FINALIZATION:
 796                         if (!rdp_recv_pdu(rdp, s))
 797                                 return false;
 798                         if (rdp->finalize_sc_pdus == FINALIZE_SC_COMPLETE)
 799                                 rdp->state = CONNECTION_STATE_ACTIVE;
 800                         break;
 801
 802                 case CONNECTION_STATE_ACTIVE:
 803                         if (!rdp_recv_pdu(rdp, s))
 804                                 return false;
 805                         break;
 806
 807                 default:
 808                         printf("Invalid state %d\n", rdp->state);
 809                         return false;
 810         }
 811
 812         return true;
 813 }
 814
 815 int rdp_send_channel_data(rdpRdp* rdp, int channel_id, uint8* data, int size)
 816 {
 817         return freerdp_channel_send(rdp, channel_id, data, size);
 818 }
 819
 820 /**
 821  * Set non-blocking mode information.
 822  * @param rdp RDP module
 823  * @param blocking blocking mode
 824  */
 825 void rdp_set_blocking_mode(rdpRdp* rdp, boolean blocking)
 826 {
 827         rdp->transport->recv_callback = rdp_recv_callback;
 828         rdp->transport->recv_extra = rdp;
 829         transport_set_blocking_mode(rdp->transport, blocking);
 830 }
 831
 832 int rdp_check_fds(rdpRdp* rdp)
 833 {
 834         return transport_check_fds(rdp->transport);
 835 }
 836
 837 /**
 838  * Instantiate new RDP module.
 839  * @return new RDP module
 840  */
 841
 842 rdpRdp* rdp_new(freerdp* instance)
 843 {
 844         rdpRdp* rdp;
 845
 846         rdp = (rdpRdp*) xzalloc(sizeof(rdpRdp));
 847
 848         if (rdp != NULL)
 849         {
 850                 rdp->instance = instance;
 851                 rdp->settings = settings_new((void*) instance);
 852                 if (instance != NULL)
 853                         instance->settings = rdp->settings;
 854                 rdp->extension = extension_new(instance);
 855                 rdp->transport = transport_new(rdp->settings);
 856                 rdp->license = license_new(rdp);
 857                 rdp->input = input_new(rdp);
 858                 rdp->update = update_new(rdp);
 859                 rdp->fastpath = fastpath_new(rdp);
 860                 rdp->nego = nego_new(rdp->transport);
 861                 rdp->mcs = mcs_new(rdp->transport);
 862                 rdp->redirection = redirection_new();
 863                 rdp->mppc = mppc_new(rdp);
 864         }
 865
 866         return rdp;
 867 }
 868
 869 /**
 870  * Free RDP module.
 871  * @param rdp RDP module to be freed
 872  */
 873
 874 void rdp_free(rdpRdp* rdp)
 875 {
 876         if (rdp != NULL)
 877         {
 878                 extension_free(rdp->extension);
 879                 settings_free(rdp->settings);
 880                 transport_free(rdp->transport);
 881                 license_free(rdp->license);
 882                 input_free(rdp->input);
 883                 update_free(rdp->update);
 884                 fastpath_free(rdp->fastpath);
 885                 nego_free(rdp->nego);
 886                 mcs_free(rdp->mcs);
 887                 redirection_free(rdp->redirection);
 888                 mppc_free(rdp);
 889                 xfree(rdp);
 890         }
 891 }
 892