static BOOL TestStream_Extent(UINT32 maxSize) { UINT32 i; wStream *s = NULL; BOOL result = FALSE; if (!(s = Stream_New(NULL, 1))) { printf("%s: Stream_New failed\n", __FUNCTION__); return FALSE; } for (i = 1; i < maxSize; i++) { if (i % 2) { if (!Stream_EnsureRemainingCapacity(s, i)) goto fail; } else { if (!Stream_EnsureCapacity(s, i)) goto fail; } Stream_SetPosition(s, i); Stream_SealLength(s); if (!TestStream_Verify(s, i, i, i)) { printf("%s: failed to verify stream in iteration %d\n", __FUNCTION__, i); goto fail; } } result = TRUE; fail: if (s) { Stream_Free(s, TRUE); } return result; }
static void rail_virtual_channel_event_data_received(railPlugin* rail, void* pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags) { wStream* data_in; if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME)) { return; } if (dataFlags & CHANNEL_FLAG_FIRST) { if (rail->data_in) Stream_Free(rail->data_in, TRUE); rail->data_in = Stream_New(NULL, totalLength); if (!rail->data_in) { WLog_ERR(TAG, "%s: unable to allocate data_in", __FUNCTION__); return; } } data_in = rail->data_in; if (!Stream_EnsureRemainingCapacity(data_in, (int) dataLength)) { WLog_ERR(TAG, "%s: unable to grow data_in to %d", __FUNCTION__, dataLength); return; } Stream_Write(data_in, pData, dataLength); if (dataFlags & CHANNEL_FLAG_LAST) { if (Stream_Capacity(data_in) != Stream_GetPosition(data_in)) { WLog_ERR(TAG, "rail_plugin_process_received: read error"); } rail->data_in = NULL; Stream_SealLength(data_in); Stream_SetPosition(data_in, 0); MessageQueue_Post(rail->queue, NULL, 0, (void*) data_in, NULL); } }
static UINT video_control_send_client_notification(VideoClientContext *context, TSMM_CLIENT_NOTIFICATION *notif) { BYTE buf[100]; wStream *s; VIDEO_PLUGIN* video = (VIDEO_PLUGIN *)context->handle; IWTSVirtualChannel* channel; UINT ret; UINT32 cbSize; s = Stream_New(buf, 30); if (!s) return CHANNEL_RC_NO_MEMORY; cbSize = 16; Stream_Seek_UINT32(s); /* cbSize */ Stream_Write_UINT32(s, TSMM_PACKET_TYPE_CLIENT_NOTIFICATION); /* PacketType */ Stream_Write_UINT8(s, notif->PresentationId); Stream_Write_UINT8(s, notif->NotificationType); Stream_Zero(s, 2); if (notif->NotificationType == TSMM_CLIENT_NOTIFICATION_TYPE_FRAMERATE_OVERRIDE) { Stream_Write_UINT32(s, 16); /* cbData */ /* TSMM_CLIENT_NOTIFICATION_FRAMERATE_OVERRIDE */ Stream_Write_UINT32(s, notif->FramerateOverride.Flags); Stream_Write_UINT32(s, notif->FramerateOverride.DesiredFrameRate); Stream_Zero(s, 4 * 2); cbSize += 4 * 4; } else { Stream_Write_UINT32(s, 0); /* cbData */ } Stream_SealLength(s); Stream_SetPosition(s, 0); Stream_Write_UINT32(s, cbSize); Stream_Free(s, FALSE); channel = video->control_callback->channel_callback->channel; ret = channel->Write(channel, cbSize, buf, NULL); return ret; }
int nla_client_authenticate(rdpNla* nla) { wStream* s; int status; s = Stream_New(NULL, 4096); if (!s) { WLog_ERR(TAG, "Stream_New failed!"); return -1; } if (nla_client_begin(nla) < 1) { Stream_Free(s, TRUE); return -1; } while (nla->state < NLA_STATE_AUTH_INFO) { Stream_SetPosition(s, 0); status = transport_read_pdu(nla->transport, s); if (status < 0) { WLog_ERR(TAG, "nla_client_authenticate failure"); Stream_Free(s, TRUE); return -1; } status = nla_recv_pdu(nla, s); if (status < 0) { Stream_Free(s, TRUE); return -1; } } Stream_Free(s, TRUE); return 1; }
static void wts_read_drdynvc_data_first(rdpPeerChannel* channel, wStream* s, int cbLen, UINT32 length) { int value; value = wts_read_variable_uint(s, cbLen, &channel->dvc_total_length); if (value == 0) return; length -= value; if (length > channel->dvc_total_length) return; Stream_SetPosition(channel->receiveData, 0); Stream_EnsureRemainingCapacity(channel->receiveData, (int) channel->dvc_total_length); Stream_Write(channel->receiveData, Stream_Pointer(s), length); }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ static UINT dvcman_receive_channel_data(IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId, wStream* data) { UINT status = CHANNEL_RC_OK; DVCMAN_CHANNEL* channel; size_t dataSize = Stream_GetRemainingLength(data); channel = (DVCMAN_CHANNEL*) dvcman_find_channel_by_id(pChannelMgr, ChannelId); if (!channel) { WLog_ERR(TAG, "ChannelId %d not found!", ChannelId); return ERROR_INTERNAL_ERROR; } if (channel->dvc_data) { /* Fragmented data */ if (Stream_GetPosition(channel->dvc_data) + dataSize > (UINT32) Stream_Capacity(channel->dvc_data)) { WLog_ERR(TAG, "data exceeding declared length!"); Stream_Release(channel->dvc_data); channel->dvc_data = NULL; return ERROR_INVALID_DATA; } Stream_Write(channel->dvc_data, Stream_Pointer(data), dataSize); if (((size_t) Stream_GetPosition(channel->dvc_data)) >= channel->dvc_data_length) { Stream_SealLength(channel->dvc_data); Stream_SetPosition(channel->dvc_data, 0); status = channel->channel_callback->OnDataReceived(channel->channel_callback, channel->dvc_data); Stream_Release(channel->dvc_data); channel->dvc_data = NULL; } } else { status = channel->channel_callback->OnDataReceived(channel->channel_callback, data); } return status; }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ static UINT encomsp_recv_change_participant_control_level_pdu( EncomspServerContext* context, wStream* s, ENCOMSP_ORDER_HEADER* header) { int beg, end; ENCOMSP_CHANGE_PARTICIPANT_CONTROL_LEVEL_PDU pdu; UINT error = CHANNEL_RC_OK; beg = ((int) Stream_GetPosition(s)) - ENCOMSP_ORDER_HEADER_SIZE; CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER)); if (Stream_GetRemainingLength(s) < 6) { WLog_ERR(TAG, "Not enough data!"); return ERROR_INVALID_DATA; } Stream_Read_UINT16(s, pdu.Flags); /* Flags (2 bytes) */ Stream_Read_UINT32(s, pdu.ParticipantId); /* ParticipantId (4 bytes) */ end = (int) Stream_GetPosition(s); if ((beg + header->Length) < end) { WLog_ERR(TAG, "Not enough data!"); return ERROR_INVALID_DATA; } if ((beg + header->Length) > end) { if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end)) { WLog_ERR(TAG, "Not enough data!"); return ERROR_INVALID_DATA; } Stream_SetPosition(s, (beg + header->Length)); } IFCALLRET(context->ChangeParticipantControlLevel, error, context, &pdu); if (error) WLog_ERR(TAG, "context->ChangeParticipantControlLevel failed with error %u", error); return error; }
static int update_recv_surfcmd_surface_bits(rdpUpdate* update, wStream* s, UINT32* length) { int pos; SURFACE_BITS_COMMAND* cmd = &update->surface_bits_command; if (Stream_GetRemainingLength(s) < 20) return -1; Stream_Read_UINT16(s, cmd->destLeft); Stream_Read_UINT16(s, cmd->destTop); Stream_Read_UINT16(s, cmd->destRight); Stream_Read_UINT16(s, cmd->destBottom); Stream_Read_UINT8(s, cmd->bpp); if ((cmd->bpp < 1) || (cmd->bpp > 32)) { WLog_ERR(TAG, "invalid bpp value %d", cmd->bpp); return FALSE; } Stream_Seek(s, 2); /* reserved1, reserved2 */ Stream_Read_UINT8(s, cmd->codecID); Stream_Read_UINT16(s, cmd->width); Stream_Read_UINT16(s, cmd->height); Stream_Read_UINT32(s, cmd->bitmapDataLength); if (Stream_GetRemainingLength(s) < cmd->bitmapDataLength) return -1; pos = Stream_GetPosition(s) + cmd->bitmapDataLength; cmd->bitmapData = Stream_Pointer(s); Stream_SetPosition(s, pos); *length = 20 + cmd->bitmapDataLength; WLog_Print(update->log, WLOG_DEBUG, "SurfaceBits: destLeft: %d destTop: %d destRight: %d destBottom: %d " "bpp: %d codecId: %d width: %d height: %d bitmapDataLength: %d", cmd->destLeft, cmd->destTop, cmd->destRight, cmd->destBottom, cmd->bpp, cmd->codecID, cmd->width, cmd->height, cmd->bitmapDataLength); IFCALL(update->SurfaceBits, update->context, cmd); return 0; }
void wf_update_encode(wfInfo* wfi) { RFX_RECT rect; long height, width; BYTE* pDataBits = NULL; int stride; SURFACE_BITS_COMMAND* cmd; wf_info_find_invalid_region(wfi); cmd = &wfi->cmd; Stream_SetPosition(wfi->s, 0); wf_info_getScreenData(wfi, &width, &height, &pDataBits, &stride); rect.x = 0; rect.y = 0; rect.width = (UINT16) width; rect.height = (UINT16) height; //printf("x:%d y:%d w:%d h:%d\n", wfi->invalid.left, wfi->invalid.top, width, height); Stream_Clear(wfi->s); rfx_compose_message(wfi->rfx_context, wfi->s, &rect, 1, pDataBits, width, height, stride); wfi->frame_idx = wfi->rfx_context->frameIdx; cmd->destLeft = wfi->invalid.left; cmd->destTop = wfi->invalid.top; cmd->destRight = wfi->invalid.left + width; cmd->destBottom = wfi->invalid.top + height; cmd->bpp = 32; cmd->codecID = 3; cmd->width = width; cmd->height = height; cmd->bitmapDataLength = Stream_GetPosition(wfi->s); cmd->bitmapData = Stream_Buffer(wfi->s); }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ static UINT rdpgfx_send_reset_graphics_pdu(RdpgfxServerContext* context, RDPGFX_RESET_GRAPHICS_PDU* pdu) { UINT32 index; MONITOR_DEF* monitor; wStream* s; /* Check monitorCount. This ensures total size within 340 bytes) */ if (pdu->monitorCount >= 16) { WLog_ERR(TAG, "Monitor count MUST be less than or equal to 16: %lu", (unsigned long) pdu->monitorCount); return ERROR_INVALID_DATA; } s = rdpgfx_server_single_packet_new( RDPGFX_CMDID_RESETGRAPHICS, RDPGFX_RESET_GRAPHICS_PDU_SIZE - RDPGFX_HEADER_SIZE); if (!s) { WLog_ERR(TAG, "rdpgfx_server_single_packet_new failed!"); return CHANNEL_RC_NO_MEMORY; } Stream_Write_UINT32(s, pdu->width); /* width (4 bytes) */ Stream_Write_UINT32(s, pdu->height); /* height (4 bytes) */ Stream_Write_UINT32(s, pdu->monitorCount); /* monitorCount (4 bytes) */ for (index = 0; index < pdu->monitorCount; index++) { monitor = &(pdu->monitorDefArray[index]); Stream_Write_UINT32(s, monitor->left); /* left (4 bytes) */ Stream_Write_UINT32(s, monitor->top); /* top (4 bytes) */ Stream_Write_UINT32(s, monitor->right); /* right (4 bytes) */ Stream_Write_UINT32(s, monitor->bottom); /* bottom (4 bytes) */ Stream_Write_UINT32(s, monitor->flags); /* flags (4 bytes) */ } /* pad (total size must be 340 bytes) */ Stream_SetPosition(s, RDPGFX_RESET_GRAPHICS_PDU_SIZE); return rdpgfx_server_single_packet_send(context, s); }
int dvcman_receive_channel_data(IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId, wStream* data) { int status = 0; DVCMAN_CHANNEL* channel; UINT32 dataSize = Stream_GetRemainingLength(data); channel = (DVCMAN_CHANNEL*) dvcman_find_channel_by_id(pChannelMgr, ChannelId); if (!channel) { DEBUG_WARN("ChannelId %d not found!", ChannelId); return 1; } if (channel->dvc_data) { /* Fragmented data */ if (Stream_GetPosition(channel->dvc_data) + dataSize > (UINT32) Stream_Capacity(channel->dvc_data)) { DEBUG_WARN("data exceeding declared length!"); Stream_Release(channel->dvc_data); channel->dvc_data = NULL; return 1; } Stream_Write(channel->dvc_data, Stream_Pointer(data), dataSize); if (((size_t) Stream_GetPosition(channel->dvc_data)) >= Stream_Capacity(channel->dvc_data)) { Stream_SealLength(channel->dvc_data); Stream_SetPosition(channel->dvc_data, 0); status = channel->channel_callback->OnDataReceived(channel->channel_callback, channel->dvc_data); Stream_Release(channel->dvc_data); channel->dvc_data = NULL; } } else { status = channel->channel_callback->OnDataReceived(channel->channel_callback, data); } return status; }
static void svc_plugin_process_received(rdpSvcPlugin* plugin, void* pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags) { wStream* s; if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME)) { /* * According to MS-RDPBCGR 2.2.6.1, "All virtual channel traffic MUST be suspended. * This flag is only valid in server-to-client virtual channel traffic. It MUST be * ignored in client-to-server data." Thus it would be best practice to cease data * transmission. However, simply returning here avoids a crash. */ return; } if (dataFlags & CHANNEL_FLAG_FIRST) { if (plugin->data_in != NULL) Stream_Free(plugin->data_in, TRUE); plugin->data_in = Stream_New(NULL, totalLength); } s = plugin->data_in; Stream_EnsureRemainingCapacity(s, (int) dataLength); Stream_Write(s, pData, dataLength); if (dataFlags & CHANNEL_FLAG_LAST) { if (Stream_Capacity(s) != Stream_GetPosition(s)) { fprintf(stderr, "svc_plugin_process_received: read error\n"); } plugin->data_in = NULL; Stream_SealLength(s); Stream_SetPosition(s, 0); MessageQueue_Post(plugin->MsgPipe->In, NULL, 0, (void*) s, NULL); } }
int freerds_client_outbound_vblank_event(rdsModuleConnector* connector) { int length; int status; wStream* s; RDS_MSG_VBLANK_EVENT msg; msg.msgFlags = 0; msg.type = RDS_CLIENT_VBLANK_EVENT; s = connector->OutboundStream; Stream_SetPosition(s, 0); length = freerds_write_vblank_event(NULL, &msg); freerds_write_vblank_event(s, &msg); status = freerds_named_pipe_write(connector->hClientPipe, Stream_Buffer(s), length); return status; }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ static UINT encomsp_recv_graphics_stream_resumed_pdu(encomspPlugin* encomsp, wStream* s, ENCOMSP_ORDER_HEADER* header) { int beg, end; EncomspClientContext* context; ENCOMSP_GRAPHICS_STREAM_RESUMED_PDU pdu; UINT error = CHANNEL_RC_OK; context = encomsp_get_client_interface(encomsp); if (!context) return ERROR_INVALID_HANDLE; beg = ((int) Stream_GetPosition(s)) - ENCOMSP_ORDER_HEADER_SIZE; CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER)); end = (int) Stream_GetPosition(s); if ((beg + header->Length) < end) { WLog_ERR(TAG, "Not enought data!"); return ERROR_INVALID_DATA; } if ((beg + header->Length) > end) { if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end)) { WLog_ERR(TAG, "Not enought data!"); return ERROR_INVALID_DATA; } Stream_SetPosition(s, (beg + header->Length)); } IFCALLRET(context->GraphicsStreamResumed, error, context, &pdu); if (error) WLog_ERR(TAG, "context->GraphicsStreamResumed failed with error %lu", error); return error; }
RPC_PDU* rpc_client_receive_pool_take(rdpRpc* rpc) { RPC_PDU* pdu = NULL; if (WaitForSingleObject(Queue_Event(rpc->client->ReceivePool), 0) == WAIT_OBJECT_0) pdu = Queue_Dequeue(rpc->client->ReceivePool); if (!pdu) { pdu = (RPC_PDU*) malloc(sizeof(RPC_PDU)); pdu->s = Stream_New(NULL, rpc->max_recv_frag); } pdu->CallId = 0; pdu->Flags = 0; Stream_Length(pdu->s) = 0; Stream_SetPosition(pdu->s, 0); return pdu; }
int freerds_client_outbound_suppress_output(rdsBackend* backend, UINT32 suppress_output) { int length; int status; wStream* s; RDS_MSG_SUPPRESS_OUTPUT msg; msg.msgFlags = 0; msg.type = RDS_CLIENT_SUPPRESS_OUTPUT; msg.activeOutput = suppress_output; s = backend->OutboundStream; Stream_SetPosition(s, 0); length = freerds_write_suppress_output(NULL, &msg); freerds_write_suppress_output(s, &msg); status = freerds_named_pipe_write(backend->hClientPipe, Stream_Buffer(s), length); return status; }
static void audin_server_send_formats(audin_server* audin, wStream* s) { int i; UINT32 nAvgBytesPerSec; ULONG written; Stream_SetPosition(s, 0); Stream_Write_UINT8(s, MSG_SNDIN_FORMATS); Stream_Write_UINT32(s, audin->context.num_server_formats); /* NumFormats (4 bytes) */ Stream_Write_UINT32(s, 0); /* cbSizeFormatsPacket (4 bytes), client-to-server only */ for (i = 0; i < audin->context.num_server_formats; i++) { nAvgBytesPerSec = audin->context.server_formats[i].nSamplesPerSec * audin->context.server_formats[i].nChannels * audin->context.server_formats[i].wBitsPerSample / 8; if (!Stream_EnsureRemainingCapacity(s, 18)) return; Stream_Write_UINT16(s, audin->context.server_formats[i].wFormatTag); Stream_Write_UINT16(s, audin->context.server_formats[i].nChannels); Stream_Write_UINT32(s, audin->context.server_formats[i].nSamplesPerSec); Stream_Write_UINT32(s, nAvgBytesPerSec); Stream_Write_UINT16(s, audin->context.server_formats[i].nBlockAlign); Stream_Write_UINT16(s, audin->context.server_formats[i].wBitsPerSample); Stream_Write_UINT16(s, audin->context.server_formats[i].cbSize); if (audin->context.server_formats[i].cbSize) { if (!Stream_EnsureRemainingCapacity(s, audin->context.server_formats[i].cbSize)) return; Stream_Write(s, audin->context.server_formats[i].data, audin->context.server_formats[i].cbSize); } } WTSVirtualChannelWrite(audin->audin_channel, (PCHAR) Stream_Buffer(s), Stream_GetPosition(s), &written); }
static BOOL TestStream_Copy(void) { BOOL rc = FALSE; const BYTE data[] = "someteststreamdata"; wStream* s = Stream_New(NULL, sizeof(data)); wStream* d = Stream_New(NULL, sizeof(data)); if (!s || !d) goto out; if (s->pointer != s->buffer) goto out; Stream_Write(s, data, sizeof(data)); if (memcmp(Stream_Buffer(s), data, sizeof(data)) != 0) goto out; if (s->pointer != s->buffer + sizeof(data)) goto out; Stream_SetPosition(s, 0); if (s->pointer != s->buffer) goto out; Stream_Copy(s, d, sizeof(data)); if (s->pointer != s->buffer + sizeof(data)) goto out; if (d->pointer != d->buffer + sizeof(data)) goto out; if (Stream_GetPosition(s) != Stream_GetPosition(d)) goto out; if (memcmp(Stream_Buffer(s), data, sizeof(data)) != 0) goto out; if (memcmp(Stream_Buffer(d), data, sizeof(data)) != 0) goto out; rc = TRUE; out: Stream_Free(s, TRUE); Stream_Free(d, TRUE); return rc; }
int freerds_client_outbound_synchronize_keyboard_event(rdsModuleConnector* connector, DWORD flags) { int length; int status; wStream* s; RDS_MSG_SYNCHRONIZE_KEYBOARD_EVENT msg; msg.msgFlags = 0; msg.type = RDS_CLIENT_SYNCHRONIZE_KEYBOARD_EVENT; msg.flags = flags; s = connector->OutboundStream; Stream_SetPosition(s, 0); length = freerds_write_synchronize_keyboard_event(NULL, &msg); freerds_write_synchronize_keyboard_event(s, &msg); status = freerds_named_pipe_write(connector->hClientPipe, Stream_Buffer(s), length); return status; }
static int drdynvc_process_create_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s) { int pos; int status; UINT32 ChannelId; wStream* data_out; ChannelId = drdynvc_read_variable_uint(s, cbChId); pos = Stream_GetPosition(s); DEBUG_DVC("ChannelId=%d ChannelName=%s", ChannelId, Stream_Pointer(s)); status = dvcman_create_channel(drdynvc->channel_mgr, ChannelId, (char*) Stream_Pointer(s)); data_out = Stream_New(NULL, pos + 4); Stream_Write_UINT8(data_out, 0x10 | cbChId); Stream_SetPosition(s, 1); Stream_Copy(data_out, s, pos - 1); if (status == 0) { DEBUG_DVC("channel created"); Stream_Write_UINT32(data_out, 0); } else { DEBUG_DVC("no listener"); Stream_Write_UINT32(data_out, (UINT32)(-1)); } status = svc_plugin_send((rdpSvcPlugin*) drdynvc, data_out); if (status != CHANNEL_RC_OK) { DEBUG_WARN("VirtualChannelWrite failed %d", status); return 1; } return 0; }
static int update_recv_surfcmd_surface_bits(rdpUpdate* update, wStream* s, UINT32* length) { int pos; SURFACE_BITS_COMMAND* cmd = &update->surface_bits_command; if (Stream_GetRemainingLength(s) < 20) return -1; Stream_Read_UINT16(s, cmd->destLeft); Stream_Read_UINT16(s, cmd->destTop); Stream_Read_UINT16(s, cmd->destRight); Stream_Read_UINT16(s, cmd->destBottom); Stream_Read_UINT8(s, cmd->bpp); if ((cmd->bpp < 1) || (cmd->bpp > 32)) { fprintf(stderr, "%s: invalid bpp value %d", __FUNCTION__, cmd->bpp); return FALSE; } Stream_Seek(s, 2); /* reserved1, reserved2 */ Stream_Read_UINT8(s, cmd->codecID); Stream_Read_UINT16(s, cmd->width); Stream_Read_UINT16(s, cmd->height); Stream_Read_UINT32(s, cmd->bitmapDataLength); if (Stream_GetRemainingLength(s) < cmd->bitmapDataLength) return -1; pos = Stream_GetPosition(s) + cmd->bitmapDataLength; cmd->bitmapData = Stream_Pointer(s); Stream_SetPosition(s, pos); *length = 20 + cmd->bitmapDataLength; IFCALL(update->SurfaceBits, update->context, cmd); return 0; }
int freerds_client_outbound_virtual_keyboard_event(rdsModuleConnector* connector, DWORD flags, DWORD code) { int length; int status; wStream* s; RDS_MSG_VIRTUAL_KEYBOARD_EVENT msg; msg.msgFlags = 0; msg.type = RDS_CLIENT_VIRTUAL_KEYBOARD_EVENT; msg.flags = flags; msg.code = code; s = connector->OutboundStream; Stream_SetPosition(s, 0); length = freerds_write_virtual_keyboard_event(NULL, &msg); freerds_write_virtual_keyboard_event(s, &msg); status = freerds_named_pipe_write(connector->hClientPipe, Stream_Buffer(s), length); return status; }
int freerds_client_outbound_unicode_keyboard_event(rdsBackend* backend, DWORD flags, DWORD code) { int length; int status; wStream* s; RDS_MSG_UNICODE_KEYBOARD_EVENT msg; msg.msgFlags = 0; msg.type = RDS_CLIENT_UNICODE_KEYBOARD_EVENT; msg.flags = flags; msg.code = code; s = backend->OutboundStream; Stream_SetPosition(s, 0); length = freerds_write_unicode_keyboard_event(NULL, &msg); freerds_write_unicode_keyboard_event(s, &msg); status = freerds_named_pipe_write(backend->hClientPipe, Stream_Buffer(s), length); return status; }
/** * Function description * * @return 0 on success, otherwise a Win32 error code */ UINT rdpei_server_resume(RdpeiServerContext *context) { ULONG written; RdpeiServerPrivate *priv = context->priv; switch (priv->automataState) { case STATE_WAITING_FRAME: WLog_ERR(TAG, "not suspended"); return CHANNEL_RC_OK; case STATE_SUSPENDED: break; default: 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)) { WLog_ERR(TAG, "Stream_EnsureCapacity failed!"); return CHANNEL_RC_NO_MEMORY; } 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)) { WLog_ERR(TAG, "WTSVirtualChannelWrite failed!"); return ERROR_INTERNAL_ERROR; } priv->automataState = STATE_WAITING_FRAME; return CHANNEL_RC_OK; }
BOOL rdg_process_packet(rdpRdg* rdg, wStream* s) { BOOL status = TRUE; UINT16 type; Stream_SetPosition(s, 0); if (Stream_GetRemainingLength(s) < 2) return FALSE; Stream_Peek_UINT16(s, type); switch (type) { case PKT_TYPE_HANDSHAKE_RESPONSE: status = rdg_process_handshake_response(rdg, s); break; case PKT_TYPE_TUNNEL_RESPONSE: status = rdg_process_tunnel_response(rdg, s); break; case PKT_TYPE_TUNNEL_AUTH_RESPONSE: status = rdg_process_tunnel_authorization_response(rdg, s); break; case PKT_TYPE_CHANNEL_RESPONSE: status = rdg_process_channel_response(rdg, s); break; case PKT_TYPE_DATA: assert(FALSE); return FALSE; } return status; }
void serial_get_timeouts(SERIAL_DEVICE* serial, IRP* irp, UINT32* timeout, UINT32* interval_timeout) { SERIAL_TTY* tty; UINT32 Length; UINT32 pos; pos = Stream_GetPosition(irp->input); Stream_Read_UINT32(irp->input, Length); Stream_SetPosition(irp->input, pos); DEBUG_SVC("length read %u", Length); tty = serial->tty; if(!tty) { DEBUG_WARN("tty = %p", tty); return; } *timeout = (tty->read_total_timeout_multiplier * Length) + tty->read_total_timeout_constant; *interval_timeout = tty->read_interval_timeout; DEBUG_SVC("timeouts %u %u", *timeout, *interval_timeout); }
int freerds_client_outbound_extended_mouse_event(rdsModuleConnector* connector, DWORD flags, DWORD x, DWORD y) { int length; int status; wStream* s; RDS_MSG_EXTENDED_MOUSE_EVENT msg; msg.msgFlags = 0; msg.type = RDS_CLIENT_EXTENDED_MOUSE_EVENT; msg.flags = flags; msg.x = x; msg.y = y; s = connector->OutboundStream; Stream_SetPosition(s, 0); length = freerds_write_extended_mouse_event(NULL, &msg); freerds_write_extended_mouse_event(s, &msg); status = freerds_named_pipe_write(connector->hClientPipe, Stream_Buffer(s), length); return status; }
int freerds_client_outbound_mouse_event(rdsBackend* backend, DWORD flags, DWORD x, DWORD y) { int length; int status; wStream* s; RDS_MSG_MOUSE_EVENT msg; msg.msgFlags = 0; msg.type = RDS_CLIENT_MOUSE_EVENT; msg.flags = flags; msg.x = x; msg.y = y; s = backend->OutboundStream; Stream_SetPosition(s, 0); length = freerds_write_mouse_event(NULL, &msg); freerds_write_mouse_event(s, &msg); status = freerds_named_pipe_write(backend->hClientPipe, Stream_Buffer(s), length); return status; }
static void remdesk_virtual_channel_event_data_received(remdeskPlugin* remdesk, void* pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags) { wStream* data_in; if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME)) { return; } if (dataFlags & CHANNEL_FLAG_FIRST) { if (remdesk->data_in) Stream_Free(remdesk->data_in, TRUE); remdesk->data_in = Stream_New(NULL, totalLength); } data_in = remdesk->data_in; Stream_EnsureRemainingCapacity(data_in, (int) dataLength); Stream_Write(data_in, pData, dataLength); if (dataFlags & CHANNEL_FLAG_LAST) { if (Stream_Capacity(data_in) != Stream_GetPosition(data_in)) { WLog_ERR(TAG, "read error"); } remdesk->data_in = NULL; Stream_SealLength(data_in); Stream_SetPosition(data_in, 0); MessageQueue_Post(remdesk->MsgPipe->In, NULL, 0, (void*) data_in, NULL); } }
BOOL nego_send_negotiation_response(rdpNego* nego) { int length; int bm, em; BOOL status; wStream* s; BYTE flags; rdpSettings* settings; status = TRUE; settings = nego->transport->settings; s = Stream_New(NULL, 512); if (!s) return FALSE; length = TPDU_CONNECTION_CONFIRM_LENGTH; bm = Stream_GetPosition(s); Stream_Seek(s, length); if (nego->SelectedProtocol & PROTOCOL_FAILED_NEGO) { UINT32 errorCode = (nego->SelectedProtocol & ~PROTOCOL_FAILED_NEGO); flags = 0; Stream_Write_UINT8(s, TYPE_RDP_NEG_FAILURE); Stream_Write_UINT8(s, flags); /* flags */ Stream_Write_UINT16(s, 8); /* RDP_NEG_DATA length (8) */ Stream_Write_UINT32(s, errorCode); length += 8; status = FALSE; } else { flags = EXTENDED_CLIENT_DATA_SUPPORTED; if (settings->SupportGraphicsPipeline) flags |= DYNVC_GFX_PROTOCOL_SUPPORTED; /* RDP_NEG_DATA must be present for TLS, NLA, and RDP */ Stream_Write_UINT8(s, TYPE_RDP_NEG_RSP); Stream_Write_UINT8(s, flags); /* flags */ Stream_Write_UINT16(s, 8); /* RDP_NEG_DATA length (8) */ Stream_Write_UINT32(s, nego->SelectedProtocol); /* selectedProtocol */ length += 8; } em = Stream_GetPosition(s); Stream_SetPosition(s, bm); tpkt_write_header(s, length); tpdu_write_connection_confirm(s, length - 5); Stream_SetPosition(s, em); Stream_SealLength(s); if (transport_write(nego->transport, s) < 0) { Stream_Free(s, TRUE); return FALSE; } Stream_Free(s, TRUE); if (status) { /* update settings with negotiated protocol security */ settings->RequestedProtocols = nego->RequestedProtocols; settings->SelectedProtocol = nego->SelectedProtocol; if (settings->SelectedProtocol == PROTOCOL_RDP) { settings->TlsSecurity = FALSE; settings->NlaSecurity = FALSE; settings->RdpSecurity = TRUE; settings->UseRdpSecurityLayer = TRUE; if (settings->EncryptionLevel == ENCRYPTION_LEVEL_NONE) { /** * If the server implementation did not explicitely set a * encryption level we default to client compatible */ settings->EncryptionLevel = ENCRYPTION_LEVEL_CLIENT_COMPATIBLE; } if (settings->LocalConnection) { /** * Note: This hack was firstly introduced in commit 95f5e115 to * disable the unnecessary encryption with peers connecting to * 127.0.0.1 or local unix sockets. * This also affects connections via port tunnels! (e.g. ssh -L) */ WLog_INFO(TAG, "Turning off encryption for local peer with standard rdp security"); settings->UseRdpSecurityLayer = FALSE; settings->EncryptionLevel = ENCRYPTION_LEVEL_NONE; } if (!settings->RdpServerRsaKey && !settings->RdpKeyFile) { WLog_ERR(TAG, "Missing server certificate"); return FALSE; } } else if (settings->SelectedProtocol == PROTOCOL_TLS) { settings->TlsSecurity = TRUE; settings->NlaSecurity = FALSE; settings->RdpSecurity = FALSE; settings->UseRdpSecurityLayer = FALSE; settings->EncryptionLevel = ENCRYPTION_LEVEL_NONE; } else if (settings->SelectedProtocol == PROTOCOL_NLA) { settings->TlsSecurity = TRUE; settings->NlaSecurity = TRUE; settings->RdpSecurity = FALSE; settings->UseRdpSecurityLayer = FALSE; settings->EncryptionLevel = ENCRYPTION_LEVEL_NONE; } } return status; }