mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libfreerdp-core: encapsulate received RPC PDU

Browse Source
This commit is contained in:
Marc-André Moreau 2012-11-28 21:25:01 -05:00
parent 5faebcd77a
commit 3634a1bbf1
8 changed files with 86 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
libfreerdp/core/gateway/rpc.c
View File

@ -364,7 +364,7 @@ int rpc_recv_pdu_fragment(rdpRpc* rpc)
return header->common.frag_length;
printf("Receiving Out-of-Sequence RTS PDU\n");
rts_recv_out_of_sequence_pdu(rpc);
rts_recv_out_of_sequence_pdu(rpc, rpc->FragBuffer, header->common.frag_length);
return rpc_recv_pdu_fragment(rpc);
}
@ -400,7 +400,7 @@ int rpc_recv_pdu_fragment(rdpRpc* rpc)
return header->common.frag_length;
}
int rpc_recv_pdu(rdpRpc* rpc)
RPC_PDU* rpc_recv_pdu(rdpRpc* rpc)
{
int status;
UINT32 StubOffset;
@ -416,7 +416,7 @@ int rpc_recv_pdu(rdpRpc* rpc)
rpc->pdu->Size = rpc->FragBufferSize;
rpc->pdu->Length = status;
return status;
return rpc->pdu;
}
header = (rpcconn_hdr_t*) rpc->FragBuffer;
@ -424,13 +424,13 @@ int rpc_recv_pdu(rdpRpc* rpc)
if (header->common.ptype != PTYPE_RESPONSE)
{
printf("rpc_recv_pdu: unexpected ptype 0x%02X\n", header->common.ptype);
return -1;
return NULL;
}
if (!rpc_get_stub_data_info(rpc, rpc->FragBuffer, &StubOffset, &StubLength))
{
printf("rpc_recv_pdu: expected stub\n");
return -1;
return NULL;
}
if (header->response.alloc_hint > rpc->StubBufferSize)
@ -466,7 +466,7 @@ int rpc_recv_pdu(rdpRpc* rpc)
rpc->pdu->Size = rpc->StubBufferSize;
rpc->pdu->Length = rpc->StubLength;
return rpc->StubLength;
return rpc->pdu;
}
return rpc_recv_pdu(rpc);

25
libfreerdp/core/gateway/rpc.h
View File

@ -23,6 +23,7 @@
#define FREERDP_CORE_RPC_H
#include <winpr/wtypes.h>
#include <winpr/interlocked.h>
typedef struct rdp_rpc rdpRpc;
@ -48,6 +49,17 @@ typedef struct
#define RTS_PDU_HEADER_LENGTH 20
#define RPC_PDU_FLAG_STUB 0x00000001
typedef struct _RPC_PDU
{
SLIST_ENTRY ItemEntry;
BYTE* Buffer;
UINT32 Size;
UINT32 Length;
DWORD Flags;
} RPC_PDU, *PRPC_PDU;
#include "tcp.h"
#include "rts.h"
#include "http.h"
@ -697,17 +709,6 @@ struct rpc_virtual_connection_cookie_table
};
typedef struct rpc_virtual_connection_cookie_table RpcVirtualConnectionCookieTable;
#define RPC_PDU_FLAG_STUB 0x00000001
typedef struct _RPC_PDU
{
SLIST_ENTRY ItemEntry;
BYTE* Buffer;
UINT32 Size;
UINT32 Length;
DWORD Flags;
} RPC_PDU, *PRPC_PDU;
struct rpc_client
{
HANDLE Thread;
@ -792,7 +793,7 @@ BOOL rpc_get_stub_data_info(rdpRpc* rpc, BYTE* header, UINT32* offset, UINT32* l
int rpc_recv_pdu_header(rdpRpc* rpc, BYTE* header);
int rpc_recv_pdu_fragment(rdpRpc* rpc);
int rpc_recv_pdu(rdpRpc* rpc);
RPC_PDU* rpc_recv_pdu(rdpRpc* rpc);
int rpc_write(rdpRpc* rpc, BYTE* data, int length, UINT16 opnum);

28
libfreerdp/core/gateway/rpc_bind.c
View File

@ -213,29 +213,29 @@ int rpc_send_bind_pdu(rdpRpc* rpc)
int rpc_recv_bind_ack_pdu(rdpRpc* rpc)
{
int status;
RPC_PDU* pdu;
BYTE* auth_data;
rpcconn_hdr_t* header;
status = rpc_recv_pdu(rpc);
pdu = rpc_recv_pdu(rpc);
if (status > 0)
{
header = (rpcconn_hdr_t*) rpc->FragBuffer;
if (!pdu)
return -1;
rpc->max_recv_frag = header->bind_ack.max_xmit_frag;
rpc->max_xmit_frag = header->bind_ack.max_recv_frag;
header = (rpcconn_hdr_t*) pdu->Buffer;
rpc->ntlm->inputBuffer.cbBuffer = header->common.auth_length;
rpc->ntlm->inputBuffer.pvBuffer = malloc(header->common.auth_length);
rpc->max_recv_frag = header->bind_ack.max_xmit_frag;
rpc->max_xmit_frag = header->bind_ack.max_recv_frag;
auth_data = rpc->FragBuffer + (header->common.frag_length - header->common.auth_length);
CopyMemory(rpc->ntlm->inputBuffer.pvBuffer, auth_data, header->common.auth_length);
rpc->ntlm->inputBuffer.cbBuffer = header->common.auth_length;
rpc->ntlm->inputBuffer.pvBuffer = malloc(header->common.auth_length);
ntlm_authenticate(rpc->ntlm);
}
auth_data = pdu->Buffer + (header->common.frag_length - header->common.auth_length);
CopyMemory(rpc->ntlm->inputBuffer.pvBuffer, auth_data, header->common.auth_length);
return status;
ntlm_authenticate(rpc->ntlm);
return pdu->Length;
}
/**

6
libfreerdp/core/gateway/rpc_client.c
View File

@ -87,18 +87,16 @@ int rpc_send_dequeue_pdu(rdpRpc* rpc)
int rpc_recv_enqueue_pdu(rdpRpc* rpc)
{
int status;
RPC_PDU* pdu;
status = rpc_recv_pdu(rpc);
pdu = rpc_recv_pdu(rpc);
if (status <= 0)
if (!pdu)
{
printf("rpc_recv_enqueue_pdu error\n");
return -1;
}
pdu = rpc->pdu;
rpc->pdu = (RPC_PDU*) _aligned_malloc(sizeof(RPC_PDU), MEMORY_ALLOCATION_ALIGNMENT);
if (pdu->Flags & RPC_PDU_FLAG_STUB)

25
libfreerdp/core/gateway/rts.c
View File

@ -57,6 +57,7 @@
BOOL rts_connect(rdpRpc* rpc)
{
int status;
RPC_PDU* pdu;
rpcconn_rts_hdr_t* rts;
HttpResponse* http_response;
@ -173,12 +174,12 @@ BOOL rts_connect(rdpRpc* rpc)
*
*/
status = rpc_recv_pdu(rpc);
pdu = rpc_recv_pdu(rpc);
if (status < 1)
if (!pdu)
return FALSE;
rts = (rpcconn_rts_hdr_t*) rpc->FragBuffer;
rts = (rpcconn_rts_hdr_t*) pdu->Buffer;
if (!rts_match_pdu_signature(rpc, &RTS_PDU_CONN_A3_SIGNATURE, rts))
{
@ -186,7 +187,7 @@ BOOL rts_connect(rdpRpc* rpc)
return FALSE;
}
rts_recv_CONN_A3_pdu(rpc, rpc->FragBuffer, rpc->FragBufferSize);
rts_recv_CONN_A3_pdu(rpc, pdu->Buffer, pdu->Size);
rpc->VirtualConnection->State = VIRTUAL_CONNECTION_STATE_WAIT_C2;
DEBUG_RTS("VIRTUAL_CONNECTION_STATE_WAIT_C2");
@ -212,12 +213,12 @@ BOOL rts_connect(rdpRpc* rpc)
*
*/
status = rpc_recv_pdu(rpc);
pdu = rpc_recv_pdu(rpc);
if (status < 1)
if (!pdu)
return FALSE;
rts = (rpcconn_rts_hdr_t*) rpc->FragBuffer;
rts = (rpcconn_rts_hdr_t*) pdu->Buffer;
if (!rts_match_pdu_signature(rpc, &RTS_PDU_CONN_C2_SIGNATURE, rts))
{
@ -225,7 +226,7 @@ BOOL rts_connect(rdpRpc* rpc)
return FALSE;
}
rts_recv_CONN_C2_pdu(rpc, rpc->FragBuffer, rpc->FragBufferSize);
rts_recv_CONN_C2_pdu(rpc, pdu->Buffer, pdu->Size);
rpc->VirtualConnection->State = VIRTUAL_CONNECTION_STATE_OPENED;
DEBUG_RTS("VIRTUAL_CONNECTION_STATE_OPENED");
@ -952,13 +953,13 @@ int rts_command_length(rdpRpc* rpc, UINT32 CommandType, BYTE* buffer, UINT32 len
return CommandLength;
}
int rts_recv_out_of_sequence_pdu(rdpRpc* rpc)
int rts_recv_out_of_sequence_pdu(rdpRpc* rpc, BYTE* buffer, UINT32 length)
{
UINT32 SignatureId;
rpcconn_rts_hdr_t* rts;
RtsPduSignature signature;
rts = (rpcconn_rts_hdr_t*) rpc->FragBuffer;
rts = (rpcconn_rts_hdr_t*) buffer;
rts_extract_pdu_signature(rpc, &signature, rts);
rts_print_pdu_signature(rpc, &signature);
@ -966,11 +967,11 @@ int rts_recv_out_of_sequence_pdu(rdpRpc* rpc)
if (SignatureId == RTS_PDU_FLOW_CONTROL_ACK)
{
return rts_recv_flow_control_ack_pdu(rpc, rpc->FragBuffer, rpc->FragBufferSize);
return rts_recv_flow_control_ack_pdu(rpc, buffer, length);
}
else if (SignatureId == RTS_PDU_FLOW_CONTROL_ACK_WITH_DESTINATION)
{
return rts_recv_flow_control_ack_with_destination_pdu(rpc, rpc->FragBuffer, rpc->FragBufferSize);
return rts_recv_flow_control_ack_with_destination_pdu(rpc, buffer, length);
}
return 0;

2
libfreerdp/core/gateway/rts.h
View File

@ -139,7 +139,7 @@ int rts_send_keep_alive_pdu(rdpRpc* rpc);
int rts_send_flow_control_ack_pdu(rdpRpc* rpc);
int rts_send_ping_pdu(rdpRpc* rpc);
int rts_recv_out_of_sequence_pdu(rdpRpc* rpc);
int rts_recv_out_of_sequence_pdu(rdpRpc* rpc, BYTE* buffer, UINT32 length);
#include "rts_signature.h"

89
libfreerdp/core/gateway/tsg.c
View File

@ -198,12 +198,12 @@ BOOL TsProxyCreateTunnelWriteRequest(rdpTsg* tsg)
BOOL TsProxyCreateTunnelReadResponse(rdpTsg* tsg)
{
int status;
BYTE* buffer;
UINT32 count;
UINT32 length;
UINT32 offset;
UINT32 Pointer;
RPC_PDU* pdu;
PTSG_PACKET packet;
UINT32 SwitchValue;
rdpRpc* rpc = tsg->rpc;
@ -212,13 +212,13 @@ BOOL TsProxyCreateTunnelReadResponse(rdpTsg* tsg)
PTSG_PACKET_CAPS_RESPONSE packetCapsResponse;
PTSG_PACKET_QUARENC_RESPONSE packetQuarEncResponse;
status = rpc_recv_pdu(rpc);
pdu = rpc_recv_pdu(rpc);
if (status <= 0)
if (!pdu)
return FALSE;
length = rpc->StubLength;
buffer = rpc->StubBuffer;
length = pdu->Length;
buffer = pdu->Buffer;
packet = (PTSG_PACKET) malloc(sizeof(TSG_PACKET));
ZeroMemory(packet, sizeof(TSG_PACKET));
@ -549,7 +549,7 @@ BOOL TsProxyAuthorizeTunnelWriteRequest(rdpTsg* tsg)
BOOL TsProxyAuthorizeTunnelReadResponse(rdpTsg* tsg)
{
int status;
RPC_PDU* pdu;
BYTE* buffer;
UINT32 length;
UINT32 offset;
@ -560,19 +560,20 @@ BOOL TsProxyAuthorizeTunnelReadResponse(rdpTsg* tsg)
rdpRpc* rpc = tsg->rpc;
PTSG_PACKET_RESPONSE packetResponse;
status = rpc_recv_pdu_fragment(rpc);
pdu = rpc_recv_pdu(rpc);
if (status <= 0)
if (!pdu)
return FALSE;
length = status;
buffer = rpc->FragBuffer;
length = pdu->Length;
buffer = pdu->Buffer;
packet = (PTSG_PACKET) malloc(sizeof(TSG_PACKET));
ZeroMemory(packet, sizeof(TSG_PACKET));
packet->packetId = *((UINT32*) &buffer[28]); /* PacketId */
SwitchValue = *((UINT32*) &buffer[32]); /* SwitchValue */
offset = 4;
packet->packetId = *((UINT32*) &buffer[offset]); /* PacketId */
SwitchValue = *((UINT32*) &buffer[offset + 4]); /* SwitchValue */
if ((packet->packetId != TSG_PACKET_TYPE_RESPONSE) ||
(SwitchValue != TSG_PACKET_TYPE_RESPONSE))
@ -585,8 +586,8 @@ BOOL TsProxyAuthorizeTunnelReadResponse(rdpTsg* tsg)
ZeroMemory(packetResponse, sizeof(TSG_PACKET_RESPONSE));
packet->tsgPacket.packetResponse = packetResponse;
Pointer = *((UINT32*) &buffer[36]); /* PacketResponsePtr */
packetResponse->flags = *((UINT32*) &buffer[40]); /* Flags */
Pointer = *((UINT32*) &buffer[offset + 8]); /* PacketResponsePtr */
packetResponse->flags = *((UINT32*) &buffer[offset + 12]); /* Flags */
if (packetResponse->flags != TSG_PACKET_TYPE_QUARREQUEST)
{
@ -596,18 +597,18 @@ BOOL TsProxyAuthorizeTunnelReadResponse(rdpTsg* tsg)
}
/* Reserved (4 bytes) */
Pointer = *((UINT32*) &buffer[48]); /* ResponseDataPtr */
packetResponse->responseDataLen = *((UINT32*) &buffer[52]); /* ResponseDataLength */
Pointer = *((UINT32*) &buffer[offset + 20]); /* ResponseDataPtr */
packetResponse->responseDataLen = *((UINT32*) &buffer[offset + 24]); /* ResponseDataLength */
packetResponse->redirectionFlags.enableAllRedirections = *((UINT32*) &buffer[56]); /* EnableAllRedirections */
packetResponse->redirectionFlags.disableAllRedirections = *((UINT32*) &buffer[60]); /* DisableAllRedirections */
packetResponse->redirectionFlags.driveRedirectionDisabled = *((UINT32*) &buffer[64]); /* DriveRedirectionDisabled */
packetResponse->redirectionFlags.printerRedirectionDisabled = *((UINT32*) &buffer[68]); /* PrinterRedirectionDisabled */
packetResponse->redirectionFlags.portRedirectionDisabled = *((UINT32*) &buffer[72]); /* PortRedirectionDisabled */
packetResponse->redirectionFlags.reserved = *((UINT32*) &buffer[76]); /* Reserved */
packetResponse->redirectionFlags.clipboardRedirectionDisabled = *((UINT32*) &buffer[80]); /* ClipboardRedirectionDisabled */
packetResponse->redirectionFlags.pnpRedirectionDisabled = *((UINT32*) &buffer[84]); /* PnpRedirectionDisabled */
offset = 88;
packetResponse->redirectionFlags.enableAllRedirections = *((UINT32*) &buffer[offset + 28]); /* EnableAllRedirections */
packetResponse->redirectionFlags.disableAllRedirections = *((UINT32*) &buffer[offset + 32]); /* DisableAllRedirections */
packetResponse->redirectionFlags.driveRedirectionDisabled = *((UINT32*) &buffer[offset + 36]); /* DriveRedirectionDisabled */
packetResponse->redirectionFlags.printerRedirectionDisabled = *((UINT32*) &buffer[offset + 40]); /* PrinterRedirectionDisabled */
packetResponse->redirectionFlags.portRedirectionDisabled = *((UINT32*) &buffer[offset + 44]); /* PortRedirectionDisabled */
packetResponse->redirectionFlags.reserved = *((UINT32*) &buffer[offset + 48]); /* Reserved */
packetResponse->redirectionFlags.clipboardRedirectionDisabled = *((UINT32*) &buffer[offset + 52]); /* ClipboardRedirectionDisabled */
packetResponse->redirectionFlags.pnpRedirectionDisabled = *((UINT32*) &buffer[offset + 56]); /* PnpRedirectionDisabled */
offset += 60;
SizeValue = *((UINT32*) &buffer[offset]);
offset += 4;
@ -787,18 +788,18 @@ BOOL TsProxyCreateChannelWriteRequest(rdpTsg* tsg)
BOOL TsProxyCreateChannelReadResponse(rdpTsg* tsg)
{
int status;
RPC_PDU* pdu;
BYTE* buffer;
UINT32 length;
rdpRpc* rpc = tsg->rpc;
status = rpc_recv_pdu_fragment(rpc);
pdu = rpc_recv_pdu(rpc);
if (status < 0)
if (!pdu)
return FALSE;
length = status;
buffer = rpc->FragBuffer;
length = pdu->Length;
buffer = pdu->Buffer;
/* ChannelContext (20 bytes) */
CopyMemory(&tsg->ChannelContext.ContextType, &rpc->FragBuffer[24], 4); /* ContextType (4 bytes) */
@ -883,21 +884,6 @@ BOOL TsProxySetupReceivePipeWriteRequest(rdpTsg* tsg)
BOOL TsProxySetupReceivePipeReadResponse(rdpTsg* tsg)
{
#if 0
int status;
BYTE* FragBuffer;
UINT32 length;
rdpRpc* rpc = tsg->rpc;
status = rpc_recv_pdu_fragment(rpc);
if (status < 0)
return FALSE;
length = status;
FragBuffer = rpc->FragBuffer;
#endif
return TRUE;
}
@ -1091,8 +1077,6 @@ BOOL tsg_connect(rdpTsg* tsg, const char* hostname, UINT16 port)
if (!TsProxySetupReceivePipe((handle_t) tsg, NULL))
return FALSE;
tsg->state = TSG_STATE_PIPE_CREATED;
rpc->client->SynchronousSend = TRUE;
return TRUE;
@ -1100,7 +1084,6 @@ BOOL tsg_connect(rdpTsg* tsg, const char* hostname, UINT16 port)
int tsg_read(rdpTsg* tsg, BYTE* data, UINT32 length)
{
int status;
int CopyLength;
rdpRpc* rpc = tsg->rpc;
@ -1110,7 +1093,7 @@ int tsg_read(rdpTsg* tsg, BYTE* data, UINT32 length)
{
CopyLength = (tsg->BytesAvailable > length) ? length : tsg->BytesAvailable;
CopyMemory(data, &rpc->StubBuffer[tsg->BytesRead], CopyLength);
CopyMemory(data, &tsg->pdu->Buffer[tsg->BytesRead], CopyLength);
tsg->BytesAvailable -= CopyLength;
tsg->BytesRead += CopyLength;
@ -1121,9 +1104,9 @@ int tsg_read(rdpTsg* tsg, BYTE* data, UINT32 length)
}
else
{
status = rpc_recv_pdu(rpc);
tsg->pdu = rpc_recv_pdu(rpc);
if (rpc->StubLength == 4)
if ((tsg->pdu->Flags & RPC_PDU_FLAG_STUB) && (tsg->pdu->Length == 4))
{
DEBUG_TSG("Ignoring TsProxySetupReceivePipe Response");
return tsg_read(tsg, data, length);
@ -1131,12 +1114,12 @@ int tsg_read(rdpTsg* tsg, BYTE* data, UINT32 length)
}
tsg->PendingPdu = TRUE;
tsg->BytesAvailable = rpc->StubLength;
tsg->BytesAvailable = rpc->pdu->Length;
tsg->BytesRead = 0;
CopyLength = (tsg->BytesAvailable > length) ? length : tsg->BytesAvailable;
CopyMemory(data, &rpc->StubBuffer[tsg->BytesRead], CopyLength);
CopyMemory(data, &tsg->pdu->Buffer[tsg->BytesRead], CopyLength);
tsg->BytesAvailable -= CopyLength;
tsg->BytesRead += CopyLength;

1
libfreerdp/core/gateway/tsg.h
View File

@ -55,6 +55,7 @@ struct rdp_tsg
{
rdpRpc* rpc;
UINT16 Port;
RPC_PDU* pdu;
LPWSTR Hostname;
LPWSTR MachineName;
TSG_STATE state;