int rpc_http_send_replacement_out_channel_request(rdpRpc* rpc) { wStream* s; int content_length; content_length = 120; s = rpc_ntlm_http_request(rpc, NULL, content_length, TSG_CHANNEL_OUT); WLog_DBG(TAG, "\n%s", Stream_Buffer(s)); rpc_out_write(rpc, Stream_Buffer(s), Stream_Length(s)); Stream_Free(s, TRUE); return 0; }
int rpc_ncacn_http_send_out_channel_request(rdpRpc* rpc, RpcOutChannel* outChannel, BOOL replacement) { wStream* s; int status; int contentLength; BOOL continueNeeded; rdpNtlm* ntlm = outChannel->ntlm; HttpContext* http = outChannel->http; continueNeeded = ntlm_authenticate(ntlm); if (!replacement) contentLength = (continueNeeded) ? 0 : 76; else contentLength = (continueNeeded) ? 0 : 120; s = rpc_ntlm_http_request(rpc, http, "RPC_OUT_DATA", contentLength, &ntlm->outputBuffer[0]); if (!s) return -1; status = rpc_out_channel_write(outChannel, Stream_Buffer(s), Stream_Length(s)); Stream_Free(s, TRUE); return (status > 0) ? 1 : -1; }
BOOL TsProxyCloseTunnelReadResponse(rdpTsg* tsg) { RPC_PDU* pdu; BYTE* buffer; UINT32 length; UINT32 offset; rdpRpc* rpc = tsg->rpc; pdu = rpc_recv_dequeue_pdu(rpc); if (!pdu) return FALSE; length = Stream_Length(pdu->s); buffer = Stream_Buffer(pdu->s); if (!(pdu->Flags & RPC_PDU_FLAG_STUB)) buffer = &buffer[24]; offset = 0; rpc_client_receive_pool_return(rpc, pdu); return TRUE; }
static int rdpdr_server_send_client_id_confirm(RdpdrServerContext* context) { wStream* s; BOOL status; RDPDR_HEADER header; ULONG written; CLOG_DBG("RdpdrServerSendClientIdConfirm\n"); header.Component = RDPDR_CTYP_CORE; header.PacketId = PAKID_CORE_CLIENTID_CONFIRM; s = Stream_New(NULL, RDPDR_HEADER_LENGTH + 8); Stream_Write_UINT16(s, header.Component); /* Component (2 bytes) */ Stream_Write_UINT16(s, header.PacketId); /* PacketId (2 bytes) */ Stream_Write_UINT16(s, context->priv->VersionMajor); /* VersionMajor (2 bytes) */ Stream_Write_UINT16(s, context->priv->VersionMinor); /* VersionMinor (2 bytes) */ Stream_Write_UINT32(s, context->priv->ClientId); /* ClientId (4 bytes) */ Stream_SealLength(s); status = WTSVirtualChannelWrite(context->priv->ChannelHandle, (PCHAR) Stream_Buffer(s), Stream_Length(s), &written); Stream_Free(s, TRUE); return 0; }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ static UINT audin_server_send_open(audin_server* audin, wStream* s) { ULONG written; if (audin->context.selected_client_format < 0) { WLog_ERR(TAG, "audin->context.selected_client_format = %d", audin->context.selected_client_format); return ERROR_INVALID_DATA; } audin->opened = TRUE; Stream_SetPosition(s, 0); Stream_Write_UINT8(s, MSG_SNDIN_OPEN); Stream_Write_UINT32(s, audin->context.frames_per_packet); /* FramesPerPacket (4 bytes) */ Stream_Write_UINT32(s, audin->context.selected_client_format); /* initialFormat (4 bytes) */ /* * [MS-RDPEAI] 3.2.5.1.6 * The second format specify the format that SHOULD be used to capture data from * the actual audio input device. */ Stream_Write_UINT16(s, 1); /* wFormatTag = PCM */ Stream_Write_UINT16(s, 2); /* nChannels */ Stream_Write_UINT32(s, 44100); /* nSamplesPerSec */ Stream_Write_UINT32(s, 44100 * 2 * 2); /* nAvgBytesPerSec */ Stream_Write_UINT16(s, 4); /* nBlockAlign */ Stream_Write_UINT16(s, 16); /* wBitsPerSample */ Stream_Write_UINT16(s, 0); /* cbSize */ return WTSVirtualChannelWrite(audin->audin_channel, (PCHAR) Stream_Buffer(s), Stream_GetPosition(s), &written) ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR; }
void test_nsc_encode(void) { int i; BYTE* rgb_data; wStream* enc_stream; NSC_CONTEXT* context; rgb_data = (BYTE *) malloc(64 * 64 * 3); for (i = 0; i < 64; i++) memcpy(rgb_data + i * 64 * 3, rgb_scanline_data, 64 * 3); context = nsc_context_new(); nsc_context_set_pixel_format(context, RDP_PIXEL_FORMAT_R8G8B8); enc_stream = stream_new(65536); stream_clear(enc_stream); for (i = 0; i < 30000; i++) { Stream_SetPosition(enc_stream, 0); nsc_compose_message(context, enc_stream, rgb_data, 64, 64, 64 * 3); } /*winpr_HexDump(Stream_Buffer(enc_stream), Stream_GetPosition(enc_stream));*/ nsc_process_message(context, 32, 64, 64, Stream_Buffer(enc_stream), Stream_GetPosition(enc_stream)); /*winpr_HexDump(context->bmpdata, 64 * 64 * 4);*/ stream_free(enc_stream); nsc_context_free(context); }
static UINT rdpgfx_send_qoe_frame_acknowledge_pdu(RDPGFX_CHANNEL_CALLBACK* callback, const RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU* pdu) { UINT error; wStream* s; RDPGFX_HEADER header; RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*) callback->plugin; header.flags = 0; header.cmdId = RDPGFX_CMDID_QOEFRAMEACKNOWLEDGE; header.pduLength = RDPGFX_HEADER_SIZE + 12; WLog_Print(gfx->log, WLOG_DEBUG, "SendQoeFrameAcknowledgePdu: %"PRIu32"", pdu->frameId); s = Stream_New(NULL, header.pduLength); if (!s) { WLog_ERR(TAG, "Stream_New failed!"); return CHANNEL_RC_NO_MEMORY; } if ((error = rdpgfx_write_header(s, &header))) goto fail; /* RDPGFX_FRAME_ACKNOWLEDGE_PDU */ Stream_Write_UINT32(s, pdu->frameId); Stream_Write_UINT32(s, pdu->timestamp); Stream_Write_UINT16(s, pdu->timeDiffSE); Stream_Write_UINT16(s, pdu->timeDiffEDR); error = callback->channel->Write(callback->channel, (UINT32) Stream_Length(s), Stream_Buffer(s), NULL); fail: Stream_Free(s, TRUE); return error; }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ static UINT rdpgfx_send_frame_acknowledge_pdu(RDPGFX_CHANNEL_CALLBACK* callback, RDPGFX_FRAME_ACKNOWLEDGE_PDU* pdu) { UINT error; wStream* s; RDPGFX_HEADER header; header.flags = 0; header.cmdId = RDPGFX_CMDID_FRAMEACKNOWLEDGE; header.pduLength = RDPGFX_HEADER_SIZE + 12; WLog_DBG(TAG, "SendFrameAcknowledgePdu: %d", pdu->frameId); s = Stream_New(NULL, header.pduLength); if (!s) { WLog_ERR(TAG, "Stream_New failed!"); return CHANNEL_RC_NO_MEMORY; } if ((error = rdpgfx_write_header(s, &header))) { WLog_ERR(TAG, "rdpgfx_write_header failed with error %u!", error); return error; } /* RDPGFX_FRAME_ACKNOWLEDGE_PDU */ Stream_Write_UINT32(s, pdu->queueDepth); /* queueDepth (4 bytes) */ Stream_Write_UINT32(s, pdu->frameId); /* frameId (4 bytes) */ Stream_Write_UINT32(s, pdu->totalFramesDecoded); /* totalFramesDecoded (4 bytes) */ error = callback->channel->Write(callback->channel, (UINT32) Stream_Length(s), Stream_Buffer(s), NULL); Stream_Free(s, TRUE); return error; }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ UINT rdpei_server_send_sc_ready(RdpeiServerContext *context, UINT32 version) { ULONG written; RdpeiServerPrivate *priv = context->priv; if (priv->automataState != STATE_INITIAL) { WLog_ERR(TAG, "called from unexpected state %d", (int)priv->automataState); return ERROR_INVALID_STATE; } Stream_SetPosition(priv->outputStream, 0); if (!Stream_EnsureCapacity(priv->outputStream, RDPINPUT_HEADER_LENGTH + 4)) { WLog_ERR(TAG, "Stream_EnsureCapacity failed!"); return CHANNEL_RC_NO_MEMORY; } Stream_Write_UINT16(priv->outputStream, EVENTID_SC_READY); Stream_Write_UINT32(priv->outputStream, RDPINPUT_HEADER_LENGTH + 4); Stream_Write_UINT32(priv->outputStream, version); if (!WTSVirtualChannelWrite(priv->channelHandle, (PCHAR)Stream_Buffer(priv->outputStream), Stream_GetPosition(priv->outputStream), &written)) { WLog_ERR(TAG, "WTSVirtualChannelWrite failed!"); return ERROR_INTERNAL_ERROR; } priv->automataState = STATE_WAITING_CLIENT_READY; return CHANNEL_RC_OK; }
BOOL TsProxyCreateChannelReadResponse(rdpTsg* tsg, RPC_PDU* pdu) { BYTE* buffer; UINT32 length; UINT32 offset; rdpRpc* rpc = tsg->rpc; if (!pdu) return FALSE; length = Stream_Length(pdu->s); buffer = Stream_Buffer(pdu->s); if (!(pdu->Flags & RPC_PDU_FLAG_STUB)) buffer = &buffer[24]; offset = 0; /* ChannelContext (20 bytes) */ CopyMemory(&tsg->ChannelContext.ContextType, &buffer[offset], 4); /* ContextType (4 bytes) */ CopyMemory(tsg->ChannelContext.ContextUuid, &buffer[offset + 4], 16); /* ContextUuid (16 bytes) */ #ifdef WITH_DEBUG_TSG fprintf(stderr, "ChannelContext:\n"); winpr_HexDump((void*) &tsg->ChannelContext, 20); fprintf(stderr, "\n"); #endif rpc_client_receive_pool_return(rpc, pdu); return TRUE; }
BOOL rdg_process_keep_alive_packet(rdpRdg* rdg) { int status; wStream* sChunk; int packetSize = 8; char chunkSize[11]; sprintf_s(chunkSize, sizeof(chunkSize), "%X\r\n", packetSize); sChunk = Stream_New(NULL, strlen(chunkSize) + packetSize + 2); if (!sChunk) return FALSE; Stream_Write(sChunk, chunkSize, strlen(chunkSize)); Stream_Write_UINT16(sChunk, PKT_TYPE_KEEPALIVE); /* Type */ Stream_Write_UINT16(sChunk, 0); /* Reserved */ Stream_Write_UINT32(sChunk, packetSize); /* Packet length */ Stream_Write(sChunk, "\r\n", 2); Stream_SealLength(sChunk); status = tls_write_all(rdg->tlsIn, Stream_Buffer(sChunk), Stream_Length(sChunk)); Stream_Free(sChunk, TRUE); return (status < 0 ? FALSE : TRUE); }
int rdpei_server_send_sc_ready(RdpeiServerContext *context, UINT32 version) { ULONG written; RdpeiServerPrivate *priv = context->priv; if (priv->automataState != STATE_INITIAL) { fprintf(stderr, "%s: called from unexpected state %d\n", __FUNCTION__, priv->automataState); return -1; } Stream_SetPosition(priv->outputStream, 0); Stream_EnsureCapacity(priv->outputStream, RDPINPUT_HEADER_LENGTH + 4); Stream_Write_UINT16(priv->outputStream, EVENTID_SC_READY); Stream_Write_UINT32(priv->outputStream, RDPINPUT_HEADER_LENGTH + 4); Stream_Write_UINT32(priv->outputStream, version); if (!WTSVirtualChannelWrite(priv->channelHandle, (PCHAR)Stream_Buffer(priv->outputStream), Stream_GetPosition(priv->outputStream), &written)) { fprintf(stderr, "%s: error writing ready message\n", __FUNCTION__); return -1; } priv->automataState = STATE_WAITING_CLIENT_READY; return 0; }
static int rdpdr_server_send_core_capability_request(RdpdrServerContext* context) { wStream* s; BOOL status; RDPDR_HEADER header; UINT16 numCapabilities; ULONG written; WLog_DBG(TAG, "RdpdrServerSendCoreCapabilityRequest"); header.Component = RDPDR_CTYP_CORE; header.PacketId = PAKID_CORE_SERVER_CAPABILITY; numCapabilities = 5; s = Stream_New(NULL, RDPDR_HEADER_LENGTH + 512); Stream_Write_UINT16(s, header.Component); /* Component (2 bytes) */ Stream_Write_UINT16(s, header.PacketId); /* PacketId (2 bytes) */ Stream_Write_UINT16(s, numCapabilities); /* numCapabilities (2 bytes) */ Stream_Write_UINT16(s, 0); /* Padding (2 bytes) */ rdpdr_server_write_general_capability_set(context, s); rdpdr_server_write_printer_capability_set(context, s); rdpdr_server_write_port_capability_set(context, s); rdpdr_server_write_drive_capability_set(context, s); rdpdr_server_write_smartcard_capability_set(context, s); Stream_SealLength(s); status = WTSVirtualChannelWrite(context->priv->ChannelHandle, (PCHAR) Stream_Buffer(s), Stream_Length(s), &written); Stream_Free(s, TRUE); return 0; }
int rdpgfx_send_frame_acknowledge_pdu(RDPGFX_CHANNEL_CALLBACK* callback, RDPGFX_FRAME_ACKNOWLEDGE_PDU* pdu) { int status; wStream* s; RDPGFX_HEADER header; RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*) callback->plugin; header.flags = 0; header.cmdId = RDPGFX_CMDID_FRAMEACKNOWLEDGE; header.pduLength = RDPGFX_HEADER_SIZE + 12; WLog_Print(gfx->log, WLOG_DEBUG, "SendFrameAcknowledgePdu: %d", pdu->frameId); s = Stream_New(NULL, header.pduLength); rdpgfx_write_header(s, &header); /* RDPGFX_FRAME_ACKNOWLEDGE_PDU */ Stream_Write_UINT32(s, pdu->queueDepth); /* queueDepth (4 bytes) */ Stream_Write_UINT32(s, pdu->frameId); /* frameId (4 bytes) */ Stream_Write_UINT32(s, pdu->totalFramesDecoded); /* totalFramesDecoded (4 bytes) */ status = callback->channel->Write(callback->channel, (UINT32) Stream_Length(s), Stream_Buffer(s), NULL); Stream_Free(s, TRUE); return status; }
static BOOL TestStream_Fill(void) { BOOL rc = FALSE; const BYTE fill[7] = "XXXXXXX"; const BYTE data[] = "someteststreamdata"; wStream* s = Stream_New(NULL, sizeof(data)); if (!s) goto out; Stream_Write(s, data, sizeof(data)); if (memcmp(Stream_Buffer(s), data, sizeof(data)) != 0) goto out; Stream_SetPosition(s, 0); if (s->pointer != s->buffer) goto out; Stream_Fill(s, fill[0], sizeof(fill)); if (s->pointer != s->buffer + sizeof(fill)) goto out; if (memcmp(Stream_Pointer(s), data+sizeof(fill), sizeof(data)-sizeof(fill)) != 0) goto out; Stream_SetPosition(s, 0); if (s->pointer != s->buffer) goto out; if (memcmp(Stream_Pointer(s), fill, sizeof(fill)) != 0) goto out; rc = TRUE; out: Stream_Free(s, TRUE); return rc; }
static void WTSProcessChannelData(rdpPeerChannel* channel, UINT16 channelId, BYTE* data, int size, int flags, int totalSize) { if (flags & CHANNEL_FLAG_FIRST) { Stream_SetPosition(channel->receiveData, 0); } Stream_EnsureRemainingCapacity(channel->receiveData, size); Stream_Write(channel->receiveData, data, size); if (flags & CHANNEL_FLAG_LAST) { if (Stream_GetPosition(channel->receiveData) != totalSize) { fprintf(stderr, "WTSProcessChannelData: read error\n"); } if (channel == channel->vcm->drdynvc_channel) { wts_read_drdynvc_pdu(channel); } else { wts_queue_receive_data(channel, Stream_Buffer(channel->receiveData), Stream_GetPosition(channel->receiveData)); } Stream_SetPosition(channel->receiveData, 0); } }
static BOOL wts_read_drdynvc_data(rdpPeerChannel* channel, wStream* s, UINT32 length) { BOOL ret = FALSE; if (channel->dvc_total_length > 0) { if (Stream_GetPosition(channel->receiveData) + length > channel->dvc_total_length) { channel->dvc_total_length = 0; WLog_ERR(TAG, "incorrect fragment data, discarded."); return FALSE; } Stream_Write(channel->receiveData, Stream_Pointer(s), length); if (Stream_GetPosition(channel->receiveData) >= (int) channel->dvc_total_length) { ret = wts_queue_receive_data(channel, Stream_Buffer(channel->receiveData), channel->dvc_total_length); channel->dvc_total_length = 0; } } else { ret = wts_queue_receive_data(channel, Stream_Pointer(s), length); } return ret; }
static int rdg_write_data_packet(rdpRdg* rdg, BYTE* buf, int size) { int status; wStream* sChunk; int packetSize = size + 10; char chunkSize[11]; if (size < 1) return 0; sprintf_s(chunkSize, sizeof(chunkSize), "%X\r\n", packetSize); sChunk = Stream_New(NULL, strlen(chunkSize) + packetSize + 2); if (!sChunk) return -1; Stream_Write(sChunk, chunkSize, strlen(chunkSize)); Stream_Write_UINT16(sChunk, PKT_TYPE_DATA); /* Type */ Stream_Write_UINT16(sChunk, 0); /* Reserved */ Stream_Write_UINT32(sChunk, packetSize); /* Packet length */ Stream_Write_UINT16(sChunk, size); /* Data size */ Stream_Write(sChunk, buf, size); /* Data */ Stream_Write(sChunk, "\r\n", 2); Stream_SealLength(sChunk); status = tls_write_all(rdg->tlsIn, Stream_Buffer(sChunk), Stream_Length(sChunk)); Stream_Free(sChunk, TRUE); if (status < 0) return -1; return size; }
RPC_PDU* rpc_recv_dequeue_pdu(rdpRpc* rpc) { RPC_PDU* pdu; DWORD dwMilliseconds; DWORD result; dwMilliseconds = rpc->client->SynchronousReceive ? SYNCHRONOUS_TIMEOUT * 4 : 0; result = WaitForSingleObject(Queue_Event(rpc->client->ReceiveQueue), dwMilliseconds); if (result == WAIT_TIMEOUT) { WLog_ERR(TAG, "timed out waiting for receive event"); return NULL; } if (result != WAIT_OBJECT_0) return NULL; pdu = (RPC_PDU*)Queue_Dequeue(rpc->client->ReceiveQueue); #ifdef WITH_DEBUG_TSG if (pdu) { WLog_DBG(TAG, "Receiving PDU (length: %d, CallId: %d)", pdu->s->length, pdu->CallId); winpr_HexDump(TAG, WLOG_DEBUG, Stream_Buffer(pdu->s), Stream_Length(pdu->s)); } else { WLog_DBG(TAG, "Receiving a NULL PDU"); } #endif return pdu; }
static BOOL rdpsnd_server_close(RdpsndServerContext* context) { int pos; BOOL status; wStream* s = context->priv->rdpsnd_pdu; if (context->selected_client_format < 0) return FALSE; if (context->priv->out_pending_frames > 0) { if (!rdpsnd_server_send_audio_pdu(context)) return FALSE; } context->selected_client_format = -1; Stream_Write_UINT8(s, SNDC_CLOSE); Stream_Write_UINT8(s, 0); Stream_Seek_UINT16(s); pos = Stream_GetPosition(s); Stream_SetPosition(s, 2); Stream_Write_UINT16(s, pos - 4); Stream_SetPosition(s, pos); status = WTSVirtualChannelWrite(context->priv->ChannelHandle, (PCHAR) Stream_Buffer(s), Stream_GetPosition(s), NULL); Stream_SetPosition(s, 0); return status; }
BOOL rdg_process_in_channel_authorization(rdpRdg* rdg, HttpResponse* response) { wStream* s; int status; if (response->StatusCode != HTTP_STATUS_OK) { rdg->state = RDG_CLIENT_STATE_CLOSED; return FALSE; } WLog_DBG(TAG, "In Channel authorization complete"); rdg->state = RDG_CLIENT_STATE_IN_CHANNEL_AUTHORIZED; s = rdg_build_http_request(rdg, "RDG_IN_DATA"); if (!s) return FALSE; status = tls_write_all(rdg->tlsIn, Stream_Buffer(s), Stream_Length(s)); Stream_Free(s, TRUE); if (status <= 0) return FALSE; return TRUE; }
static int rdpdr_server_send_user_logged_on(RdpdrServerContext* context) { wStream* s; BOOL status; RDPDR_HEADER header; ULONG written; CLOG_DBG("%s\n", __FUNCTION__); header.Component = RDPDR_CTYP_CORE; header.PacketId = PAKID_CORE_USER_LOGGEDON; s = Stream_New(NULL, RDPDR_HEADER_LENGTH); Stream_Write_UINT16(s, header.Component); /* Component (2 bytes) */ Stream_Write_UINT16(s, header.PacketId); /* PacketId (2 bytes) */ Stream_SealLength(s); status = WTSVirtualChannelWrite(context->priv->ChannelHandle, (PCHAR) Stream_Buffer(s), Stream_Length(s), &written); Stream_Free(s, TRUE); return 0; }
int rdpei_server_resume(RdpeiServerContext *context) { ULONG written; RdpeiServerPrivate *priv = context->priv; switch (priv->automataState) { case STATE_WAITING_FRAME: fprintf(stderr, "%s: not suspended\n", __FUNCTION__); return 0; case STATE_SUSPENDED: break; default: fprintf(stderr, "%s: called from unexpected state %d\n", __FUNCTION__, priv->automataState); return -1; } Stream_SetPosition(priv->outputStream, 0); Stream_EnsureCapacity(priv->outputStream, RDPINPUT_HEADER_LENGTH); Stream_Write_UINT16(priv->outputStream, EVENTID_RESUME_TOUCH); Stream_Write_UINT32(priv->outputStream, RDPINPUT_HEADER_LENGTH); if (!WTSVirtualChannelWrite(priv->channelHandle, (PCHAR)Stream_Buffer(priv->outputStream), Stream_GetPosition(priv->outputStream), &written)) { fprintf(stderr, "%s: error writing resumeTouch message\n", __FUNCTION__); return -1; } priv->automataState = STATE_WAITING_FRAME; return 0; }
static BOOL WTSProcessChannelData(rdpPeerChannel* channel, UINT16 channelId, BYTE* data, int size, int flags, int totalSize) { BOOL ret = TRUE; if (flags & CHANNEL_FLAG_FIRST) { Stream_SetPosition(channel->receiveData, 0); } if (!Stream_EnsureRemainingCapacity(channel->receiveData, size)) return FALSE; Stream_Write(channel->receiveData, data, size); if (flags & CHANNEL_FLAG_LAST) { if (Stream_GetPosition(channel->receiveData) != totalSize) { WLog_ERR(TAG, "read error"); } if (channel == channel->vcm->drdynvc_channel) { ret = wts_read_drdynvc_pdu(channel); } else { ret = wts_queue_receive_data(channel, Stream_Buffer(channel->receiveData), Stream_GetPosition(channel->receiveData)); } Stream_SetPosition(channel->receiveData, 0); } return ret; }
RPC_PDU* rpc_recv_dequeue_pdu(rdpRpc* rpc) { RPC_PDU* pdu; DWORD dwMilliseconds; pdu = NULL; dwMilliseconds = rpc->client->SynchronousReceive ? INFINITE : 0; if (WaitForSingleObject(Queue_Event(rpc->client->ReceiveQueue), dwMilliseconds) == WAIT_OBJECT_0) { pdu = (RPC_PDU*) Queue_Dequeue(rpc->client->ReceiveQueue); #ifdef WITH_DEBUG_TSG if (pdu) { fprintf(stderr, "Receiving PDU (length: %d, CallId: %d)\n", pdu->s->length, pdu->CallId); winpr_HexDump(Stream_Buffer(pdu->s), Stream_Length(pdu->s)); fprintf(stderr, "\n"); } #endif return pdu; } return pdu; }
int rpc_secure_bind(rdpRpc* rpc) { int status; RPC_PDU* pdu; rpc->client->SynchronousSend = TRUE; rpc->client->SynchronousReceive = TRUE; while (rpc->State != RPC_CLIENT_STATE_CONTEXT_NEGOTIATED) { if (rpc->State == RPC_CLIENT_STATE_ESTABLISHED) { status = rpc_send_bind_pdu(rpc); if (status <= 0) { DEBUG_WARN( "rpc_secure_bind: error sending bind pdu!\n"); return -1; } rpc->State = RPC_CLIENT_STATE_WAIT_SECURE_BIND_ACK; } else if (rpc->State == RPC_CLIENT_STATE_WAIT_SECURE_BIND_ACK) { pdu = rpc_recv_dequeue_pdu(rpc); if (!pdu) { DEBUG_WARN( "rpc_secure_bind: error receiving bind ack pdu!\n"); return -1; } if (rpc_recv_bind_ack_pdu(rpc, Stream_Buffer(pdu->s), Stream_Length(pdu->s)) <= 0) { DEBUG_WARN( "rpc_secure_bind: error receiving bind ack pdu!\n"); return -1; } rpc_client_receive_pool_return(rpc, pdu); if (rpc_send_rpc_auth_3_pdu(rpc) <= 0) { DEBUG_WARN( "rpc_secure_bind: error sending rpc_auth_3 pdu!\n"); return -1; } rpc->State = RPC_CLIENT_STATE_CONTEXT_NEGOTIATED; } else { DEBUG_WARN( "rpc_secure_bind: invalid state: %d\n", rpc->State); return -1; } } rpc->client->SynchronousSend = TRUE; rpc->client->SynchronousReceive = TRUE; return 0; }
BOOL tf_peer_dump_rfx(freerdp_peer* client) { wStream* s; UINT32 prev_seconds; UINT32 prev_useconds; rdpUpdate* update; rdpPcap* pcap_rfx; pcap_record record; s = Stream_New(NULL, 512); if (!s) return FALSE; update = client->update; if (!(pcap_rfx = pcap_open(test_pcap_file, FALSE))) return FALSE; prev_seconds = prev_useconds = 0; while (pcap_has_next_record(pcap_rfx)) { if (!pcap_get_next_record_header(pcap_rfx, &record)) break; if (!Stream_EnsureCapacity(s, record.length)) break; record.data = Stream_Buffer(s); pcap_get_next_record_content(pcap_rfx, &record); Stream_SetPointer(s, Stream_Buffer(s) + Stream_Capacity(s)); if (test_dump_rfx_realtime && test_sleep_tsdiff(&prev_seconds, &prev_useconds, record.header.ts_sec, record.header.ts_usec) == FALSE) break; update->SurfaceCommand(update->context, s); if (client->CheckFileDescriptor(client) != TRUE) break; } Stream_Free(s, TRUE); pcap_close(pcap_rfx); return TRUE; }
static BOOL WLog_BinaryAppender_WriteMessage(wLog* log, wLogAppender* appender, wLogMessage* message) { FILE* fp; wStream* s; int MessageLength; int FileNameLength; int FunctionNameLength; int TextStringLength; BOOL ret = TRUE; wLogBinaryAppender* binaryAppender; if (!log || !appender || !message) return FALSE; binaryAppender = (wLogBinaryAppender *)appender; fp = binaryAppender->FileDescriptor; if (!fp) return FALSE; FileNameLength = (int) strlen(message->FileName); FunctionNameLength = (int) strlen(message->FunctionName); TextStringLength = (int) strlen(message->TextString); MessageLength = 16 + (4 + FileNameLength + 1) + (4 + FunctionNameLength + 1) + (4 + TextStringLength + 1); s = Stream_New(NULL, MessageLength); if (!s) return FALSE; Stream_Write_UINT32(s, MessageLength); Stream_Write_UINT32(s, message->Type); Stream_Write_UINT32(s, message->Level); Stream_Write_UINT32(s, message->LineNumber); Stream_Write_UINT32(s, FileNameLength); Stream_Write(s, message->FileName, FileNameLength + 1); Stream_Write_UINT32(s, FunctionNameLength); Stream_Write(s, message->FunctionName, FunctionNameLength + 1); Stream_Write_UINT32(s, TextStringLength); Stream_Write(s, message->TextString, TextStringLength + 1); Stream_SealLength(s); if (fwrite(Stream_Buffer(s), MessageLength, 1, fp) != 1) ret = FALSE; Stream_Free(s, TRUE); return ret; }
static void test_peer_draw_background(freerdp_peer* client) { int size; wStream* s; RFX_RECT rect; BYTE* rgb_data; rdpUpdate* update = client->update; SURFACE_BITS_COMMAND* cmd = &update->surface_bits_command; testPeerContext* context = (testPeerContext*) client->context; if (!client->settings->RemoteFxCodec && !client->settings->NSCodec) return; s = test_peer_stream_init(context); rect.x = 0; rect.y = 0; rect.width = client->settings->DesktopWidth; rect.height = client->settings->DesktopHeight; size = rect.width * rect.height * 3; if (!(rgb_data = malloc(size))) return; memset(rgb_data, 0xA0, size); if (client->settings->RemoteFxCodec) { if (!rfx_compose_message(context->rfx_context, s, &rect, 1, rgb_data, rect.width, rect.height, rect.width * 3)) { goto out; } cmd->codecID = client->settings->RemoteFxCodecId; } else { nsc_compose_message(context->nsc_context, s, rgb_data, rect.width, rect.height, rect.width * 3); cmd->codecID = client->settings->NSCodecId; } cmd->destLeft = 0; cmd->destTop = 0; cmd->destRight = rect.width; cmd->destBottom = rect.height; cmd->bpp = 32; cmd->width = rect.width; cmd->height = rect.height; cmd->bitmapDataLength = Stream_GetPosition(s); cmd->bitmapData = Stream_Buffer(s); test_peer_begin_frame(client); update->SurfaceBits(update->context, cmd); test_peer_end_frame(client); out: free(rgb_data); }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ static UINT drdynvc_send(drdynvcPlugin* drdynvc, wStream* s) { UINT status; if (!drdynvc) status = CHANNEL_RC_BAD_CHANNEL_HANDLE; else { status = drdynvc->channelEntryPoints.pVirtualChannelWriteEx(drdynvc->InitHandle, drdynvc->OpenHandle, Stream_Buffer(s), (UINT32) Stream_GetPosition(s), s); } switch (status) { case CHANNEL_RC_OK: return CHANNEL_RC_OK; case CHANNEL_RC_NOT_CONNECTED: Stream_Free(s, TRUE); return CHANNEL_RC_OK; case CHANNEL_RC_BAD_CHANNEL_HANDLE: Stream_Free(s, TRUE); WLog_ERR(TAG, "VirtualChannelWriteEx failed with CHANNEL_RC_BAD_CHANNEL_HANDLE"); return status; default: Stream_Free(s, TRUE); WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08"PRIX32"]", WTSErrorToString(status), status); return status; } }