FreeRDP/libfreerdp/core/peer.c

422 lines
9.7 KiB
C
Raw Normal View History

2011-08-18 12:06:32 +04:00
/**
2012-10-09 07:02:04 +04:00
* FreeRDP: A Remote Desktop Protocol Implementation
2011-08-18 12:06:32 +04:00
* RDP Server Peer
*
* Copyright 2011 Vic Lee
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "certificate.h"
2012-03-18 21:13:34 +04:00
#include <freerdp/utils/tcp.h>
2011-08-18 12:06:32 +04:00
#include "peer.h"
static BOOL freerdp_peer_initialize(freerdp_peer* client)
2011-08-18 12:06:32 +04:00
{
client->context->rdp->settings->ServerMode = TRUE;
client->context->rdp->settings->FrameAcknowledge = 0;
client->context->rdp->settings->LocalConnection = client->local;
client->context->rdp->state = CONNECTION_STATE_INITIAL;
2012-03-18 21:13:34 +04:00
if (client->context->rdp->settings->RdpKeyFile != NULL)
2012-03-18 21:13:34 +04:00
{
client->context->rdp->settings->RdpServerRsaKey =
key_new(client->context->rdp->settings->RdpKeyFile);
}
return TRUE;
2011-08-18 12:06:32 +04:00
}
static BOOL freerdp_peer_get_fds(freerdp_peer* client, void** rfds, int* rcount)
2011-08-18 12:06:32 +04:00
{
rfds[*rcount] = (void*)(long)(client->context->rdp->transport->tcp->sockfd);
2011-08-18 12:06:32 +04:00
(*rcount)++;
return TRUE;
2011-08-18 12:06:32 +04:00
}
static BOOL freerdp_peer_check_fds(freerdp_peer* client)
2011-08-18 12:06:32 +04:00
{
int status;
2012-03-18 21:13:34 +04:00
rdpRdp* rdp;
rdp = client->context->rdp;
status = rdp_check_fds(rdp);
2012-03-18 21:13:34 +04:00
if (status < 0)
return FALSE;
return TRUE;
2011-08-18 12:06:32 +04:00
}
static BOOL peer_recv_data_pdu(freerdp_peer* client, STREAM* s)
2011-08-21 18:52:37 +04:00
{
BYTE type;
UINT16 length;
2012-10-09 11:26:39 +04:00
UINT32 share_id;
BYTE compressed_type;
UINT16 compressed_len;
2011-08-21 18:52:37 +04:00
if (!rdp_read_share_data_header(s, &length, &type, &share_id, &compressed_type, &compressed_len))
return FALSE;
2011-08-21 18:52:37 +04:00
switch (type)
{
case DATA_PDU_TYPE_SYNCHRONIZE:
if (!rdp_recv_client_synchronize_pdu(client->context->rdp, s))
return FALSE;
2011-08-21 18:52:37 +04:00
break;
case DATA_PDU_TYPE_CONTROL:
if (!rdp_server_accept_client_control_pdu(client->context->rdp, s))
return FALSE;
break;
case DATA_PDU_TYPE_INPUT:
if (!input_recv(client->context->rdp->input, s))
return FALSE;
break;
case DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST:
/* TODO: notify server bitmap cache data */
break;
case DATA_PDU_TYPE_FONT_LIST:
2012-03-18 21:13:34 +04:00
if (!rdp_server_accept_client_font_list_pdu(client->context->rdp, s))
return FALSE;
2012-03-18 21:13:34 +04:00
if (!client->connected)
2011-08-22 19:02:56 +04:00
{
/**
* PostConnect should only be called once and should not be called
* after a reactivation sequence.
*/
2012-03-18 21:13:34 +04:00
IFCALLRET(client->PostConnect, client->connected, client);
if (!client->connected)
return FALSE;
}
2012-03-18 21:13:34 +04:00
if (!client->activated)
2012-09-17 05:05:51 +04:00
{
/* Activate will be called everytime after the client is activated/reactivated. */
IFCALLRET(client->Activate, client->activated, client);
if (!client->activated)
return FALSE;
2012-09-17 05:05:51 +04:00
}
2011-08-21 18:52:37 +04:00
break;
case DATA_PDU_TYPE_SHUTDOWN_REQUEST:
mcs_send_disconnect_provider_ultimatum(client->context->rdp->mcs);
return FALSE;
case DATA_PDU_TYPE_FRAME_ACKNOWLEDGE:
2012-10-09 11:26:39 +04:00
stream_read_UINT32(s, client->ack_frame_id);
break;
case DATA_PDU_TYPE_REFRESH_RECT:
if (!update_read_refresh_rect(client->update, s))
return FALSE;
break;
case DATA_PDU_TYPE_SUPPRESS_OUTPUT:
if (!update_read_suppress_output(client->update, s))
return FALSE;
break;
2011-08-21 18:52:37 +04:00
default:
printf("Data PDU type %d\n", type);
break;
}
return TRUE;
2011-08-21 18:52:37 +04:00
}
static BOOL peer_recv_tpkt_pdu(freerdp_peer* client, STREAM* s)
2011-08-21 18:52:37 +04:00
{
2012-03-18 21:13:34 +04:00
rdpRdp* rdp;
UINT16 length;
UINT16 pduType;
UINT16 pduLength;
UINT16 pduSource;
UINT16 channelId;
UINT16 securityFlags;
2011-08-21 18:52:37 +04:00
2012-01-25 19:30:54 +04:00
rdp = client->context->rdp;
if (!rdp_read_header(rdp, s, &length, &channelId))
2011-08-21 18:52:37 +04:00
{
printf("Incorrect RDP header.\n");
return FALSE;
2011-08-21 18:52:37 +04:00
}
if (rdp->settings->DisableEncryption)
2012-01-25 19:30:54 +04:00
{
rdp_read_security_header(s, &securityFlags);
2012-03-18 21:13:34 +04:00
2012-01-25 19:30:54 +04:00
if (securityFlags & SEC_ENCRYPT)
{
if (!rdp_decrypt(rdp, s, length - 4, securityFlags))
{
printf("rdp_decrypt failed\n");
return FALSE;
2012-01-25 19:30:54 +04:00
}
}
}
2011-08-21 18:52:37 +04:00
if (channelId != MCS_GLOBAL_CHANNEL_ID)
{
freerdp_channel_peer_process(client, s, channelId);
2011-08-21 18:52:37 +04:00
}
else
{
if (!rdp_read_share_control_header(s, &pduLength, &pduType, &pduSource))
return FALSE;
2011-08-21 18:52:37 +04:00
client->settings->PduSource = pduSource;
2011-08-21 18:52:37 +04:00
switch (pduType)
{
case PDU_TYPE_DATA:
if (!peer_recv_data_pdu(client, s))
return FALSE;
2011-08-21 18:52:37 +04:00
break;
default:
printf("Client sent pduType %d\n", pduType);
return FALSE;
2011-08-21 18:52:37 +04:00
}
}
return TRUE;
2011-08-21 18:52:37 +04:00
}
static BOOL peer_recv_fastpath_pdu(freerdp_peer* client, STREAM* s)
2011-08-21 18:52:37 +04:00
{
2011-09-27 09:30:58 +04:00
rdpRdp* rdp;
UINT16 length;
2011-09-27 09:30:58 +04:00
rdpFastPath* fastpath;
rdp = client->context->rdp;
2011-09-27 09:30:58 +04:00
fastpath = rdp->fastpath;
length = fastpath_read_header_rdp(fastpath, s);
2011-08-23 11:51:51 +04:00
2011-09-15 01:14:50 +04:00
if (length == 0 || length > stream_get_left(s))
2011-08-23 11:51:51 +04:00
{
printf("incorrect FastPath PDU header length %d\n", length);
return FALSE;
2011-08-23 11:51:51 +04:00
}
2011-09-27 09:30:58 +04:00
if (fastpath->encryptionFlags & FASTPATH_OUTPUT_ENCRYPTED)
2011-09-15 01:14:50 +04:00
{
rdp_decrypt(rdp, s, length, (fastpath->encryptionFlags & FASTPATH_OUTPUT_SECURE_CHECKSUM) ? SEC_SECURE_CHECKSUM : 0);
2011-09-15 01:14:50 +04:00
}
2011-09-27 09:30:58 +04:00
return fastpath_recv_inputs(fastpath, s);
2011-08-21 18:52:37 +04:00
}
static BOOL peer_recv_pdu(freerdp_peer* client, STREAM* s)
2011-08-21 18:52:37 +04:00
{
if (tpkt_verify_header(s))
return peer_recv_tpkt_pdu(client, s);
2011-08-21 18:52:37 +04:00
else
return peer_recv_fastpath_pdu(client, s);
2011-08-21 18:52:37 +04:00
}
static BOOL peer_recv_callback(rdpTransport* transport, STREAM* s, void* extra)
{
freerdp_peer* client = (freerdp_peer*) extra;
rdpRdp* rdp = client->context->rdp;
switch (rdp->state)
{
case CONNECTION_STATE_INITIAL:
if (!rdp_server_accept_nego(rdp, s))
return FALSE;
if (rdp->nego->selected_protocol & PROTOCOL_NLA)
{
sspi_CopyAuthIdentity(&client->identity, &(rdp->nego->transport->credssp->identity));
IFCALLRET(client->Logon, client->authenticated, client, &client->identity, TRUE);
credssp_free(rdp->nego->transport->credssp);
}
else
{
IFCALLRET(client->Logon, client->authenticated, client, &client->identity, FALSE);
}
break;
case CONNECTION_STATE_NEGO:
if (!rdp_server_accept_mcs_connect_initial(rdp, s))
return FALSE;
break;
case CONNECTION_STATE_MCS_CONNECT:
if (!rdp_server_accept_mcs_erect_domain_request(rdp, s))
return FALSE;
break;
case CONNECTION_STATE_MCS_ERECT_DOMAIN:
if (!rdp_server_accept_mcs_attach_user_request(rdp, s))
return FALSE;
break;
case CONNECTION_STATE_MCS_ATTACH_USER:
if (!rdp_server_accept_mcs_channel_join_request(rdp, s))
return FALSE;
2011-08-20 14:22:14 +04:00
break;
case CONNECTION_STATE_MCS_CHANNEL_JOIN:
if (rdp->settings->DisableEncryption)
{
if (!rdp_server_accept_client_keys(rdp, s))
return FALSE;
break;
}
rdp->state = CONNECTION_STATE_ESTABLISH_KEYS;
/* FALLTHROUGH */
case CONNECTION_STATE_ESTABLISH_KEYS:
if (!rdp_server_accept_client_info(rdp, s))
return FALSE;
2012-03-18 21:13:34 +04:00
IFCALL(client->Capabilities, client);
2012-03-18 21:13:34 +04:00
if (!rdp_send_demand_active(rdp))
return FALSE;
2011-08-21 11:52:44 +04:00
break;
case CONNECTION_STATE_LICENSE:
if (!rdp_server_accept_confirm_active(rdp, s))
{
/**
* During reactivation sequence the client might sent some input or channel data
* before receiving the Deactivate All PDU. We need to process them as usual.
*/
stream_set_pos(s, 0);
return peer_recv_pdu(client, s);
}
2011-08-21 18:52:37 +04:00
break;
case CONNECTION_STATE_ACTIVE:
if (!peer_recv_pdu(client, s))
return FALSE;
break;
default:
printf("Invalid state %d\n", rdp->state);
return FALSE;
}
return TRUE;
}
static BOOL freerdp_peer_close(freerdp_peer* client)
{
/**
* [MS-RDPBCGR] 1.3.1.4.2 User-Initiated Disconnection Sequence on Server
* The server first sends the client a Deactivate All PDU followed by an
* optional MCS Disconnect Provider Ultimatum PDU.
*/
if (!rdp_send_deactivate_all(client->context->rdp))
return FALSE;
return mcs_send_disconnect_provider_ultimatum(client->context->rdp->mcs);
}
2011-08-18 12:06:32 +04:00
static void freerdp_peer_disconnect(freerdp_peer* client)
{
transport_disconnect(client->context->rdp->transport);
}
static int freerdp_peer_send_channel_data(freerdp_peer* client, int channelId, BYTE* data, int size)
{
return rdp_send_channel_data(client->context->rdp, channelId, data, size);
}
void freerdp_peer_context_new(freerdp_peer* client)
{
rdpRdp* rdp;
rdp = rdp_new(NULL);
client->input = rdp->input;
client->update = rdp->update;
client->settings = rdp->settings;
2011-10-30 09:43:04 +04:00
client->context = (rdpContext*) xzalloc(client->context_size);
client->context->rdp = rdp;
client->context->peer = client;
client->update->context = client->context;
client->input->context = client->context;
update_register_server_callbacks(client->update);
transport_attach(rdp->transport, client->sockfd);
2011-08-23 12:14:32 +04:00
rdp->transport->recv_callback = peer_recv_callback;
rdp->transport->recv_extra = client;
transport_set_blocking_mode(rdp->transport, FALSE);
IFCALL(client->ContextNew, client, client->context);
}
void freerdp_peer_context_free(freerdp_peer* client)
{
IFCALL(client->ContextFree, client, client->context);
2011-08-18 12:06:32 +04:00
}
freerdp_peer* freerdp_peer_new(int sockfd)
{
freerdp_peer* client;
client = xnew(freerdp_peer);
freerdp_tcp_set_no_delay(sockfd, TRUE);
2012-03-18 21:13:34 +04:00
2011-10-30 09:43:04 +04:00
if (client != NULL)
{
client->sockfd = sockfd;
client->context_size = sizeof(rdpContext);
client->Initialize = freerdp_peer_initialize;
client->GetFileDescriptor = freerdp_peer_get_fds;
client->CheckFileDescriptor = freerdp_peer_check_fds;
client->Close = freerdp_peer_close;
2011-10-30 09:43:04 +04:00
client->Disconnect = freerdp_peer_disconnect;
client->SendChannelData = freerdp_peer_send_channel_data;
2011-10-30 09:43:04 +04:00
}
2011-08-18 12:06:32 +04:00
return client;
}
void freerdp_peer_free(freerdp_peer* client)
{
if (client)
{
rdp_free(client->context->rdp);
free(client->context);
free(client);
}
2011-08-18 12:06:32 +04:00
}