void gcc_write_conference_create_response(STREAM* s, STREAM* user_data) { /* ConnectData */ per_write_choice(s, 0); per_write_object_identifier(s, t124_02_98_oid); /* ConnectData::connectPDU (OCTET_STRING) */ per_write_length(s, stream_get_length(user_data) + 2); /* ConnectGCCPDU */ per_write_choice(s, 0x14); /* ConferenceCreateResponse::nodeID (UserID) */ per_write_integer16(s, 0x79F3, 1001); /* ConferenceCreateResponse::tag (INTEGER) */ per_write_integer(s, 1); /* ConferenceCreateResponse::result (ENUMERATED) */ per_write_enumerated(s, 0, MCS_Result_enum_length); /* number of UserData sets */ per_write_number_of_sets(s, 1); /* UserData::value present + select h221NonStandard (1) */ per_write_choice(s, 0xC0); /* h221NonStandard */ per_write_octet_string(s, h221_sc_key, 4, 4); /* h221NonStandard, server-to-client H.221 key, "McDn" */ /* userData (OCTET_STRING) */ per_write_octet_string(s, user_data->data, stream_get_length(user_data), 0); /* array of server data blocks */ }
static void WTSProcessChannelData(rdpPeerChannel* channel, int channelId, BYTE* data, int size, int flags, int total_size) { if (flags & CHANNEL_FLAG_FIRST) { stream_set_pos(channel->receive_data, 0); } stream_check_size(channel->receive_data, size); stream_write(channel->receive_data, data, size); if (flags & CHANNEL_FLAG_LAST) { if (stream_get_length(channel->receive_data) != total_size) { fprintf(stderr, "WTSProcessChannelData: read error\n"); } if (channel == channel->vcm->drdynvc_channel) { wts_read_drdynvc_pdu(channel); } else { wts_queue_receive_data(channel, stream_get_head(channel->receive_data), stream_get_length(channel->receive_data)); } stream_set_pos(channel->receive_data, 0); } }
void gcc_write_conference_create_request(STREAM* s, STREAM* user_data) { /* ConnectData */ per_write_choice(s, 0); /* From Key select object (0) of type OBJECT_IDENTIFIER */ per_write_object_identifier(s, t124_02_98_oid); /* ITU-T T.124 (02/98) OBJECT_IDENTIFIER */ /* ConnectData::connectPDU (OCTET_STRING) */ per_write_length(s, stream_get_length(user_data) + 14); /* connectPDU length */ /* ConnectGCCPDU */ per_write_choice(s, 0); /* From ConnectGCCPDU select conferenceCreateRequest (0) of type ConferenceCreateRequest */ per_write_selection(s, 0x08); /* select optional userData from ConferenceCreateRequest */ /* ConferenceCreateRequest::conferenceName */ per_write_numeric_string(s, "1", 1, 1); /* ConferenceName::numeric */ per_write_padding(s, 1); /* padding */ /* UserData (SET OF SEQUENCE) */ per_write_number_of_sets(s, 1); /* one set of UserData */ per_write_choice(s, 0xC0); /* UserData::value present + select h221NonStandard (1) */ /* h221NonStandard */ per_write_octet_string(s, h221_cs_key, 4, 4); /* h221NonStandard, client-to-server H.221 key, "Duca" */ /* userData::value (OCTET_STRING) */ per_write_octet_string(s, user_data->data, stream_get_length(user_data), 0); /* array of client data blocks */ }
int credssp_client_authenticate(rdpCredssp* credssp) { NTLMSSP* ntlmssp = credssp->ntlmssp; STREAM* s = stream_new(0); uint8* negoTokenBuffer = (uint8*) xmalloc(2048); if (credssp_ntlmssp_client_init(credssp) == 0) return 0; /* NTLMSSP NEGOTIATE MESSAGE */ stream_attach(s, negoTokenBuffer, 2048); ntlmssp_send(ntlmssp, s); credssp->negoToken.data = stream_get_head(s); credssp->negoToken.length = stream_get_length(s); credssp_send(credssp, &credssp->negoToken, NULL, NULL); /* NTLMSSP CHALLENGE MESSAGE */ if (credssp_recv(credssp, &credssp->negoToken, NULL, NULL) < 0) return -1; stream_attach(s, credssp->negoToken.data, credssp->negoToken.length); ntlmssp_recv(ntlmssp, s); freerdp_blob_free(&credssp->negoToken); /* NTLMSSP AUTHENTICATE MESSAGE */ stream_attach(s, negoTokenBuffer, 2048); ntlmssp_send(ntlmssp, s); /* The last NTLMSSP message is sent with the encrypted public key */ credssp->negoToken.data = stream_get_head(s); credssp->negoToken.length = stream_get_length(s); credssp_encrypt_public_key(credssp, &credssp->pubKeyAuth); credssp_send(credssp, &credssp->negoToken, NULL, &credssp->pubKeyAuth); freerdp_blob_free(&credssp->pubKeyAuth); /* Encrypted Public Key +1 */ if (credssp_recv(credssp, &credssp->negoToken, NULL, &credssp->pubKeyAuth) < 0) return -1; if (credssp_verify_public_key(credssp, &credssp->pubKeyAuth) == 0) { /* Failed to verify server public key echo */ return 0; /* DO NOT SEND CREDENTIALS! */ } freerdp_blob_free(&credssp->negoToken); freerdp_blob_free(&credssp->pubKeyAuth); /* Send encrypted credentials */ credssp_encode_ts_credentials(credssp); credssp_encrypt_ts_credentials(credssp, &credssp->authInfo); credssp_send(credssp, NULL, &credssp->authInfo, NULL); freerdp_blob_free(&credssp->authInfo); xfree(s); return 1; }
static void test_peer_draw_icon(freerdp_peer* client, int x, int y) { testPeerContext* context = (testPeerContext*) client->context; rdpUpdate* update = client->update; SURFACE_BITS_COMMAND* cmd = &update->surface_bits_command; RFX_RECT rect; STREAM* s; if (client->update->dump_rfx) return; if (!client->settings->rfx_codec || !context) return; if (context->icon_width < 1 || !context->activated) return; rect.x = 0; rect.y = 0; rect.width = context->icon_width; rect.height = context->icon_height; if (context->icon_x >= 0) { s = test_peer_stream_init(context); rfx_compose_message(context->rfx_context, s, &rect, 1, context->bg_data, rect.width, rect.height, rect.width * 3); cmd->destLeft = context->icon_x; cmd->destTop = context->icon_y; cmd->destRight = context->icon_x + context->icon_width; cmd->destBottom = context->icon_y + context->icon_height; cmd->bpp = 32; cmd->codecID = client->settings->rfx_codec_id; cmd->width = context->icon_width; cmd->height = context->icon_height; cmd->bitmapDataLength = stream_get_length(s); cmd->bitmapData = stream_get_head(s); update->SurfaceBits(update->context, cmd); } s = test_peer_stream_init(context); rfx_compose_message(context->rfx_context, s, &rect, 1, context->icon_data, rect.width, rect.height, rect.width * 3); cmd->destLeft = x; cmd->destTop = y; cmd->destRight = x + context->icon_width; cmd->destBottom = y + context->icon_height; cmd->bpp = 32; cmd->codecID = client->settings->rfx_codec_id; cmd->width = context->icon_width; cmd->height = context->icon_height; cmd->bitmapDataLength = stream_get_length(s); cmd->bitmapData = stream_get_head(s); update->SurfaceBits(update->context, cmd); context->icon_x = x; context->icon_y = y; }
static void update_send_surface_command(rdpContext* context, STREAM* s) { STREAM* update; rdpRdp* rdp = context->rdp; update = fastpath_update_pdu_init(rdp->fastpath); stream_check_size(update, stream_get_length(s)); stream_write(update, stream_get_head(s), stream_get_length(s)); fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, update); }
int transport_write(rdpTransport* transport, STREAM* s) { int status = -1; if (transport->layer == TRANSPORT_LAYER_TLS) status = tls_write(transport->tls, s->data, stream_get_length(s)); else if (transport->layer == TRANSPORT_LAYER_TCP) status = tcp_write(transport->tcp, s->data, stream_get_length(s)); return status; }
int svc_plugin_send(rdpSvcPlugin* plugin, STREAM* data_out) { uint32 error = 0; DEBUG_SVC("length %d", stream_get_length(data_out)); error = plugin->channel_entry_points.pVirtualChannelWrite(plugin->priv->open_handle, stream_get_data(data_out), stream_get_length(data_out), data_out); if (error != CHANNEL_RC_OK) printf("svc_plugin_send: VirtualChannelWrite failed %d\n", error); return error; }
void test_read_fast_index_order(void) { STREAM _s, *s; FAST_INDEX_ORDER fast_index; s = &_s; s->p = s->data = fast_index_order; memset(orderInfo, 0, sizeof(ORDER_INFO)); orderInfo->fieldFlags = 0x70FF; memset(&fast_index, 0, sizeof(FAST_INDEX_ORDER)); update_read_fast_index_order(s, orderInfo, &fast_index); CU_ASSERT(fast_index.cacheId == 7); CU_ASSERT(fast_index.flAccel == 3); CU_ASSERT(fast_index.ulCharInc == 0); CU_ASSERT(fast_index.backColor == 0x0000FFFF); CU_ASSERT(fast_index.foreColor == 0x00003B74); CU_ASSERT(fast_index.bkLeft == 14); CU_ASSERT(fast_index.bkTop == 113); CU_ASSERT(fast_index.bkRight == 66); CU_ASSERT(fast_index.bkBottom == 126); CU_ASSERT(fast_index.opLeft == 0); CU_ASSERT(fast_index.opTop == 0); CU_ASSERT(fast_index.opRight == 0); CU_ASSERT(fast_index.opBottom == 0); CU_ASSERT(fast_index.x == -32768); CU_ASSERT(fast_index.y == 124); CU_ASSERT(stream_get_length(s) == (sizeof(fast_index_order) - 1)); }
boolean license_send(rdpLicense* license, STREAM* s, uint8 type) { int length; uint8 flags; uint16 wMsgSize; uint16 sec_flags; DEBUG_LICENSE("Sending %s Packet", LICENSE_MESSAGE_STRINGS[type & 0x1F]); length = stream_get_length(s); stream_set_pos(s, 0); sec_flags = SEC_LICENSE_PKT; wMsgSize = length - LICENSE_PACKET_HEADER_MAX_LENGTH + 4; /** * Using EXTENDED_ERROR_MSG_SUPPORTED here would cause mstsc to crash when * running in server mode! This flag seems to be incorrectly documented. */ flags = PREAMBLE_VERSION_3_0; rdp_write_header(license->rdp, s, length, MCS_GLOBAL_CHANNEL_ID); rdp_write_security_header(s, sec_flags); license_write_preamble(s, type, flags, wMsgSize); #ifdef WITH_DEBUG_LICENSE printf("Sending %s Packet, length %d\n", LICENSE_MESSAGE_STRINGS[type & 0x1F], wMsgSize); freerdp_hexdump(s->p - 4, wMsgSize); #endif stream_set_pos(s, length); if (transport_write(license->rdp->transport, s) < 0) return false; return true; }
void test_read_line_to_order(void) { STREAM _s, *s; LINE_TO_ORDER line_to; s = &_s; s->p = s->data = line_to_order; memset(orderInfo, 0, sizeof(ORDER_INFO)); orderInfo->fieldFlags = 0x021E; orderInfo->deltaCoordinates = true; memset(&line_to, 0, sizeof(LINE_TO_ORDER)); line_to.nXStart = 826; line_to.nYStart = 350; line_to.nXEnd = 829; line_to.nYEnd = 347; update_read_line_to_order(s, orderInfo, &line_to); CU_ASSERT(line_to.nXStart == 829); CU_ASSERT(line_to.nYStart == 271); CU_ASSERT(line_to.nXEnd == 843); CU_ASSERT(line_to.nYEnd == 257); CU_ASSERT(line_to.backColor == 0); CU_ASSERT(line_to.bRop2 == 0); CU_ASSERT(line_to.penStyle == 0); CU_ASSERT(line_to.penWidth == 0); CU_ASSERT(line_to.penColor == 0x00EF5B); CU_ASSERT(stream_get_length(s) == (sizeof(line_to_order) - 1)); }
void test_read_draw_nine_grid_order(void) { STREAM _s, *s; DRAW_NINE_GRID_ORDER draw_nine_grid; s = &_s; s->p = s->data = draw_nine_grid_order; memset(orderInfo, 0, sizeof(ORDER_INFO)); orderInfo->fieldFlags = 0x1C; orderInfo->deltaCoordinates = true; memset(&draw_nine_grid, 0, sizeof(DRAW_NINE_GRID_ORDER)); draw_nine_grid.srcRight = 38; draw_nine_grid.srcBottom = 40; update_read_draw_nine_grid_order(s, orderInfo, &draw_nine_grid); CU_ASSERT(draw_nine_grid.srcLeft == 0); CU_ASSERT(draw_nine_grid.srcTop == 0); CU_ASSERT(draw_nine_grid.srcRight == 33); CU_ASSERT(draw_nine_grid.srcBottom == 33); CU_ASSERT(draw_nine_grid.bitmapId == 13); CU_ASSERT(stream_get_length(s) == (sizeof(draw_nine_grid_order) - 1)); }
boolean rdp_send_data_pdu(rdpRdp* rdp, STREAM* s, uint8 type, uint16 channel_id) { uint16 length; uint32 sec_bytes; uint8* sec_hold; length = stream_get_length(s); stream_set_pos(s, 0); rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID); sec_bytes = rdp_get_sec_bytes(rdp); sec_hold = s->p; stream_seek(s, sec_bytes); rdp_write_share_control_header(s, length - sec_bytes, PDU_TYPE_DATA, channel_id); rdp_write_share_data_header(s, length - sec_bytes, type, rdp->settings->share_id); s->p = sec_hold; length += rdp_security_stream_out(rdp, s, length); stream_set_pos(s, length); if (transport_write(rdp->transport, s) < 0) return false; return true; }
void test_read_cache_bitmap_v3_order(void) { STREAM _s, *s; uint16 extraFlags; CACHE_BITMAP_V3_ORDER cache_bitmap_v3; s = &_s; extraFlags = 0x0C30; s->p = s->data = cache_bitmap_v3_order; memset(&cache_bitmap_v3, 0, sizeof(CACHE_BITMAP_V3_ORDER)); update_read_cache_bitmap_v3_order(s, &cache_bitmap_v3, true, extraFlags); CU_ASSERT(cache_bitmap_v3.cacheIndex == 32767); CU_ASSERT(cache_bitmap_v3.key1 == 0xBCEC5035); CU_ASSERT(cache_bitmap_v3.key2 == 0xB7655274); CU_ASSERT(cache_bitmap_v3.bpp == 32); CU_ASSERT(cache_bitmap_v3.bitmapData.bpp == 32); CU_ASSERT(cache_bitmap_v3.bitmapData.codecID == 0); CU_ASSERT(cache_bitmap_v3.bitmapData.width == 5); CU_ASSERT(cache_bitmap_v3.bitmapData.height == 2); CU_ASSERT(cache_bitmap_v3.bitmapData.length == 40); CU_ASSERT(stream_get_length(s) == (sizeof(cache_bitmap_v3_order) - 1)); }
static void audin_server_send_open(audin_server* audin, STREAM* s) { if (audin->context.selected_client_format < 0) return; audin->opened = TRUE; stream_set_pos(s, 0); stream_write_BYTE(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 */ WTSVirtualChannelWrite(audin->audin_channel, stream_get_head(s), stream_get_length(s), NULL); }
void test_read_patblt_order(void) { STREAM _s, *s; PATBLT_ORDER patblt; s = &_s; s->p = s->data = patblt_order; memset(orderInfo, 0, sizeof(ORDER_INFO)); orderInfo->fieldFlags = 0x027F; memset(&patblt, 0, sizeof(PATBLT_ORDER)); update_read_patblt_order(s, orderInfo, &patblt); CU_ASSERT(patblt.nLeftRect == 26); CU_ASSERT(patblt.nTopRect == 451); CU_ASSERT(patblt.nWidth == 13); CU_ASSERT(patblt.nHeight == 13); CU_ASSERT(patblt.bRop == 240); CU_ASSERT(patblt.backColor == 0x00FFFF); CU_ASSERT(patblt.foreColor == 0x00EF5B); CU_ASSERT(patblt.brush.x == 0); CU_ASSERT(patblt.brush.y == 0); CU_ASSERT(patblt.brush.style == (BMF_1BPP | CACHED_BRUSH)); CU_ASSERT(stream_get_length(s) == (sizeof(patblt_order) - 1)); }
static void sample_process_receive(rdpSvcPlugin* plugin, STREAM* data_in) { int bytes; STREAM* data_out; samplePlugin* sample = (samplePlugin*) plugin; printf("sample_process_receive:\n"); if (!sample) { printf("sample_process_receive: sample is nil\n"); return; } /* process data in (from server) here */ /* here we just send the same data back */ bytes = stream_get_size(data_in); printf("sample_process_receive: got bytes %d\n", bytes); if (bytes > 0) { data_out = stream_new(bytes); stream_copy(data_out, data_in, bytes); /* svc_plugin_send takes ownership of data_out, that is why we do not free it */ bytes = stream_get_length(data_in); printf("sample_process_receive: sending bytes %d\n", bytes); svc_plugin_send(plugin, data_out); } stream_free(data_in); }
BOOL rdp_send_data_pdu(rdpRdp* rdp, STREAM* s, BYTE type, UINT16 channel_id) { UINT16 length; UINT32 sec_bytes; BYTE* sec_hold; length = stream_get_length(s); stream_set_pos(s, 0); rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID); sec_bytes = rdp_get_sec_bytes(rdp); sec_hold = s->p; stream_seek(s, sec_bytes); rdp_write_share_control_header(s, length - sec_bytes, PDU_TYPE_DATA, channel_id); rdp_write_share_data_header(s, length - sec_bytes, type, rdp->settings->ShareId); s->p = sec_hold; length += rdp_security_stream_out(rdp, s, length); stream_set_pos(s, length); if (transport_write(rdp->transport, s) < 0) return FALSE; return TRUE; }
BOOL rdp_send(rdpRdp* rdp, STREAM* s, UINT16 channel_id) { UINT16 length; UINT32 sec_bytes; BYTE* sec_hold; length = stream_get_length(s); stream_set_pos(s, 0); rdp_write_header(rdp, s, length, channel_id); sec_bytes = rdp_get_sec_bytes(rdp); sec_hold = s->p; stream_seek(s, sec_bytes); s->p = sec_hold; length += rdp_security_stream_out(rdp, s, length); stream_set_pos(s, length); if (transport_write(rdp->transport, s) < 0) return FALSE; return TRUE; }
void test_read_fast_glyph_order(void) { STREAM _s, *s; FAST_GLYPH_ORDER fast_glyph; s = &_s; s->p = s->data = fast_glyph_order; memset(orderInfo, 0, sizeof(ORDER_INFO)); orderInfo->fieldFlags = 0x7EFB; memset(&fast_glyph, 0, sizeof(FAST_GLYPH_ORDER)); update_read_fast_glyph_order(s, orderInfo, &fast_glyph); CU_ASSERT(fast_glyph.backColor == 0); CU_ASSERT(fast_glyph.foreColor == 0x0000FFFF); CU_ASSERT(fast_glyph.bkLeft == 139); CU_ASSERT(fast_glyph.bkTop == 177); CU_ASSERT(fast_glyph.bkRight == 147); CU_ASSERT(fast_glyph.bkBottom == 190); CU_ASSERT(fast_glyph.opLeft == 0); CU_ASSERT(fast_glyph.opTop == 13); CU_ASSERT(fast_glyph.opRight == 32766); CU_ASSERT(fast_glyph.opBottom == -32768); CU_ASSERT(fast_glyph.x == -32768); CU_ASSERT(fast_glyph.y == 187); CU_ASSERT(stream_get_length(s) == (sizeof(fast_glyph_order) - 1)); }
static void audin_server_send_formats(audin_server* audin, STREAM* s) { int i; UINT32 nAvgBytesPerSec; stream_set_pos(s, 0); stream_write_BYTE(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; stream_check_size(s, 18); 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) { stream_check_size(s, audin->context.server_formats[i].cbSize); stream_write(s, audin->context.server_formats[i].data, audin->context.server_formats[i].cbSize); } } WTSVirtualChannelWrite(audin->audin_channel, stream_get_head(s), stream_get_length(s), NULL); }
void test_read_polygon_cb_order(void) { STREAM _s, *s; POLYGON_CB_ORDER polygon_cb; s = &_s; s->p = s->data = polygon_cb_order; memset(orderInfo, 0, sizeof(ORDER_INFO)); orderInfo->fieldFlags = 0x1BEF; memset(&polygon_cb, 0, sizeof(POLYGON_CB_ORDER)); update_read_polygon_cb_order(s, orderInfo, &polygon_cb); CU_ASSERT(polygon_cb.xStart == 234); CU_ASSERT(polygon_cb.yStart == 326); CU_ASSERT(polygon_cb.bRop2 == 0x0D); CU_ASSERT(polygon_cb.fillMode == 1); CU_ASSERT(polygon_cb.backColor == 0); CU_ASSERT(polygon_cb.foreColor == 0x00000008); CU_ASSERT(polygon_cb.brush.x == 4); CU_ASSERT(polygon_cb.brush.y == 3); CU_ASSERT(polygon_cb.brush.style == 0x81); CU_ASSERT(polygon_cb.numPoints == 3); CU_ASSERT(polygon_cb.cbData == 5); CU_ASSERT(stream_get_length(s) == (sizeof(polygon_cb_order) - 1)); }
static void svc_plugin_process_received(rdpSvcPlugin* plugin, void* pData, uint32 dataLength, uint32 totalLength, uint32 dataFlags) { STREAM* data_in; if (dataFlags & CHANNEL_FLAG_FIRST) { if (plugin->priv->data_in != NULL) stream_free(plugin->priv->data_in); plugin->priv->data_in = stream_new(totalLength); } data_in = plugin->priv->data_in; stream_check_size(data_in, dataLength); stream_write(data_in, pData, dataLength); if (dataFlags & CHANNEL_FLAG_LAST) { if (stream_get_size(data_in) != stream_get_length(data_in)) { printf("svc_plugin_process_received: read error\n"); } /* the stream ownership is passed to the callback who is responsible for freeing it. */ plugin->priv->data_in = NULL; stream_set_pos(data_in, 0); plugin->receive_callback(plugin, data_in); } }
void test_read_create_offscreen_bitmap_order(void) { STREAM _s, *s; OFFSCREEN_DELETE_LIST* deleteList; CREATE_OFFSCREEN_BITMAP_ORDER create_offscreen_bitmap; s = &_s; s->p = s->data = create_offscreen_bitmap_order; memset(&create_offscreen_bitmap, 0, sizeof(CREATE_OFFSCREEN_BITMAP_ORDER)); deleteList = &(create_offscreen_bitmap.deleteList); deleteList->cIndices = 0; deleteList->sIndices = 16; deleteList->indices = malloc(sizeof(uint16) * deleteList->sIndices); update_read_create_offscreen_bitmap_order(s, &create_offscreen_bitmap); CU_ASSERT(create_offscreen_bitmap.id == 0); CU_ASSERT(create_offscreen_bitmap.cx == 352); CU_ASSERT(create_offscreen_bitmap.cy == 16); CU_ASSERT(create_offscreen_bitmap.deleteList.cIndices == 1); CU_ASSERT(stream_get_length(s) == (sizeof(create_offscreen_bitmap_order) - 1)); }
void test_nsc_encode(void) { int i; uint8* rgb_data; STREAM* enc_stream; NSC_CONTEXT* context; rgb_data = (uint8 *) 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_cpu_opt(context, CPU_SSE2); 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_set_pos(enc_stream, 0); nsc_compose_message(context, enc_stream, rgb_data, 64, 64, 64 * 3); } /*freerdp_hexdump(stream_get_head(enc_stream), stream_get_length(enc_stream));*/ nsc_process_message(context, 32, 64, 64, stream_get_head(enc_stream), stream_get_length(enc_stream)); /*freerdp_hexdump(context->bmpdata, 64 * 64 * 4);*/ stream_free(enc_stream); nsc_context_free(context); }
void credssp_send(rdpCredssp* credssp) { STREAM* s; int length; int ts_request_length; int nego_tokens_length; int pub_key_auth_length; int auth_info_length; nego_tokens_length = (credssp->negoToken.cbBuffer > 0) ? credssp_skip_nego_tokens(credssp->negoToken.cbBuffer) : 0; pub_key_auth_length = (credssp->pubKeyAuth.cbBuffer > 0) ? credssp_skip_pub_key_auth(credssp->pubKeyAuth.cbBuffer) : 0; auth_info_length = (credssp->authInfo.cbBuffer > 0) ? credssp_skip_auth_info(credssp->authInfo.cbBuffer) : 0; length = nego_tokens_length + pub_key_auth_length + auth_info_length; ts_request_length = credssp_skip_ts_request(length); s = stream_new(ts_request_length); /* TSRequest */ length = der_get_content_length(ts_request_length); der_write_sequence_tag(s, length); /* SEQUENCE */ /* [0] version */ ber_write_contextual_tag(s, 0, 3, true); ber_write_integer(s, 2); /* INTEGER */ /* [1] negoTokens (NegoData) */ if (nego_tokens_length > 0) { length = der_get_content_length(nego_tokens_length); length -= der_write_contextual_tag(s, 1, length, true); /* NegoData */ length -= der_write_sequence_tag(s, length); /* SEQUENCE OF NegoDataItem */ length -= der_write_sequence_tag(s, length); /* NegoDataItem */ length -= der_write_contextual_tag(s, 0, length, true); /* [0] negoToken */ der_write_octet_string(s, (uint8*) credssp->negoToken.pvBuffer, length); /* OCTET STRING */ } /* [2] authInfo (OCTET STRING) */ if (auth_info_length > 0) { length = ber_get_content_length(auth_info_length); length -= ber_write_contextual_tag(s, 2, length, true); ber_write_octet_string(s, credssp->authInfo.pvBuffer, credssp->authInfo.cbBuffer); } /* [3] pubKeyAuth (OCTET STRING) */ if (pub_key_auth_length > 0) { length = ber_get_content_length(pub_key_auth_length); length -= ber_write_contextual_tag(s, 3, length, true); ber_write_octet_string(s, credssp->pubKeyAuth.pvBuffer, length); } //printf("Sending TSRequest: (%d)\n", stream_get_length(s)); //freerdp_hexdump(s->data, stream_get_length(s)); tls_write(credssp->tls, s->data, stream_get_length(s)); stream_free(s); }
static void sc_output_alignment(IRP *irp, uint32 seed) { uint32 size = stream_get_length(irp->output) - 20; uint32 add = (seed - (size % seed)) % seed; if (add > 0) stream_write_zero(irp->output, add); }
void test_read_polyline_order(void) { STREAM _s, *s; POLYLINE_ORDER polyline; s = &_s; s->p = s->data = polyline_order; memset(orderInfo, 0, sizeof(ORDER_INFO)); orderInfo->fieldFlags = 0x73; memset(&polyline, 0, sizeof(POLYLINE_ORDER)); update_read_polyline_order(s, orderInfo, &polyline); CU_ASSERT(polyline.xStart == 504); CU_ASSERT(polyline.yStart == 696); CU_ASSERT(polyline.bRop2 == 0); CU_ASSERT(polyline.penColor == 0x0000C000); CU_ASSERT(polyline.numPoints == 32); CU_ASSERT(polyline.cbData == 108); CU_ASSERT(polyline.points[0].x == -130); CU_ASSERT(polyline.points[1].x == -191); CU_ASSERT(polyline.points[2].x == -220); CU_ASSERT(polyline.points[3].x == -213); CU_ASSERT(polyline.points[4].x == -171); CU_ASSERT(polyline.points[5].x == -100); CU_ASSERT(polyline.points[6].x == -13); CU_ASSERT(polyline.points[7].x == 77); CU_ASSERT(polyline.points[8].x == 153); CU_ASSERT(polyline.points[9].x == 205); CU_ASSERT(polyline.points[10].x == 222); CU_ASSERT(polyline.points[11].x == 202); CU_ASSERT(polyline.points[12].x == 150); CU_ASSERT(polyline.points[13].x == 72); CU_ASSERT(polyline.points[14].x == -17); CU_ASSERT(polyline.points[15].x == -105); CU_ASSERT(polyline.points[16].x == -174); CU_ASSERT(polyline.points[17].x == -213); CU_ASSERT(polyline.points[18].x == -220); CU_ASSERT(polyline.points[19].x == -188); CU_ASSERT(polyline.points[20].x == -127); CU_ASSERT(polyline.points[21].x == -42); CU_ASSERT(polyline.points[22].x == 47); CU_ASSERT(polyline.points[23].x == 130); CU_ASSERT(polyline.points[24].x == 191); CU_ASSERT(polyline.points[25].x == 221); CU_ASSERT(polyline.points[26].x == 212); CU_ASSERT(polyline.points[27].x == 171); CU_ASSERT(polyline.points[28].x == 100); CU_ASSERT(polyline.points[29].x == 13); CU_ASSERT(polyline.points[30].x == -77); CU_ASSERT(polyline.points[31].x == -153); CU_ASSERT(polyline.points[32].x == 0); CU_ASSERT(stream_get_length(s) == (sizeof(polyline_order) - 1)); }
int transport_write(rdpTransport* transport, STREAM* s) { int status = -1; int length; length = stream_get_length(s); stream_set_pos(s, 0); #ifdef WITH_DEBUG_TRANSPORT if (length > 0) { printf("Local > Remote\n"); winpr_HexDump(s->data, length); } #endif while (length > 0) { if (transport->layer == TRANSPORT_LAYER_TLS) status = tls_write(transport->TlsOut, stream_get_tail(s), length); else if (transport->layer == TRANSPORT_LAYER_TCP) status = tcp_write(transport->TcpOut, stream_get_tail(s), length); else if (transport->layer == TRANSPORT_LAYER_TSG) status = tsg_write(transport->tsg, stream_get_tail(s), length); if (status < 0) break; /* error occurred */ if (status == 0) { /* when sending is blocked in nonblocking mode, the receiving buffer should be checked */ if (!transport->blocking) { /* and in case we do have buffered some data, we set the event so next loop will get it */ if (transport_read_nonblocking(transport) > 0) SetEvent(transport->ReceiveEvent); } if (transport->layer == TRANSPORT_LAYER_TLS) tls_wait_write(transport->TlsOut); else if (transport->layer == TRANSPORT_LAYER_TCP) tcp_wait_write(transport->TcpOut); else USleep(transport->SleepInterval); } length -= status; stream_seek(s, status); } if (status < 0) { /* A write error indicates that the peer has dropped the connection */ transport->layer = TRANSPORT_LAYER_CLOSED; } return status; }
void test_read_glyph_index_order(void) { STREAM _s, *s; GLYPH_INDEX_ORDER glyph_index; s = &_s; s->p = s->data = glyph_index_order_1; memset(orderInfo, 0, sizeof(ORDER_INFO)); orderInfo->fieldFlags = 0x200100; orderInfo->deltaCoordinates = true; memset(&glyph_index, 0, sizeof(GLYPH_INDEX_ORDER)); update_read_glyph_index_order(s, orderInfo, &glyph_index); CU_ASSERT(glyph_index.bkRight == 618); CU_ASSERT(stream_get_length(s) == (sizeof(glyph_index_order_1) - 1)); s->p = s->data = glyph_index_order_2; memset(orderInfo, 0, sizeof(ORDER_INFO)); orderInfo->fieldFlags = 0x383FE8; orderInfo->deltaCoordinates = true; memset(&glyph_index, 0, sizeof(GLYPH_INDEX_ORDER)); update_read_glyph_index_order(s, orderInfo, &glyph_index); CU_ASSERT(glyph_index.fOpRedundant == 0); CU_ASSERT(glyph_index.foreColor == 0x00FFFFFF); CU_ASSERT(glyph_index.bkLeft == 524); CU_ASSERT(glyph_index.bkTop == 366); CU_ASSERT(glyph_index.bkRight == 589); CU_ASSERT(glyph_index.bkBottom == 379); CU_ASSERT(glyph_index.opLeft == 521); CU_ASSERT(glyph_index.opTop == 366); CU_ASSERT(glyph_index.opRight == 758); CU_ASSERT(glyph_index.opBottom == 379); CU_ASSERT(glyph_index.x == 524); CU_ASSERT(glyph_index.y == 377); CU_ASSERT(stream_get_length(s) == (sizeof(glyph_index_order_2) - 1)); }