libfreerdp-core/peer.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol client.
   3  * RDP Server Peer
   4  *
   5  * Copyright 2011 Vic Lee
   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 "peer.h"
  21
  22 static boolean freerdp_peer_initialize(freerdp_peer* client)
  23 {
  24         client->context->rdp->settings->server_mode = true;
  25         client->context->rdp->state = CONNECTION_STATE_INITIAL;
  26         if (client->context->rdp->settings->rdp_key_file != NULL) {
  27                 client->context->rdp->settings->server_key =
  28                     key_new(client->context->rdp->settings->rdp_key_file);
  29         }
  30
  31         return true;
  32 }
  33
  34 static boolean freerdp_peer_get_fds(freerdp_peer* client, void** rfds, int* rcount)
  35 {
  36         rfds[*rcount] = (void*)(long)(client->context->rdp->transport->tcp->sockfd);
  37         (*rcount)++;
  38
  39         return true;
  40 }
  41
  42 static boolean freerdp_peer_check_fds(freerdp_peer* client)
  43 {
  44         rdpRdp* rdp;
  45         int status;
  46
  47         rdp = client->context->rdp;
  48
  49         status = rdp_check_fds(rdp);
  50         if (status < 0)
  51                 return false;
  52
  53         return true;
  54 }
  55
  56 static boolean peer_recv_data_pdu(freerdp_peer* client, STREAM* s)
  57 {
  58         uint8 type;
  59         uint16 length;
  60         uint32 share_id;
  61         uint8 compressed_type;
  62         uint16 compressed_len;
  63
  64
  65         if (!rdp_read_share_data_header(s, &length, &type, &share_id, &compressed_type, &compressed_len))
  66                 return false;
  67
  68         switch (type)
  69         {
  70                 case DATA_PDU_TYPE_SYNCHRONIZE:
  71                         if (!rdp_recv_client_synchronize_pdu(client->context->rdp, s))
  72                                 return false;
  73                         break;
  74
  75                 case DATA_PDU_TYPE_CONTROL:
  76                         if (!rdp_server_accept_client_control_pdu(client->context->rdp, s))
  77                                 return false;
  78                         break;
  79
  80                 case DATA_PDU_TYPE_INPUT:
  81                         if (!input_recv(client->context->rdp->input, s))
  82                                 return false;
  83                         break;
  84
  85                 case DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST:
  86                         /* TODO: notify server bitmap cache data */
  87                         break;
  88
  89                 case DATA_PDU_TYPE_FONT_LIST:
  90                         if (!rdp_server_accept_client_font_list_pdu(client->context->rdp, s))
  91                                 return false;
  92                         if (client->PostConnect)
  93                         {
  94                                 if (!client->PostConnect(client))
  95                                         return false;
  96                                 /**
  97                                  * PostConnect should only be called once and should not be called
  98                                  * after a reactivation sequence.
  99                                  */
 100                                 client->PostConnect = NULL;
 101                         }
 102                         if (client->Activate)
 103                         {
 104                                 /* Activate will be called everytime after the client is activated/reactivated. */
 105                                 if (!client->Activate(client))
 106                                         return false;
 107                         }
 108                         break;
 109
 110                 case DATA_PDU_TYPE_SHUTDOWN_REQUEST:
 111                         mcs_send_disconnect_provider_ultimatum(client->context->rdp->mcs);
 112                         return false;
 113
 114                 default:
 115                         printf("Data PDU type %d\n", type);
 116                         break;
 117         }
 118
 119         return true;
 120 }
 121
 122 static boolean peer_recv_tpkt_pdu(freerdp_peer* client, STREAM* s)
 123 {
 124         rdpRdp *rdp;
 125         uint16 length;
 126         uint16 pduType;
 127         uint16 pduLength;
 128         uint16 pduSource;
 129         uint16 channelId;
 130         uint16 securityFlags;
 131
 132         rdp = client->context->rdp;
 133
 134         if (!rdp_read_header(rdp, s, &length, &channelId))
 135         {
 136                 printf("Incorrect RDP header.\n");
 137                 return false;
 138         }
 139
 140         if (rdp->settings->encryption)
 141         {
 142                 rdp_read_security_header(s, &securityFlags);
 143                 if (securityFlags & SEC_ENCRYPT)
 144                 {
 145                         if (!rdp_decrypt(rdp, s, length - 4, securityFlags))
 146                         {
 147                                 printf("rdp_decrypt failed\n");
 148                                 return false;
 149                         }
 150                 }
 151         }
 152
 153         if (channelId != MCS_GLOBAL_CHANNEL_ID)
 154         {
 155                 freerdp_channel_peer_process(client, s, channelId);
 156         }
 157         else
 158         {
 159                 if (!rdp_read_share_control_header(s, &pduLength, &pduType, &pduSource))
 160                         return false;
 161
 162                 client->settings->pdu_source = pduSource;
 163
 164                 switch (pduType)
 165                 {
 166                         case PDU_TYPE_DATA:
 167                                 if (!peer_recv_data_pdu(client, s))
 168                                         return false;
 169                                 break;
 170
 171                         default:
 172                                 printf("Client sent pduType %d\n", pduType);
 173                                 return false;
 174                 }
 175         }
 176
 177         return true;
 178 }
 179
 180 static boolean peer_recv_fastpath_pdu(freerdp_peer* client, STREAM* s)
 181 {
 182         uint16 length;
 183         rdpRdp* rdp;
 184         rdpFastPath* fastpath;
 185
 186         rdp = client->context->rdp;
 187         fastpath = rdp->fastpath;
 188         length = fastpath_read_header_rdp(fastpath, s);
 189
 190         if (length == 0 || length > stream_get_left(s))
 191         {
 192                 printf("incorrect FastPath PDU header length %d\n", length);
 193                 return false;
 194         }
 195
 196         if (fastpath->encryptionFlags & FASTPATH_OUTPUT_ENCRYPTED)
 197         {
 198                 rdp_decrypt(rdp, s, length, (fastpath->encryptionFlags & FASTPATH_OUTPUT_SECURE_CHECKSUM) ? SEC_SECURE_CHECKSUM : 0);
 199         }
 200
 201         return fastpath_recv_inputs(fastpath, s);
 202 }
 203
 204 static boolean peer_recv_pdu(freerdp_peer* client, STREAM* s)
 205 {
 206         if (tpkt_verify_header(s))
 207                 return peer_recv_tpkt_pdu(client, s);
 208         else
 209                 return peer_recv_fastpath_pdu(client, s);
 210 }
 211
 212 static boolean peer_recv_callback(rdpTransport* transport, STREAM* s, void* extra)
 213 {
 214         freerdp_peer* client = (freerdp_peer*) extra;
 215
 216         switch (client->context->rdp->state)
 217         {
 218                 case CONNECTION_STATE_INITIAL:
 219                         if (!rdp_server_accept_nego(client->context->rdp, s))
 220                                 return false;
 221                         break;
 222
 223                 case CONNECTION_STATE_NEGO:
 224                         if (!rdp_server_accept_mcs_connect_initial(client->context->rdp, s))
 225                                 return false;
 226                         break;
 227
 228                 case CONNECTION_STATE_MCS_CONNECT:
 229                         if (!rdp_server_accept_mcs_erect_domain_request(client->context->rdp, s))
 230                                 return false;
 231                         break;
 232
 233                 case CONNECTION_STATE_MCS_ERECT_DOMAIN:
 234                         if (!rdp_server_accept_mcs_attach_user_request(client->context->rdp, s))
 235                                 return false;
 236                         break;
 237
 238                 case CONNECTION_STATE_MCS_ATTACH_USER:
 239                         if (!rdp_server_accept_mcs_channel_join_request(client->context->rdp, s))
 240                                 return false;
 241                         break;
 242
 243                 case CONNECTION_STATE_MCS_CHANNEL_JOIN:
 244                         if (client->context->rdp->settings->encryption) {
 245                                 if (!rdp_server_accept_client_keys(client->context->rdp, s))
 246                                         return false;
 247                                 break;
 248                         }
 249                         client->context->rdp->state = CONNECTION_STATE_ESTABLISH_KEYS;
 250                         /* FALLTHROUGH */
 251
 252                 case CONNECTION_STATE_ESTABLISH_KEYS:
 253                         if (!rdp_server_accept_client_info(client->context->rdp, s))
 254                                 return false;
 255                         IFCALL(client->Capabilities, client);
 256                         if (!rdp_send_demand_active(client->context->rdp))
 257                                 return false;
 258                         break;
 259
 260                 case CONNECTION_STATE_LICENSE:
 261                         if (!rdp_server_accept_confirm_active(client->context->rdp, s))
 262                         {
 263                                 /**
 264                                  * During reactivation sequence the client might sent some input or channel data
 265                                  * before receiving the Deactivate All PDU. We need to process them as usual.
 266                                  */
 267                                 stream_set_pos(s, 0);
 268                                 return peer_recv_pdu(client, s);
 269                         }
 270                         break;
 271
 272                 case CONNECTION_STATE_ACTIVE:
 273                         if (!peer_recv_pdu(client, s))
 274                                 return false;
 275                         break;
 276
 277                 default:
 278                         printf("Invalid state %d\n", client->context->rdp->state);
 279                         return false;
 280         }
 281
 282         return true;
 283 }
 284
 285 static void freerdp_peer_disconnect(freerdp_peer* client)
 286 {
 287         transport_disconnect(client->context->rdp->transport);
 288 }
 289
 290 static int freerdp_peer_send_channel_data(freerdp_peer* client, int channelId, uint8* data, int size)
 291 {
 292         return rdp_send_channel_data(client->context->rdp, channelId, data, size);
 293 }
 294
 295 void freerdp_peer_context_new(freerdp_peer* client)
 296 {
 297         rdpRdp* rdp;
 298
 299         rdp = rdp_new(NULL);
 300         client->input = rdp->input;
 301         client->update = rdp->update;
 302         client->settings = rdp->settings;
 303
 304         client->context = (rdpContext*) xzalloc(client->context_size);
 305         client->context->rdp = rdp;
 306         client->context->peer = client;
 307
 308         client->update->context = client->context;
 309         client->input->context = client->context;
 310
 311         update_register_server_callbacks(client->update);
 312
 313         transport_attach(rdp->transport, client->sockfd);
 314
 315         rdp->transport->recv_callback = peer_recv_callback;
 316         rdp->transport->recv_extra = client;
 317         transport_set_blocking_mode(rdp->transport, false);
 318
 319         IFCALL(client->ContextNew, client, client->context);
 320 }
 321
 322 void freerdp_peer_context_free(freerdp_peer* client)
 323 {
 324         IFCALL(client->ContextFree, client, client->context);
 325 }
 326
 327 freerdp_peer* freerdp_peer_new(int sockfd)
 328 {
 329         freerdp_peer* client;
 330
 331         client = xnew(freerdp_peer);
 332
 333         if (client != NULL)
 334         {
 335                 client->sockfd = sockfd;
 336                 client->context_size = sizeof(rdpContext);
 337                 client->Initialize = freerdp_peer_initialize;
 338                 client->GetFileDescriptor = freerdp_peer_get_fds;
 339                 client->CheckFileDescriptor = freerdp_peer_check_fds;
 340                 client->Disconnect = freerdp_peer_disconnect;
 341                 client->SendChannelData = freerdp_peer_send_channel_data;
 342         }
 343
 344         return client;
 345 }
 346
 347 void freerdp_peer_free(freerdp_peer* client)
 348 {
 349         if (client)
 350         {
 351                 rdp_free(client->context->rdp);
 352                 xfree(client);
 353         }
 354 }
 355