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

intxrdpvr_set_geometry(void *channel, int stream_id, int xpos, int ypos,                    int width, int height){    STREAM  *s;    char    *cptr;    int     rv;    int     len;    printf("xrdpvr_set_geometry: entered; x=%d y=%d/n", xpos, ypos);    stream_new(s, MAX_PDU_SIZE);    stream_ins_u32_le(s, 0); /* number of bytes to follow */    stream_ins_u32_le(s, CMD_SET_GEOMETRY);    stream_ins_u32_le(s, stream_id);    stream_ins_u32_le(s, xpos);    stream_ins_u32_le(s, ypos);    stream_ins_u32_le(s, width);    stream_ins_u32_le(s, height);    /* insert number of bytes in stream */    len = stream_length(s) - 4;    cptr = s->p;    s->p = s->data;    stream_ins_u32_le(s, len);    s->p = cptr;    /* write data to virtual channel */    rv = xrdpvr_write_to_client(channel, s);    stream_free(s);    return rv;}

voidbgp_zebra_init (void){  /* Set default values. */  zclient = zclient_new ();  zclient_init (zclient, ZEBRA_ROUTE_BGP);  zclient->router_id_update = bgp_router_id_update;  zclient->interface_add = bgp_interface_add;  zclient->interface_delete = bgp_interface_delete;  zclient->interface_address_add = bgp_interface_address_add;  zclient->interface_address_delete = bgp_interface_address_delete;  zclient->ipv4_route_add = zebra_read_ipv4;  zclient->ipv4_route_delete = zebra_read_ipv4;  zclient->interface_up = bgp_interface_up;  zclient->interface_down = bgp_interface_down;#ifdef HAVE_IPV6  zclient->ipv6_route_add = zebra_read_ipv6;  zclient->ipv6_route_delete = zebra_read_ipv6;#endif /* HAVE_IPV6 */  /* Interface related init. */  if_init ();  bgp_nexthop_buf = stream_new(BGP_NEXTHOP_BUF_SIZE);}

tbool rpch_in_send_ping(rdpRpch* rpch){	STREAM* pdu = stream_new(20);	uint8 rpc_vers = 0x05;	uint8 rpc_vers_minor = 0x00;	uint8 ptype = PTYPE_RTS;	uint8 pfc_flags = PFC_FIRST_FRAG | PFC_LAST_FRAG;	uint32 packet_drep = 0x00000010;	uint16 frag_length = 56;	uint16 auth_length = 0;	uint32 call_id = 0x00000000;	uint16 flags = 0x0001;	uint16 num_commands = 0x0000;	stream_write_uint8(pdu, rpc_vers);	stream_write_uint8(pdu, rpc_vers_minor);	stream_write_uint8(pdu, ptype);	stream_write_uint8(pdu, pfc_flags);	stream_write_uint32(pdu, packet_drep);	stream_write_uint16(pdu, frag_length);	stream_write_uint16(pdu, auth_length);	stream_write_uint32(pdu, call_id);	stream_write_uint16(pdu, flags);	stream_write_uint16(pdu, num_commands);	rpch_in_write(rpch, pdu->data, pdu->p - pdu->data);	stream_free(pdu);	return true;}

BOOL certificate_read_server_certificate(rdpCertificate* certificate, BYTE* server_cert, int length){	STREAM* s;	UINT32 dwVersion;	if (length < 1)	{		DEBUG_CERTIFICATE("null server certificate/n");		return FALSE;	}	s = stream_new(0);	stream_attach(s, server_cert, length);	stream_read_UINT32(s, dwVersion); /* dwVersion (4 bytes) */	switch (dwVersion & CERT_CHAIN_VERSION_MASK)	{		case CERT_CHAIN_VERSION_1:			certificate_read_server_proprietary_certificate(certificate, s);			break;		case CERT_CHAIN_VERSION_2:			certificate_read_server_x509_certificate_chain(certificate, s);			break;		default:			printf("invalid certificate chain version:%d/n", dwVersion & CERT_CHAIN_VERSION_MASK);			break;	}	free(s);	return TRUE;}

// Wrap streams in Ruby objectsVALUE streams_to_ruby_array(VALUE self, AVFormatContext * format) {	VALUE streams = rb_ary_new();	unsigned i = 0;	for(; i < format->nb_streams; ++i) {		switch (format->streams[i]->codec->codec_type) {			case AVMEDIA_TYPE_VIDEO: {				// Video stream				rb_ary_push(streams, video_stream_new(self, format->streams[i]));				break;			}			case AVMEDIA_TYPE_AUDIO: {				// Audio stream				rb_ary_push(streams, audio_stream_new(self, format->streams[i]));				break;			}			default: {				// All other streams				rb_ary_push(streams, stream_new(self, format->streams[i]));				break;			}		}	}	return streams;}

static int drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s){	STREAM* data_out;	int error;	DEBUG_DVC("Sp=%d cbChId=%d", Sp, cbChId);	stream_seek(s, 1); /* pad */	stream_read_UINT16(s, drdynvc->version);	if (drdynvc->version == 2)	{		stream_read_UINT16(s, drdynvc->PriorityCharge0);		stream_read_UINT16(s, drdynvc->PriorityCharge1);		stream_read_UINT16(s, drdynvc->PriorityCharge2);		stream_read_UINT16(s, drdynvc->PriorityCharge3);	}	data_out = stream_new(4);	stream_write_UINT16(data_out, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */	stream_write_UINT16(data_out, drdynvc->version);	error = svc_plugin_send((rdpSvcPlugin*) drdynvc, data_out);	if (error != CHANNEL_RC_OK)	{		DEBUG_WARN("VirtualChannelWrite failed %d", error);		return 1;	}	drdynvc->channel_error = error;	return 0;}

int credssp_authenticate(rdpCredssp* credssp){    NTLMSSP* ntlmssp = credssp->ntlmssp;    STREAM* s = stream_new(0);    uint8* negoTokenBuffer = (uint8*) xmalloc(2048);    if (credssp_ntlmssp_init(credssp) == 0)        return 0;    if (credssp_get_public_key(credssp) == 0)        return 0;    /* NTLMSSP NEGOTIATE MESSAGE */    s->p = s->data = negoTokenBuffer;    ntlmssp_send(ntlmssp, s);    credssp->negoToken.data = s->data;    credssp->negoToken.length = s->p - s->data;    credssp_send(credssp, &credssp->negoToken, NULL, NULL);    /* NTLMSSP CHALLENGE MESSAGE */    if (credssp_recv(credssp, &credssp->negoToken, NULL, NULL) < 0)        return -1;    s->p = s->data = credssp->negoToken.data;    ntlmssp_recv(ntlmssp, s);    freerdp_blob_free(&credssp->negoToken);    /* NTLMSSP AUTHENTICATE MESSAGE */    s->p = s->data = negoTokenBuffer;    ntlmssp_send(ntlmssp, s);    /* The last NTLMSSP message is sent with the encrypted public key */    credssp->negoToken.data = s->data;    credssp->negoToken.length = s->p - s->data;    credssp_encrypt_public_key(credssp, &credssp->pubKeyAuth);    credssp_send(credssp, &credssp->negoToken, NULL, &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);    xfree(s);    return 1;}

boolean rts_send_keep_alive_pdu(rdpRpc* rpc){	STREAM* s;	RTS_PDU_HEADER header;	header.rpc_vers = 5;	header.rpc_vers_minor = 0;	header.ptype = PTYPE_RTS;	header.pfc_flags = PFC_FIRST_FRAG | PFC_LAST_FRAG;	header.packed_drep[0] = 0x10;	header.packed_drep[1] = 0x00;	header.packed_drep[2] = 0x00;	header.packed_drep[3] = 0x00;	header.frag_length = 28;	header.auth_length = 0;	header.call_id = 0;	header.flags = 2;	header.numberOfCommands = 1;	DEBUG_RPC("Sending Keep-Alive RTS PDU");	s = stream_new(header.frag_length);	rts_pdu_header_write(s, &header); /* RTS Header (20 bytes) */	rts_client_keepalive_command_write(s, 0x00007530); /* ClientKeepalive (8 bytes) */	stream_seal(s);	rpc_in_write(rpc, s->data, s->size);	stream_free(s);	return true;}

KrbAPREQ* krb_apreq_new(KRB_CONTEXT* krb_ctx, Ticket* ticket, Authenticator* krb_auth){	KrbAPREQ* krb_apreq;	STREAM* as;	rdpBlob msg;	rdpBlob* encmsg;	uint32 len;	as = stream_new(1024);	stream_seek(as, 1023);	krb_apreq = xnew(KrbAPREQ);	krb_apreq->pvno = KRB_VERSION;	krb_apreq->type = KRB_TAG_APREQ;	krb_apreq->ap_options = 0x00000000 | 0x00000000 | 0x00000000; /* Reserved (bit 31), Use session Key (bit 30), Mututal Required (bit 29) */	krb_apreq->ticket = ticket;	if (krb_auth != NULL)	{		len = krb_encode_authenticator(as, krb_auth);		msg.data = as->p;		msg.length = len;		encmsg = crypto_kdcmsg_encrypt(&msg, krb_ctx->askey, 7); /* RFC4757 section 3 for msgtype (T=7) */		krb_apreq->enc_auth.enctype = krb_ctx->askey->enctype;		krb_apreq->enc_auth.kvno = -1;		krb_apreq->enc_auth.encblob.data = encmsg->data;		krb_apreq->enc_auth.encblob.length =  encmsg->length;		xfree(encmsg);	}		stream_free(as);		return krb_apreq;}

/* Finish initializing a session from a connection, or kills it if the * connection shows and error. Returns <0 if the connection was killed. */static int conn_complete_session(struct connection *conn){	struct task *task = conn->owner;	struct session *sess = task->context;	struct stream *strm;	if (conn->flags & CO_FL_ERROR)		goto fail;	/* we want the connection handler to notify the stream interface about updates. */	conn->flags |= CO_FL_WAKE_DATA;	/* if logs require transport layer information, note it on the connection */	if (sess->fe->to_log & LW_XPRT)		conn->flags |= CO_FL_XPRT_TRACKED;	session_count_new(sess);	task->process = sess->listener->handler;	strm = stream_new(sess, task, &conn->obj_type);	if (!strm)		goto fail;	strm->target        = sess->listener->default_target;	strm->req.analysers = sess->listener->analysers;	conn->flags &= ~CO_FL_INIT_DATA;	return 0; fail:	session_kill_embryonic(sess);	return -1;}

void test_ber_write_length(void){	STREAM *s1, *s2;	s1 = stream_new(sizeof(ber_length_expected_1));	s2 = stream_new(sizeof(ber_length_expected_2));	ber_write_length(s1, 64);	ASSERT_STREAM(s1, (uint8*) ber_length_expected_1, sizeof(ber_length_expected_1));	ber_write_length(s2, 404);	ASSERT_STREAM(s2, (uint8*) ber_length_expected_2, sizeof(ber_length_expected_2));	stream_free(s1);	stream_free(s2);}

s32 ldp_accept(struct thread * t){	s32 fd ;	union sockunion su ;	struct ldp_peer * peer ;	s32 sock = THREAD_FD(t);	struct ldp * ldp = THREAD_ARG(t);		ldp->t_accept = NULL ;	THREAD_READ_ON(master, ldp->t_accept, ldp_accept, ldp, sock);	fd = sockunion_accept(sock, &su);	if( fd <= 0 ) 		return -1 ;	peer = ldp_peer_new();	if( NULL == peer )	{		close(fd);		return -1 ;	}		peer->state = ACCEPT_PEER ;	peer->fd = fd ;	peer->ldp = ldp;	peer->transport = su.sin.sin_addr.s_addr;	peer->input = stream_new(LDP_MAX_PDU_LEN);		listnode_add(ldp->accepts, peer);	LDP_FSM_EVENT(peer, ConnectSuccess);	return 0 ;}

/** * set video format * * @param  channel    opaque handle returned by WTSVirtualChannelOpenEx * @param  stream_id  unique identification number for this stream * * @return  0 on success, -1 on error *****************************************************************************/intxrdpvr_set_video_format(void *channel, uint32_t stream_id, int format,                        int width, int height){    STREAM  *s;    char    *cptr;    int     rv;    int     len;    width = (width + 15) & ~15;    stream_new(s, MAX_PDU_SIZE);    stream_ins_u32_le(s, 0); /* number of bytes to follow */    stream_ins_u32_le(s, CMD_SET_VIDEO_FORMAT);    stream_ins_u32_le(s, stream_id);    stream_ins_u32_le(s, format);    stream_ins_u32_le(s, width);    stream_ins_u32_le(s, height);    /* insert number of bytes in stream */    len = stream_length(s) - 4;    cptr = s->p;    s->p = s->data;    stream_ins_u32_le(s, len);    s->p = cptr;    /* write data to virtual channel */    rv = xrdpvr_write_to_client(channel, s);    stream_free(s);    return rv;}

/** * send audio data to client * * @param  channel    opaque handle returned by WTSVirtualChannelOpenEx * @param  stream_id  unique identification number for this stream * @param  data_len   number of bytes to send * @param  data       audio data to send * * @return  0 on success, -1 on error *****************************************************************************/intxrdpvr_send_audio_data(void *channel, uint32_t stream_id, uint32_t data_len,                       uint8_t *data){    STREAM  *s;    char    *cptr;    int     rv;    int     len;    //printf("xrdpvr_send_audio_data:/n");    stream_new(s, MAX_PDU_SIZE + data_len);    stream_ins_u32_le(s, 0); /* number of bytes to follow */    stream_ins_u32_le(s, CMD_SEND_AUDIO_DATA);    stream_ins_u32_le(s, stream_id);    stream_ins_u32_le(s, data_len);    stream_ins_byte_array(s, data, data_len);    /* insert number of bytes in stream */    len = stream_length(s) - 4;    cptr = s->p;    s->p = s->data;    stream_ins_u32_le(s, len);    s->p = cptr;    /* write data to virtual channel */    rv = xrdpvr_write_to_client(channel, s);    stream_free(s);    return rv;}

void test_decode(void){	RFX_CONTEXT* context;	uint8 decode_buffer[4096 * 3];	STREAM* s;	s = stream_new(sizeof(y_data) + sizeof(cb_data) + sizeof(cr_data));	stream_write(s, y_data, sizeof(y_data));	stream_write(s, cb_data, sizeof(cb_data));	stream_write(s, cr_data, sizeof(cr_data));	stream_set_pos(s, 0);	context = rfx_context_new();	context->mode = RLGR3;	rfx_context_set_pixel_format(context, RFX_PIXEL_FORMAT_RGB);	rfx_decode_rgb(context, s,		sizeof(y_data), test_quantization_values,		sizeof(cb_data), test_quantization_values,		sizeof(cr_data), test_quantization_values,		decode_buffer);	rfx_context_free(context);	stream_free(s);	dump_ppm_image(decode_buffer);}

BOOL rts_send_ping_pdu(rdpRpc* rpc){	STREAM* s;	RTS_PDU_HEADER header;	header.rpc_vers = 5;	header.rpc_vers_minor = 0;	header.ptype = PTYPE_RTS;	header.pfc_flags = PFC_FIRST_FRAG | PFC_LAST_FRAG;	header.packed_drep[0] = 0x10;	header.packed_drep[1] = 0x00;	header.packed_drep[2] = 0x00;	header.packed_drep[3] = 0x00;	header.frag_length = 20;	header.auth_length = 0;	header.call_id = 0;	header.flags = 1;	header.numberOfCommands = 0;	DEBUG_RPC("Sending Ping RTS PDU");	s = stream_new(header.frag_length);	rts_pdu_header_write(s, &header); /* RTS Header (20 bytes) */	stream_seal(s);	rpc_in_write(rpc, s->data, s->size);	stream_free(s);	return TRUE;}

void credssp_read_ts_credentials(rdpCredssp* credssp, PSecBuffer ts_credentials){	STREAM* s;	int length;	int ts_password_creds_length;	s = stream_new(0);	stream_attach(s, ts_credentials->pvBuffer, ts_credentials->cbBuffer);	/* TSCredentials (SEQUENCE) */	ber_read_sequence_tag(s, &length);	/* [0] credType (INTEGER) */	ber_read_contextual_tag(s, 0, &length, TRUE);	ber_read_integer(s, NULL);	/* [1] credentials (OCTET STRING) */	ber_read_contextual_tag(s, 1, &length, TRUE);	ber_read_octet_string_tag(s, &ts_password_creds_length);	credssp_read_ts_password_creds(credssp, s);	stream_detach(s);	stream_free(s);}

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

static void skel_process_receive(rdpSvcPlugin* plugin, STREAM* data_in){	skelPlugin* skel = (skelPlugin*)plugin;	STREAM* data_out;	int bytes;	printf("skel_process_receive:/n");	if (skel == NULL)	{		printf("skel_process_receive: skel 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("skel_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("skel_process_receive: sending bytes %d/n", bytes);		svc_plugin_send(plugin, data_out);	}	stream_free(data_in);}

static void sample_process_receive(rdpSvcPlugin* plugin, wStream* data_in){	int bytes;	wStream* data_out;	samplePlugin* sample = (samplePlugin*) plugin;	fprintf(stderr, "sample_process_receive:/n");	if (!sample)	{		fprintf(stderr, "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);	fprintf(stderr, "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);		fprintf(stderr, "sample_process_receive: sending bytes %d/n", bytes);		svc_plugin_send(plugin, data_out);	}	stream_free(data_in);}

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

intmain (void){  struct stream *s;    s = stream_new (1024);    stream_putc (s, ham);  stream_putw (s, ham);  stream_putl (s, ham);  stream_putq (s, ham);    print_stream (s);    stream_resize (s, stream_get_endp (s));    print_stream (s);    printf ("c: 0x%hhx/n", stream_getc (s));  printf ("w: 0x%hx/n", stream_getw (s));  printf ("l: 0x%x/n", stream_getl (s));  printf ("q: 0x%" PRIu64 "/n", stream_getq (s));    return 0;}

static void rdpdr_send_client_name_request(rdpdrPlugin* rdpdr){	char* s;	STREAM* data_out;	UNICONV* uniconv;	size_t computerNameLenW;	uniconv = freerdp_uniconv_new();	if (!rdpdr->computerName[0])		gethostname(rdpdr->computerName, sizeof(rdpdr->computerName) - 1);	s = freerdp_uniconv_out(uniconv, rdpdr->computerName, &computerNameLenW);	data_out = stream_new(16 + computerNameLenW + 2);	stream_write_uint16(data_out, RDPDR_CTYP_CORE);	stream_write_uint16(data_out, PAKID_CORE_CLIENT_NAME);	stream_write_uint32(data_out, 1); /* unicodeFlag, 0 for ASCII and 1 for Unicode */	stream_write_uint32(data_out, 0); /* codePage, must be set to zero */	stream_write_uint32(data_out, computerNameLenW + 2); /* computerNameLen, including null terminator */	stream_write(data_out, s, computerNameLenW);	stream_write_uint16(data_out, 0); /* null terminator */	xfree(s);	freerdp_uniconv_free(uniconv);	svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);}

STREAM* rail_pdu_init(int length){	STREAM* s;	s = stream_new(length + RAIL_PDU_HEADER_LENGTH);	stream_seek(s, RAIL_PDU_HEADER_LENGTH);	return s;}

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

boolean certificate_read_server_certificate(rdpCertificate* certificate, uint8* server_cert, int length){    STREAM* s;    uint32 dwVersion;    s = stream_new(0);    s->p = s->data = server_cert;    if (length < 1)    {        printf("null server certificate/n");        return False;    }    stream_read_uint32(s, dwVersion); /* dwVersion (4 bytes) */    switch (dwVersion & CERT_CHAIN_VERSION_MASK)    {    case CERT_CHAIN_VERSION_1:        certificate_read_server_proprietary_certificate(certificate, s);        break;    case CERT_CHAIN_VERSION_2:        certificate_read_server_x509_certificate_chain(certificate, s);        break;    default:        printf("invalid certificate chain version:%d/n", dwVersion & CERT_CHAIN_VERSION_MASK);        break;    }    xfree(s);    return True;}

intxrdpvr_send_init(void *channel){    STREAM  *s;    char    *cptr;    int     rv;    int     len;    printf("xrdpvr_send_init:/n");    stream_new(s, MAX_BUFSIZE);    stream_ins_u32_le(s, 0); /* number of bytes to follow */    stream_ins_u32_le(s, CMD_INIT_XRDPVR);    /* insert number of bytes in stream */    len = stream_length(s) - 4;    cptr = s->p;    s->p = s->data;    stream_ins_u32_le(s, len);    s->p = cptr;    /* write data to virtual channel */    rv = xrdpvr_write_to_client(channel, s);    stream_free(s);    return rv;}

/** * write set volume to a xrdpvr client * * @param  channel  opaque handle returned by WTSVirtualChannelOpenEx * @param  volume   volume 0x0000 to 0xffff * * @return 0 on success, -1 on failure ******************************************************************************/intxrdpvr_set_volume(void *channel, int volume){    STREAM  *s;    char    *cptr;    int     rv;    int     len;    stream_new(s, MAX_BUFSIZE);    stream_ins_u32_le(s, 0); /* number of bytes to follow */    stream_ins_u32_le(s, CMD_SET_VOLUME);    stream_ins_u32_le(s, volume);    /* insert number of bytes in stream */    len = stream_length(s) - 4;    cptr = s->p;    s->p = s->data;    stream_ins_u32_le(s, len);    s->p = cptr;    /* write data to virtual channel */    rv = xrdpvr_write_to_client(channel, s);    stream_free(s);    return rv;}

void dev_redir_send_server_core_cap_req(){    struct stream *s;    int            bytes;    stream_new(s, 1024);    /* setup header */    stream_wr_u16_le(s, RDPDR_CTYP_CORE);    stream_wr_u16_le(s, PAKID_CORE_SERVER_CAPABILITY);    stream_wr_u16_le(s, 5);                /* num of caps we are sending     */    stream_wr_u16_le(s, 0x0000);           /* padding                        */    /* setup general capability */    stream_wr_u16_le(s, CAP_GENERAL_TYPE); /* CapabilityType                 */    stream_wr_u16_le(s, 44);               /* CapabilityLength - len of this */                                           /* CAPABILITY_SET in bytes, inc   */                                           /* the header                     */    stream_wr_u32_le(s, 2);                /* Version                        */    stream_wr_u32_le(s, 2);                /* O.S type                       */    stream_wr_u32_le(s, 0);                /* O.S version                    */    stream_wr_u16_le(s, 1);                /* protocol major version         */    stream_wr_u16_le(s, g_client_rdp_version); /* protocol minor version     */    stream_wr_u32_le(s, 0xffff);           /* I/O code 1                     */    stream_wr_u32_le(s, 0);                /* I/O code 2                     */    stream_wr_u32_le(s, 7);                /* Extended PDU                   */    stream_wr_u32_le(s, 0);                /* extra flags 1                  */    stream_wr_u32_le(s, 0);                /* extra flags 2                  */    stream_wr_u32_le(s, 2);                /* special type device cap        */    /* setup printer capability */    stream_wr_u16_le(s, CAP_PRINTER_TYPE);    stream_wr_u16_le(s, 8);    stream_wr_u32_le(s, 1);    /* setup serial port capability */    stream_wr_u16_le(s, CAP_PORT_TYPE);    stream_wr_u16_le(s, 8);    stream_wr_u32_le(s, 1);    /* setup file system capability */    stream_wr_u16_le(s, CAP_DRIVE_TYPE);   /* CapabilityType                 */    stream_wr_u16_le(s, 8);                /* CapabilityLength - len of this */                                           /* CAPABILITY_SET in bytes, inc   */                                           /* the header                     */    stream_wr_u32_le(s, 2);                /* Version                        */    /* setup smart card capability */    stream_wr_u16_le(s, CAP_SMARTCARD_TYPE);    stream_wr_u16_le(s, 8);    stream_wr_u32_le(s, 1);    /* send to client */    bytes = stream_len(s);    send_channel_data(g_rdpdr_chan_id, s->data, bytes);    stream_free(s);}

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