自学教程：C++ stream_get_length函数代码示例

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));}