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 uint8 DATA_PDU_TYPE_STRINGS[][32] =
  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 -= RDP_PACKET_HEADER_LENGTH;
 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 {
 118         if (stream_get_left(s) < 12)
 119                 return False;
 120
 121         /* Share Data Header */
 122         stream_read_uint32(s, *share_id); /* shareId (4 bytes) */
 123         stream_seek_uint8(s); /* pad1 (1 byte) */
 124         stream_seek_uint8(s); /* streamId (1 byte) */
 125         stream_read_uint16(s, *length); /* uncompressedLength (2 bytes) */
 126         stream_read_uint8(s, *type); /* pduType2, Data PDU Type (1 byte) */
 127         stream_seek_uint8(s); /* compressedType (1 byte) */
 128         stream_seek_uint16(s); /* compressedLength (2 bytes) */
 129
 130         return True;
 131 }
 132
 133 void rdp_write_share_data_header(STREAM* s, uint16 length, uint8 type, uint32 share_id)
 134 {
 135         length -= RDP_PACKET_HEADER_LENGTH;
 136         length -= RDP_SHARE_CONTROL_HEADER_LENGTH;
 137         length -= RDP_SHARE_DATA_HEADER_LENGTH;
 138
 139         /* Share Data Header */
 140         stream_write_uint32(s, share_id); /* shareId (4 bytes) */
 141         stream_write_uint8(s, 0); /* pad1 (1 byte) */
 142         stream_write_uint8(s, STREAM_LOW); /* streamId (1 byte) */
 143         stream_write_uint16(s, length); /* uncompressedLength (2 bytes) */
 144         stream_write_uint8(s, type); /* pduType2, Data PDU Type (1 byte) */
 145         stream_write_uint8(s, 0); /* compressedType (1 byte) */
 146         stream_write_uint16(s, 0); /* compressedLength (2 bytes) */
 147 }
 148
 149 /**
 150  * Initialize an RDP packet stream.\n
 151  * @param rdp rdp module
 152  * @return
 153  */
 154
 155 STREAM* rdp_send_stream_init(rdpRdp* rdp)
 156 {
 157         STREAM* s;
 158         s = transport_send_stream_init(rdp->transport, 2048);
 159         stream_seek(s, RDP_PACKET_HEADER_LENGTH);
 160         return s;
 161 }
 162
 163 STREAM* rdp_pdu_init(rdpRdp* rdp)
 164 {
 165         STREAM* s;
 166         s = transport_send_stream_init(rdp->transport, 2048);
 167         stream_seek(s, RDP_PACKET_HEADER_LENGTH);
 168         stream_seek(s, RDP_SHARE_CONTROL_HEADER_LENGTH);
 169         return s;
 170 }
 171
 172 STREAM* rdp_data_pdu_init(rdpRdp* rdp)
 173 {
 174         STREAM* s;
 175         s = transport_send_stream_init(rdp->transport, 2048);
 176         stream_seek(s, RDP_PACKET_HEADER_LENGTH);
 177         stream_seek(s, RDP_SHARE_CONTROL_HEADER_LENGTH);
 178         stream_seek(s, RDP_SHARE_DATA_HEADER_LENGTH);
 179         return s;
 180 }
 181
 182 /**
 183  * Read an RDP packet header.\n
 184  * @param rdp rdp module
 185  * @param s stream
 186  * @param length RDP packet length
 187  * @param channel_id channel id
 188  */
 189
 190 boolean rdp_read_header(rdpRdp* rdp, STREAM* s, uint16* length, uint16* channel_id)
 191 {
 192         uint16 initiator;
 193         enum DomainMCSPDU MCSPDU;
 194
 195         MCSPDU = (rdp->settings->server_mode) ? DomainMCSPDU_SendDataRequest : DomainMCSPDU_SendDataIndication;
 196         mcs_read_domain_mcspdu_header(s, &MCSPDU, length);
 197
 198         per_read_integer16(s, &initiator, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
 199         per_read_integer16(s, channel_id, 0); /* channelId */
 200         stream_seek(s, 1); /* dataPriority + Segmentation (0x70) */
 201         per_read_length(s, length); /* userData (OCTET_STRING) */
 202
 203         if (*length > stream_get_left(s))
 204                 return False;
 205
 206         return True;
 207 }
 208
 209 /**
 210  * Write an RDP packet header.\n
 211  * @param rdp rdp module
 212  * @param s stream
 213  * @param length RDP packet length
 214  * @param channel_id channel id
 215  */
 216
 217 void rdp_write_header(rdpRdp* rdp, STREAM* s, uint16 length, uint16 channel_id)
 218 {
 219         enum DomainMCSPDU MCSPDU;
 220
 221         MCSPDU = (rdp->settings->server_mode) ? DomainMCSPDU_SendDataIndication : DomainMCSPDU_SendDataRequest;
 222
 223         mcs_write_domain_mcspdu_header(s, MCSPDU, length, 0);
 224         per_write_integer16(s, rdp->mcs->user_id, MCS_BASE_CHANNEL_ID); /* initiator */
 225         per_write_integer16(s, channel_id, 0); /* channelId */
 226         stream_write_uint8(s, 0x70); /* dataPriority + segmentation */
 227
 228         length = (length - RDP_PACKET_HEADER_LENGTH) | 0x8000;
 229         stream_write_uint16_be(s, length); /* userData (OCTET_STRING) */
 230 }
 231
 232 /**
 233  * Send an RDP packet.\n
 234  * @param rdp RDP module
 235  * @param s stream
 236  * @param channel_id channel id
 237  */
 238
 239 boolean rdp_send(rdpRdp* rdp, STREAM* s, uint16 channel_id)
 240 {
 241         uint16 length;
 242
 243         length = stream_get_length(s);
 244         stream_set_pos(s, 0);
 245
 246         rdp_write_header(rdp, s, length, channel_id);
 247
 248         stream_set_pos(s, length);
 249         if (transport_write(rdp->transport, s) < 0)
 250                 return False;
 251
 252         return True;
 253 }
 254
 255 boolean rdp_send_pdu(rdpRdp* rdp, STREAM* s, uint16 type, uint16 channel_id)
 256 {
 257         uint16 length;
 258
 259         length = stream_get_length(s);
 260         stream_set_pos(s, 0);
 261
 262         rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID);
 263         rdp_write_share_control_header(s, length, type, channel_id);
 264
 265         stream_set_pos(s, length);
 266         if (transport_write(rdp->transport, s) < 0)
 267                 return False;
 268
 269         return True;
 270 }
 271
 272 boolean rdp_send_data_pdu(rdpRdp* rdp, STREAM* s, uint8 type, uint16 channel_id)
 273 {
 274         uint16 length;
 275
 276         length = stream_get_length(s);
 277         stream_set_pos(s, 0);
 278
 279         rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID);
 280         rdp_write_share_control_header(s, length, PDU_TYPE_DATA, channel_id);
 281         rdp_write_share_data_header(s, length, type, rdp->settings->share_id);
 282
 283         //printf("send %s Data PDU (0x%02X), length:%d\n", DATA_PDU_TYPE_STRINGS[type], type, length);
 284
 285         stream_set_pos(s, length);
 286         if (transport_write(rdp->transport, s) < 0)
 287                 return False;
 288
 289         return True;
 290 }
 291
 292 void rdp_recv_set_error_info_data_pdu(STREAM* s)
 293 {
 294         uint32 errorInfo;
 295
 296         stream_read_uint32(s, errorInfo); /* errorInfo (4 bytes) */
 297
 298         if (errorInfo != ERRINFO_SUCCESS)
 299                 rdp_print_errinfo(errorInfo);
 300 }
 301
 302 void rdp_recv_data_pdu(rdpRdp* rdp, STREAM* s)
 303 {
 304         uint8 type;
 305         uint16 length;
 306         uint32 share_id;
 307
 308         rdp_read_share_data_header(s, &length, &type, &share_id);
 309
 310 #ifdef WITH_DEBUG_RDP
 311         if (type != DATA_PDU_TYPE_UPDATE)
 312                 printf("recv %s Data PDU (0x%02X), length:%d\n", DATA_PDU_TYPE_STRINGS[type], type, length);
 313 #endif
 314
 315         switch (type)
 316         {
 317                 case DATA_PDU_TYPE_UPDATE:
 318                         update_recv(rdp->update, s);
 319                         break;
 320
 321                 case DATA_PDU_TYPE_CONTROL:
 322                         rdp_recv_server_control_pdu(rdp, s);
 323                         break;
 324
 325                 case DATA_PDU_TYPE_POINTER:
 326                         update_recv_pointer(rdp->update, s);
 327                         break;
 328
 329                 case DATA_PDU_TYPE_INPUT:
 330                         break;
 331
 332                 case DATA_PDU_TYPE_SYNCHRONIZE:
 333                         rdp_recv_server_synchronize_pdu(rdp, s);
 334                         break;
 335
 336                 case DATA_PDU_TYPE_REFRESH_RECT:
 337                         break;
 338
 339                 case DATA_PDU_TYPE_PLAY_SOUND:
 340                         update_recv_play_sound(rdp->update, s);
 341                         break;
 342
 343                 case DATA_PDU_TYPE_SUPPRESS_OUTPUT:
 344                         break;
 345
 346                 case DATA_PDU_TYPE_SHUTDOWN_REQUEST:
 347                         break;
 348
 349                 case DATA_PDU_TYPE_SHUTDOWN_DENIED:
 350                         break;
 351
 352                 case DATA_PDU_TYPE_SAVE_SESSION_INFO:
 353                         rdp_recv_save_session_info(rdp, s);
 354                         break;
 355
 356                 case DATA_PDU_TYPE_FONT_LIST:
 357                         break;
 358
 359                 case DATA_PDU_TYPE_FONT_MAP:
 360                         rdp_recv_server_font_map_pdu(rdp, s);
 361                         break;
 362
 363                 case DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS:
 364                         break;
 365
 366                 case DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST:
 367                         break;
 368
 369                 case DATA_PDU_TYPE_BITMAP_CACHE_ERROR:
 370                         break;
 371
 372                 case DATA_PDU_TYPE_SET_KEYBOARD_IME_STATUS:
 373                         break;
 374
 375                 case DATA_PDU_TYPE_OFFSCREEN_CACHE_ERROR:
 376                         break;
 377
 378                 case DATA_PDU_TYPE_SET_ERROR_INFO:
 379                         rdp_recv_set_error_info_data_pdu(s);
 380                         break;
 381
 382                 case DATA_PDU_TYPE_DRAW_NINEGRID_ERROR:
 383                         break;
 384
 385                 case DATA_PDU_TYPE_DRAW_GDIPLUS_ERROR:
 386                         break;
 387
 388                 case DATA_PDU_TYPE_ARC_STATUS:
 389                         break;
 390
 391                 case DATA_PDU_TYPE_STATUS_INFO:
 392                         break;
 393
 394                 case DATA_PDU_TYPE_MONITOR_LAYOUT:
 395                         break;
 396
 397                 default:
 398                         break;
 399         }
 400 }
 401
 402 /**
 403  * Process an RDP packet.\n
 404  * @param rdp RDP module
 405  * @param s stream
 406  */
 407
 408 static boolean rdp_recv_tpkt_pdu(rdpRdp* rdp, STREAM* s)
 409 {
 410         uint16 length;
 411         uint16 pduType;
 412         uint16 pduLength;
 413         uint16 channelId;
 414
 415         if (!rdp_read_header(rdp, s, &length, &channelId))
 416         {
 417                 printf("Incorrect RDP header.\n");
 418                 return False;
 419         }
 420
 421         if (channelId != MCS_GLOBAL_CHANNEL_ID)
 422         {
 423                 vchan_process(rdp->vchan, s, channelId);
 424         }
 425         else
 426         {
 427                 rdp_read_share_control_header(s, &pduLength, &pduType, &rdp->settings->pdu_source);
 428
 429                 switch (pduType)
 430                 {
 431                         case PDU_TYPE_DATA:
 432                                 rdp_recv_data_pdu(rdp, s);
 433                                 break;
 434
 435                         case PDU_TYPE_DEACTIVATE_ALL:
 436                                 if (!rdp_recv_deactivate_all(rdp, s))
 437                                         return False;
 438                                 break;
 439
 440                         case PDU_TYPE_SERVER_REDIRECTION:
 441                                 rdp_recv_enhanced_security_redirection_packet(rdp, s);
 442                                 break;
 443
 444                         default:
 445                                 printf("incorrect PDU type: 0x%04X\n", pduType);
 446                                 break;
 447                 }
 448         }
 449
 450         return True;
 451 }
 452
 453 static boolean rdp_recv_fastpath_pdu(rdpRdp* rdp, STREAM* s)
 454 {
 455         uint16 length;
 456
 457         length = fastpath_read_header(rdp->fastpath, s);
 458         if (length == 0 || length > stream_get_size(s))
 459         {
 460                 printf("incorrect FastPath PDU header length %d\n", length);
 461                 return False;
 462         }
 463
 464         if (!fastpath_read_security_header(rdp->fastpath, s))
 465                 return False;
 466
 467         return fastpath_recv_updates(rdp->fastpath, s);
 468 }
 469
 470 static boolean rdp_recv_pdu(rdpRdp* rdp, STREAM* s)
 471 {
 472         if (tpkt_verify_header(s))
 473                 return rdp_recv_tpkt_pdu(rdp, s);
 474         else
 475                 return rdp_recv_fastpath_pdu(rdp, s);
 476 }
 477
 478 /**
 479  * Receive an RDP packet.\n
 480  * @param rdp RDP module
 481  */
 482
 483 void rdp_recv(rdpRdp* rdp)
 484 {
 485         STREAM* s;
 486
 487         s = transport_recv_stream_init(rdp->transport, 4096);
 488         transport_read(rdp->transport, s);
 489
 490         rdp_recv_pdu(rdp, s);
 491 }
 492
 493 static int rdp_recv_callback(rdpTransport* transport, STREAM* s, void* extra)
 494 {
 495         rdpRdp* rdp = (rdpRdp*) extra;
 496
 497         switch (rdp->state)
 498         {
 499                 case CONNECTION_STATE_NEGO:
 500                         if (!rdp_client_connect_mcs_connect_response(rdp, s))
 501                                 return -1;
 502                         break;
 503
 504                 case CONNECTION_STATE_MCS_ATTACH_USER:
 505                         if (!rdp_client_connect_mcs_attach_user_confirm(rdp, s))
 506                                 return -1;
 507                         break;
 508
 509                 case CONNECTION_STATE_MCS_CHANNEL_JOIN:
 510                         if (!rdp_client_connect_mcs_channel_join_confirm(rdp, s))
 511                                 return -1;
 512                         break;
 513
 514                 case CONNECTION_STATE_LICENSE:
 515                         if (!rdp_client_connect_license(rdp, s))
 516                                 return -1;
 517                         break;
 518
 519                 case CONNECTION_STATE_CAPABILITY:
 520                         if (!rdp_client_connect_demand_active(rdp, s))
 521                                 return -1;
 522                         break;
 523
 524                 case CONNECTION_STATE_ACTIVE:
 525                         if (!rdp_recv_pdu(rdp, s))
 526                                 return -1;
 527                         break;
 528
 529                 default:
 530                         printf("Invalid state %d\n", rdp->state);
 531                         return -1;
 532         }
 533
 534         return 1;
 535 }
 536
 537 int rdp_send_channel_data(rdpRdp* rdp, int channel_id, uint8* data, int size)
 538 {
 539         return vchan_send(rdp->vchan, channel_id, data, size);
 540 }
 541
 542 /**
 543  * Set non-blocking mode information.
 544  * @param rdp RDP module
 545  * @param blocking blocking mode
 546  */
 547 void rdp_set_blocking_mode(rdpRdp* rdp, boolean blocking)
 548 {
 549         rdp->transport->recv_callback = rdp_recv_callback;
 550         rdp->transport->recv_extra = rdp;
 551         transport_set_blocking_mode(rdp->transport, blocking);
 552 }
 553
 554 int rdp_check_fds(rdpRdp* rdp)
 555 {
 556         return transport_check_fds(rdp->transport);
 557 }
 558
 559 /**
 560  * Instantiate new RDP module.
 561  * @return new RDP module
 562  */
 563
 564 rdpRdp* rdp_new(freerdp* instance)
 565 {
 566         rdpRdp* rdp;
 567
 568         rdp = (rdpRdp*) xzalloc(sizeof(rdpRdp));
 569
 570         if (rdp != NULL)
 571         {
 572                 rdp->settings = settings_new();
 573                 rdp->transport = transport_new(rdp->settings);
 574                 rdp->license = license_new(rdp);
 575                 rdp->input = input_new(rdp);
 576                 rdp->update = update_new(rdp);
 577                 rdp->fastpath = fastpath_new(rdp);
 578                 rdp->nego = nego_new(rdp->transport);
 579                 rdp->mcs = mcs_new(rdp->transport);
 580                 rdp->vchan = vchan_new(instance);
 581         }
 582
 583         return rdp;
 584 }
 585
 586 /**
 587  * Free RDP module.
 588  * @param rdp RDP module to be freed
 589  */
 590
 591 void rdp_free(rdpRdp* rdp)
 592 {
 593         if (rdp != NULL)
 594         {
 595                 settings_free(rdp->settings);
 596                 transport_free(rdp->transport);
 597                 license_free(rdp->license);
 598                 input_free(rdp->input);
 599                 update_free(rdp->update);
 600                 fastpath_free(rdp->fastpath);
 601                 nego_free(rdp->nego);
 602                 mcs_free(rdp->mcs);
 603                 vchan_free(rdp->vchan);
 604                 xfree(rdp);
 605         }
 606 }
 607