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

BOOL rdp_read_client_time_zone(STREAM* s, rdpSettings* settings){	char* str;	TIME_ZONE_INFO* clientTimeZone;	if (stream_get_left(s) < 172)		return FALSE;	clientTimeZone = settings->ClientTimeZone;	stream_read_UINT32(s, clientTimeZone->bias); /* Bias */	/* standardName (64 bytes) */	ConvertFromUnicode(CP_UTF8, 0, (WCHAR*) stream_get_tail(s), 64 / 2, &str, 0, NULL, NULL);	stream_seek(s, 64);	strncpy(clientTimeZone->standardName, str, sizeof(clientTimeZone->standardName));	free(str);	rdp_read_system_time(s, &clientTimeZone->standardDate); /* StandardDate */	stream_read_UINT32(s, clientTimeZone->standardBias); /* StandardBias */	/* daylightName (64 bytes) */	ConvertFromUnicode(CP_UTF8, 0, (WCHAR*) stream_get_tail(s), 64 / 2, &str, 0, NULL, NULL);	stream_seek(s, 64);	strncpy(clientTimeZone->daylightName, str, sizeof(clientTimeZone->daylightName));	free(str);	rdp_read_system_time(s, &clientTimeZone->daylightDate); /* DaylightDate */	stream_read_UINT32(s, clientTimeZone->daylightBias); /* DaylightBias */	return TRUE;}

void cliprdr_process_format_list_event(cliprdrPlugin* cliprdr, FRDP_CB_FORMAT_LIST_EVENT* cb_event){	STREAM* data_out;	int i;	data_out = cliprdr_packet_new(CB_FORMAT_LIST, 0, 36 * cb_event->num_formats);	for (i = 0; i < cb_event->num_formats; i++)	{		stream_write_uint32(data_out, cb_event->formats[i]);		switch (cb_event->formats[i])		{			case CB_FORMAT_HTML:				memcpy(stream_get_tail(data_out), CFSTR_HTML, sizeof(CFSTR_HTML));				break;			case CB_FORMAT_PNG:				memcpy(stream_get_tail(data_out), CFSTR_PNG, sizeof(CFSTR_PNG));				break;			case CB_FORMAT_JPEG:				memcpy(stream_get_tail(data_out), CFSTR_JPEG, sizeof(CFSTR_JPEG));				break;			case CB_FORMAT_GIF:				memcpy(stream_get_tail(data_out), CFSTR_GIF, sizeof(CFSTR_GIF));				break;		}		stream_seek(data_out, 32);	}	cliprdr_packet_send(cliprdr, data_out);}

boolean rdp_read_client_time_zone(STREAM* s, rdpSettings* settings){	char* str;	TIME_ZONE_INFO* clientTimeZone;	if (stream_get_left(s) < 172)		return false;	clientTimeZone = settings->client_time_zone;	stream_read_uint32(s, clientTimeZone->bias); /* Bias */	/* standardName (64 bytes) */	str = freerdp_uniconv_in(settings->uniconv, stream_get_tail(s), 64);	stream_seek(s, 64);	strncpy(clientTimeZone->standardName, str, sizeof(clientTimeZone->standardName));	xfree(str);	rdp_read_system_time(s, &clientTimeZone->standardDate); /* StandardDate */	stream_read_uint32(s, clientTimeZone->standardBias); /* StandardBias */	/* daylightName (64 bytes) */	str = freerdp_uniconv_in(settings->uniconv, stream_get_tail(s), 64);	stream_seek(s, 64);	strncpy(clientTimeZone->daylightName, str, sizeof(clientTimeZone->daylightName));	xfree(str);	rdp_read_system_time(s, &clientTimeZone->daylightDate); /* DaylightDate */	stream_read_uint32(s, clientTimeZone->daylightBias); /* DaylightBias */	return true;}

int transport_read(rdpTransport* transport, STREAM* s){	int status = -1;	while (True)	{		if (transport->layer == TRANSPORT_LAYER_TLS)			status = tls_read(transport->tls, stream_get_tail(s), stream_get_left(s));		else if (transport->layer == TRANSPORT_LAYER_TCP)			status = tcp_read(transport->tcp, stream_get_tail(s), stream_get_left(s));		if (status == 0 && transport->blocking)		{			freerdp_usleep(transport->usleep_interval);			continue;		}		break;	}#ifdef WITH_DEBUG_TRANSPORT	if (status > 0)	{		printf("Local < Remote/n");		freerdp_hexdump(s->data, status);	}#endif	return status;}

void rfx_decode_rgb(RFX_CONTEXT* context, STREAM* data_in,	int y_size, const uint32 * y_quants,	int cb_size, const uint32 * cb_quants,	int cr_size, const uint32 * cr_quants, uint8* rgb_buffer){	PROFILER_ENTER(context->priv->prof_rfx_decode_rgb);	rfx_decode_component(context, y_quants, stream_get_tail(data_in), y_size, context->priv->y_r_buffer); /* YData */	stream_seek(data_in, y_size);	rfx_decode_component(context, cb_quants, stream_get_tail(data_in), cb_size, context->priv->cb_g_buffer); /* CbData */	stream_seek(data_in, cb_size);	rfx_decode_component(context, cr_quants, stream_get_tail(data_in), cr_size, context->priv->cr_b_buffer); /* CrData */	stream_seek(data_in, cr_size);	PROFILER_ENTER(context->priv->prof_rfx_decode_ycbcr_to_rgb);		context->decode_ycbcr_to_rgb(context->priv->y_r_buffer, context->priv->cb_g_buffer, context->priv->cr_b_buffer);	PROFILER_EXIT(context->priv->prof_rfx_decode_ycbcr_to_rgb);	PROFILER_ENTER(context->priv->prof_rfx_decode_format_rgb);		rfx_decode_format_rgb(context->priv->y_r_buffer, context->priv->cb_g_buffer, context->priv->cr_b_buffer,			context->pixel_format, rgb_buffer);	PROFILER_EXIT(context->priv->prof_rfx_decode_format_rgb);		PROFILER_EXIT(context->priv->prof_rfx_decode_rgb);}

void cliprdr_process_format_list(cliprdrPlugin* cliprdr, STREAM* data_in, uint32 dataLen){	FRDP_CB_FORMAT_LIST_EVENT* cb_event;	uint32 format;	int num_formats;	int supported;	int i;	cb_event = (FRDP_CB_FORMAT_LIST_EVENT*)freerdp_event_new(FRDP_EVENT_CLASS_CLIPRDR,		FRDP_EVENT_TYPE_CB_FORMAT_LIST, NULL, NULL);	num_formats = dataLen / 36;	cb_event->formats = (uint32*)xmalloc(sizeof(uint32) * num_formats);	cb_event->num_formats = 0;	if (num_formats * 36 != dataLen)		DEBUG_WARN("dataLen %d not devided by 36!", dataLen);	for (i = 0; i < num_formats; i++)	{		stream_read_uint32(data_in, format);		supported = 1;		switch (format)		{			case CB_FORMAT_TEXT:			case CB_FORMAT_DIB:			case CB_FORMAT_UNICODETEXT:				break;			default:				if (memcmp(stream_get_tail(data_in), CFSTR_HTML, sizeof(CFSTR_HTML)) == 0)				{					format = CB_FORMAT_HTML;					break;				}				if (memcmp(stream_get_tail(data_in), CFSTR_PNG, sizeof(CFSTR_PNG)) == 0)				{					format = CB_FORMAT_PNG;					break;				}				if (memcmp(stream_get_tail(data_in), CFSTR_JPEG, sizeof(CFSTR_JPEG)) == 0)				{					format = CB_FORMAT_JPEG;					break;				}				if (memcmp(stream_get_tail(data_in), CFSTR_GIF, sizeof(CFSTR_GIF)) == 0)				{					format = CB_FORMAT_GIF;					break;				}				supported = 0;				break;		}		stream_seek(data_in, 32);		if (supported)			cb_event->formats[cb_event->num_formats++] = format;	}	svc_plugin_send_event((rdpSvcPlugin*)cliprdr, (FRDP_EVENT*)cb_event);	cliprdr_send_format_list_response(cliprdr);}

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

static BOOL audin_server_recv_data(audin_server* audin, STREAM* s, UINT32 length){	rdpsndFormat* format;	int sbytes_per_sample;	int sbytes_per_frame;	BYTE* src;	int size;	int frames;	if (audin->context.selected_client_format < 0)		return FALSE;	format = &audin->context.client_formats[audin->context.selected_client_format];	if (format->wFormatTag == 2)	{		audin->dsp_context->decode_ms_adpcm(audin->dsp_context,			stream_get_tail(s), length, format->nChannels, format->nBlockAlign);		size = audin->dsp_context->adpcm_size;		src = audin->dsp_context->adpcm_buffer;		sbytes_per_sample = 2;		sbytes_per_frame = format->nChannels * 2;	}	else if (format->wFormatTag == 0x11)	{		audin->dsp_context->decode_ima_adpcm(audin->dsp_context,			stream_get_tail(s), length, format->nChannels, format->nBlockAlign);		size = audin->dsp_context->adpcm_size;		src = audin->dsp_context->adpcm_buffer;		sbytes_per_sample = 2;		sbytes_per_frame = format->nChannels * 2;	}	else	{		size = length;		src = stream_get_tail(s);		sbytes_per_sample = format->wBitsPerSample / 8;		sbytes_per_frame = format->nChannels * sbytes_per_sample;	}	if (format->nSamplesPerSec == audin->context.dst_format.nSamplesPerSec && format->nChannels == audin->context.dst_format.nChannels)	{		frames = size / sbytes_per_frame;	}	else	{		audin->dsp_context->resample(audin->dsp_context, src, sbytes_per_sample,			format->nChannels, format->nSamplesPerSec, size / sbytes_per_frame,			audin->context.dst_format.nChannels, audin->context.dst_format.nSamplesPerSec);		frames = audin->dsp_context->resampled_frames;		src = audin->dsp_context->resampled_buffer;	}	IFCALL(audin->context.ReceiveSamples, &audin->context, src, frames);	return TRUE;}

boolean certificate_read_server_proprietary_certificate(rdpCertificate* certificate, STREAM* s){	uint32 dwSigAlgId;	uint32 dwKeyAlgId;	uint32 wPublicKeyBlobType;	uint32 wPublicKeyBlobLen;	uint32 wSignatureBlobType;	uint32 wSignatureBlobLen;	uint8* sigdata;	int sigdatalen;	/* -4, because we need to include dwVersion */	sigdata = stream_get_tail(s) - 4;	stream_read_uint32(s, dwSigAlgId);	stream_read_uint32(s, dwKeyAlgId);	if (!(dwSigAlgId == SIGNATURE_ALG_RSA && dwKeyAlgId == KEY_EXCHANGE_ALG_RSA))	{		printf("certificate_read_server_proprietary_certificate: parse error 1/n");		return false;	}	stream_read_uint16(s, wPublicKeyBlobType);	if (wPublicKeyBlobType != BB_RSA_KEY_BLOB)	{		printf("certificate_read_server_proprietary_certificate: parse error 2/n");		return false;	}	stream_read_uint16(s, wPublicKeyBlobLen);	if (!certificate_process_server_public_key(certificate, s, wPublicKeyBlobLen))	{		printf("certificate_read_server_proprietary_certificate: parse error 3/n");		return false;	}	sigdatalen = stream_get_tail(s) - sigdata;	stream_read_uint16(s, wSignatureBlobType);	if (wSignatureBlobType != BB_RSA_SIGNATURE_BLOB)	{		printf("certificate_read_server_proprietary_certificate: parse error 4/n");		return false;	}	stream_read_uint16(s, wSignatureBlobLen);	if (wSignatureBlobLen != 72)	{		printf("certificate_process_server_public_signature: invalid signature length (got %d, expected %d)/n", wSignatureBlobLen, 64);		return false;	}	if (!certificate_process_server_public_signature(certificate, sigdata, sigdatalen, s, wSignatureBlobLen))	{		printf("certificate_read_server_proprietary_certificate: parse error 5/n");		return false;	}	return true;}

int transport_write(rdpTransport* transport, STREAM* s){	int status = -1;	int length;	int sent = 0;	length = stream_get_length(s);	stream_set_pos(s, 0);#ifdef WITH_DEBUG_TRANSPORT	if (length > 0)	{		printf("Local > Remote/n");		freerdp_hexdump(s->data, length);	}#endif	while (sent < length)	{		if (transport->layer == TRANSPORT_LAYER_TLS)			status = tls_write(transport->tls, stream_get_tail(s), length);		else if (transport->layer == TRANSPORT_LAYER_TCP)			status = tcp_write(transport->tcp, stream_get_tail(s), length);		if (status < 0)			break; /* error occurred */		if (status == 0)		{			/* blocking while sending */			freerdp_usleep(transport->usleep_interval);			/* 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)					wait_obj_set(transport->recv_event);			}		}		sent += 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;}

intrfx_encode_rgb(struct rfxencode *enc, char *rgb_data,               int width, int height, int stride_bytes,               const int *y_quants, const int *cb_quants, const int *cr_quants,               STREAM *data_out, int *y_size, int *cb_size, int *cr_size){    uint8 *y_r_buffer;    uint8 *cb_g_buffer;    uint8 *cr_b_buffer;    y_r_buffer = enc->y_r_buffer;    cb_g_buffer = enc->cb_g_buffer;    cr_b_buffer = enc->cr_b_buffer;    if (rfx_encode_format_rgb(rgb_data, width, height, stride_bytes,                              enc->format,                              y_r_buffer, cb_g_buffer, cr_b_buffer) != 0)    {        return 1;    }    if (rfx_encode_rgb_to_ycbcr(y_r_buffer, cb_g_buffer, cr_b_buffer) != 0)    {        return 1;    }    if (enc->rfx_encode(enc, y_quants, y_r_buffer,                        stream_get_tail(data_out),                        stream_get_left(data_out),                        y_size) != 0)    {        return 1;    }    LLOGLN(10, ("rfx_encode_rgb: y_size %d", *y_size));    stream_seek(data_out, *y_size);    if (enc->rfx_encode(enc, cb_quants, cb_g_buffer,                        stream_get_tail(data_out),                        stream_get_left(data_out),                        cb_size) != 0)    {        return 1;    }    LLOGLN(10, ("rfx_encode_rgb: cb_size %d", *cb_size));    stream_seek(data_out, *cb_size);    if (enc->rfx_encode(enc, cr_quants, cr_b_buffer,                        stream_get_tail(data_out),                        stream_get_left(data_out),                        cr_size) != 0)    {        return 1;    }    LLOGLN(10, ("rfx_encode_rgb: cr_size %d", *cr_size));    stream_seek(data_out, *cr_size);    return 0;}

static void printer_process_irp_write(PRINTER_DEVICE* printer_dev, IRP* irp){    UINT32 Length;    UINT64 Offset;    rdpPrintJob* printjob = NULL;    stream_read_UINT32(irp->input, Length);    stream_read_UINT64(irp->input, Offset);    stream_seek(irp->input, 20); /* Padding */    if (printer_dev->printer != NULL)        printjob = printer_dev->printer->FindPrintJob(printer_dev->printer, irp->FileId);    if (printjob == NULL)    {        irp->IoStatus = STATUS_UNSUCCESSFUL;        Length = 0;        DEBUG_WARN("printjob id %d not found.", irp->FileId);    }    else    {        printjob->Write(printjob, stream_get_tail(irp->input), Length);        DEBUG_SVC("printjob id %d written %d bytes.", irp->FileId, Length);    }    stream_write_UINT32(irp->output, Length);    stream_write_BYTE(irp->output, 0); /* Padding */    irp->Complete(irp);}

static uint32 sc_output_string(IRP* irp, char *src, tbool wide){	uint8* p;	uint32 len;	p = stream_get_tail(irp->output);	len = strlen(src) + 1;	if (wide)	{		int i;		for (i = 0; i < len; i++ )		{			p[2 * i] = src[i] < 0 ? '?' : src[i];			p[2 * i + 1] = '/0';		}		len *= 2;	}	else	{		memcpy(p, src, len);	}	stream_seek(irp->output, len);	return len;}

static BOOL update_recv_surfcmd_surface_bits(rdpUpdate* update, STREAM* s, UINT32 *length){	int pos;	SURFACE_BITS_COMMAND* cmd = &update->surface_bits_command;	if(stream_get_left(s) < 20)		return FALSE;	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_BYTE(s, cmd->bpp);	stream_seek(s, 2); /* reserved1, reserved2 */	stream_read_BYTE(s, cmd->codecID);	stream_read_UINT16(s, cmd->width);	stream_read_UINT16(s, cmd->height);	stream_read_UINT32(s, cmd->bitmapDataLength);	if(stream_get_left(s) < cmd->bitmapDataLength)		return FALSE;	pos = stream_get_pos(s) + cmd->bitmapDataLength;	cmd->bitmapData = stream_get_tail(s);	IFCALL(update->SurfaceBits, update->context, cmd);	stream_set_pos(s, pos);	*length = 20 + cmd->bitmapDataLength;	return TRUE;}

static void printer_process_irp_write(PRINTER_DEVICE* printer_dev, IRP* irp) {	rdpPrintJob* printjob = NULL;	uint32 Length;	uint64 Offset;	stream_read_uint32(irp->input, Length);	stream_read_uint64(irp->input, Offset);	(void) Offset;	stream_seek(irp->input, 20);	/* Padding */	if (printer_dev->printer != NULL)		printjob = printer_dev->printer->FindPrintJob(printer_dev->printer, irp->FileId);	if (printjob == NULL) {		irp->IoStatus = STATUS_UNSUCCESSFUL;		Length = 0;		log_warning("printjob id %d not found.", irp->FileId);	} else {		printjob->Write(printjob, stream_get_tail(irp->input), Length);		log_debug("printjob id %d written %d bytes.", irp->FileId, Length);	}	stream_write_uint32(irp->output, Length);	stream_write_uint8(irp->output, 0);	/* Padding */	irp->Complete(irp);}

static UINT32 smartcard_output_string(IRP* irp, char* src, BOOL wide){	BYTE* p;	UINT32 len;	p = stream_get_tail(irp->output);	len = strlen(src) + 1;	if (wide)	{		int i;		for (i = 0; i < len; i++ )		{			p[2 * i] = src[i] < 0 ? '?' : src[i];			p[2 * i + 1] = '/0';		}		len *= 2;	}	else	{		memcpy(p, src, len);	}	stream_seek(irp->output, len);	return len;}

int transport_write(rdpTransport* transport, STREAM* s){	int status = -1;	int length;	int sent = 0;	length = stream_get_length(s);	stream_set_pos(s, 0);#ifdef WITH_DEBUG_TRANSPORT	if (length > 0)	{		printf("Client > Server/n");		freerdp_hexdump(s->data, length);	}#endif	while (sent < length)	{		if (transport->layer == TRANSPORT_LAYER_TLS)			status = tls_write(transport->tls, stream_get_tail(s), length);		else if (transport->layer == TRANSPORT_LAYER_TCP)			status = tcp_write(transport->tcp, stream_get_tail(s), length);		if (status < 0)			break; /* error occurred */		if (status == 0)		{			/* blocking while sending */			nanosleep(&transport->ts, NULL);			/* when sending is blocked in nonblocking mode, the receiving buffer should be checked */			if (!transport->blocking)				transport_read_nonblocking(transport);		}		sent += status;		stream_seek(s, status);	}	if (!transport->blocking)		transport_check_fds(transport);	return status;}

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");        freerdp_hexdump(s->data, length);    }#endif    while (length > 0)    {        if (transport->layer == TRANSPORT_LAYER_TLS)            status = tls_write(transport->tls, stream_get_tail(s), length);        else if (transport->layer == TRANSPORT_LAYER_TCP)            status = tcp_write(transport->tcp, stream_get_tail(s), length);        if (status < 0)            break; /* error occurred */        if (status == 0)        {            /* blocking while sending */            freerdp_usleep(transport->usleep_interval);        }        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 cliprdr_process_format_data_response(cliprdrPlugin* cliprdr, STREAM* data_in, uint32 dataLen){	FRDP_CB_DATA_RESPONSE_EVENT* cb_event;	cb_event = (FRDP_CB_DATA_RESPONSE_EVENT*)freerdp_event_new(FRDP_EVENT_TYPE_CB_DATA_RESPONSE, NULL, NULL);	cb_event->size = dataLen;	cb_event->data = (uint8*)xmalloc(dataLen);	memcpy(cb_event->data, stream_get_tail(data_in), dataLen);	svc_plugin_send_event((rdpSvcPlugin*)cliprdr, (FRDP_EVENT*)cb_event);}

static int drdynvc_process_data(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s){	uint32 ChannelId;	ChannelId = drdynvc_read_variable_uint(s, cbChId);	DEBUG_DVC("ChannelId=%d", ChannelId);	return dvcman_receive_channel_data(drdynvc->channel_mgr, ChannelId,		stream_get_tail(s), stream_get_left(s));}

void cliprdr_process_long_format_names(cliprdrPlugin* cliprdr, STREAM* s, uint32 length, uint16 flags){	int allocated_formats = 8;	uint8* end_mark;	CLIPRDR_FORMAT_NAME* format_name;		stream_get_mark(s, end_mark);	end_mark += length;			cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) xmalloc(sizeof(CLIPRDR_FORMAT_NAME) * allocated_formats);	cliprdr->num_format_names = 0;	while (stream_get_left(s) >= 6)	{		uint8* p;		int name_len;				if (cliprdr->num_format_names >= allocated_formats)		{			allocated_formats *= 2;			cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) xrealloc(cliprdr->format_names,					sizeof(CLIPRDR_FORMAT_NAME) * allocated_formats);		}				format_name = &cliprdr->format_names[cliprdr->num_format_names++];		stream_read_uint32(s, format_name->id);				format_name->name = NULL;		format_name->length = 0;		for (p = stream_get_tail(s), name_len = 0; p + 1 < end_mark; p += 2, name_len += 2)		{			if (*((unsigned short*) p) == 0)				break;		}				format_name->name = freerdp_uniconv_in(cliprdr->uniconv, stream_get_tail(s), name_len);		format_name->length = strlen(format_name->name);		stream_seek(s, name_len + 2);	}}

void cliprdr_process_long_format_names(cliprdrPlugin* cliprdr, wStream* s, UINT32 length, UINT16 flags){	int allocated_formats = 8;	BYTE* end_mark;	CLIPRDR_FORMAT_NAME* format_name;		stream_get_mark(s, end_mark);	end_mark += length;			cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) malloc(sizeof(CLIPRDR_FORMAT_NAME) * allocated_formats);	cliprdr->num_format_names = 0;	while (stream_get_left(s) >= 6)	{		BYTE* p;		int name_len;				if (cliprdr->num_format_names >= allocated_formats)		{			allocated_formats *= 2;			cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) realloc(cliprdr->format_names,					sizeof(CLIPRDR_FORMAT_NAME) * allocated_formats);		}				format_name = &cliprdr->format_names[cliprdr->num_format_names++];		stream_read_UINT32(s, format_name->id);				format_name->name = NULL;		format_name->length = 0;		for (p = stream_get_tail(s), name_len = 0; p + 1 < end_mark; p += 2, name_len += 2)		{			if (*((unsigned short*) p) == 0)				break;		}				format_name->length = ConvertFromUnicode(CP_UTF8, 0, (WCHAR*) stream_get_tail(s), name_len / 2, &format_name->name, 0, NULL, NULL);		stream_seek(s, name_len + 2);	}}

static int drdynvc_process_data(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* data_in, int in_length){	int pos;	uint32 ChannelId;	ChannelId = drdynvc_read_variable_uint(data_in, cbChId);	pos = stream_get_pos(data_in);	DEBUG_DVC("ChannelId=%d", ChannelId);	return dvcman_receive_channel_data(drdynvc->channel_mgr, ChannelId,		stream_get_tail(data_in), in_length - pos);}

void cliprdr_process_format_list_event(cliprdrPlugin* cliprdr, RDP_CB_FORMAT_LIST_EVENT* cb_event){	int i;	STREAM* s;	DEBUG_CLIPRDR("Sending Clipboard Format List");	if (cb_event->raw_format_data)	{		s = cliprdr_packet_new(CB_FORMAT_LIST, 0, cb_event->raw_format_data_size);		stream_write(s, cb_event->raw_format_data, cb_event->raw_format_data_size);	}	else	{		s = cliprdr_packet_new(CB_FORMAT_LIST, 0, 36 * cb_event->num_formats);		for (i = 0; i < cb_event->num_formats; i++)		{			stream_write_uint32(s, cb_event->formats[i]);			switch (cb_event->formats[i])			{				case CB_FORMAT_HTML:					memcpy(stream_get_tail(s), CFSTR_HTML, sizeof(CFSTR_HTML));					break;				case CB_FORMAT_PNG:					memcpy(stream_get_tail(s), CFSTR_PNG, sizeof(CFSTR_PNG));					break;				case CB_FORMAT_JPEG:					memcpy(stream_get_tail(s), CFSTR_JPEG, sizeof(CFSTR_JPEG));					break;				case CB_FORMAT_GIF:					memcpy(stream_get_tail(s), CFSTR_GIF, sizeof(CFSTR_GIF));					break;			}			stream_seek(s, 32);		}	}	cliprdr_packet_send(cliprdr, s);}

boolean rdp_read_extended_info_packet(STREAM* s, rdpSettings* settings){	uint16 clientAddressFamily;	uint16 cbClientAddress;	uint16 cbClientDir;	uint16 cbAutoReconnectLen;	stream_read_uint16(s, clientAddressFamily); /* clientAddressFamily */	stream_read_uint16(s, cbClientAddress); /* cbClientAddress */	settings->ipv6 = (clientAddressFamily == ADDRESS_FAMILY_INET6 ? true : false);	if (stream_get_left(s) < cbClientAddress)		return false;	settings->ip_address = freerdp_uniconv_in(settings->uniconv, stream_get_tail(s), cbClientAddress);	stream_seek(s, cbClientAddress);	stream_read_uint16(s, cbClientDir); /* cbClientDir */	if (stream_get_left(s) < cbClientDir)		return false;	if (settings->client_dir)		xfree(settings->client_dir);	settings->client_dir = freerdp_uniconv_in(settings->uniconv, stream_get_tail(s), cbClientDir);	stream_seek(s, cbClientDir);	if (!rdp_read_client_time_zone(s, settings))		return false;	stream_seek_uint32(s); /* clientSessionId, should be set to 0 */	stream_read_uint32(s, settings->performance_flags); /* performanceFlags */	stream_read_uint16(s, cbAutoReconnectLen); /* cbAutoReconnectLen */	if (cbAutoReconnectLen > 0)		return rdp_read_client_auto_reconnect_cookie(s, settings); /* autoReconnectCookie */	/* reserved1 (2 bytes) */	/* reserved2 (2 bytes) */	return true;}

static void wts_read_drdynvc_data(rdpPeerChannel* channel, STREAM* s, uint32 length){	if (channel->dvc_total_length > 0)	{		if (stream_get_length(channel->receive_data) + length > channel->dvc_total_length)		{			channel->dvc_total_length = 0;			printf("wts_read_drdynvc_data: incorrect fragment data, discarded./n");			return;		}		stream_write(channel->receive_data, stream_get_tail(s), length);		if (stream_get_length(channel->receive_data) >= (int) channel->dvc_total_length)		{			wts_queue_receive_data(channel, stream_get_head(channel->receive_data), channel->dvc_total_length);			channel->dvc_total_length = 0;		}	}	else	{		wts_queue_receive_data(channel, stream_get_tail(s), length);	}}

intrfx_encode_yuv(struct rfxencode *enc, char *yuv_data,               int width, int height, int stride_bytes,               const int *y_quants, const int *u_quants, const int *v_quants,               STREAM *data_out, int *y_size, int *u_size, int *v_size){    uint8 *y_buffer;    uint8 *u_buffer;    uint8 *v_buffer;    y_buffer = (uint8 *) yuv_data;    u_buffer = (uint8 *) (yuv_data + RFX_YUV_BTES);    v_buffer = (uint8 *) (yuv_data + RFX_YUV_BTES * 2);    if (enc->rfx_encode(enc, y_quants, y_buffer,                        stream_get_tail(data_out),                        stream_get_left(data_out),                        y_size) != 0)    {        return 1;    }    stream_seek(data_out, *y_size);    if (enc->rfx_encode(enc, u_quants, u_buffer,                        stream_get_tail(data_out),                        stream_get_left(data_out),                        u_size) != 0)    {        return 1;    }    stream_seek(data_out, *u_size);    if (enc->rfx_encode(enc, v_quants, v_buffer,                        stream_get_tail(data_out),                        stream_get_left(data_out),                        v_size) != 0)    {        return 1;    }    stream_seek(data_out, *v_size);    return 0;}

void freerdp_channel_process(freerdp* instance, STREAM* s, uint16 channel_id){	uint32 length;	uint32 flags;	int chunk_length;	stream_read_uint32(s, length);	stream_read_uint32(s, flags);	chunk_length = stream_get_left(s);	IFCALL(instance->ReceiveChannelData, instance,		channel_id, stream_get_tail(s), chunk_length, flags, length);}

void freerdp_channel_peer_process(freerdp_peer* client, STREAM* s, uint16 channel_id){	uint32 length;	uint32 flags;	int chunk_length;	stream_read_uint32(s, length);	stream_read_uint32(s, flags);	chunk_length = stream_get_left(s);	IFCALL(client->ReceiveChannelData, client,		channel_id, stream_get_tail(s), chunk_length, flags, length);}

static int drdynvc_process_create_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s){	int pos;	int error;	UINT32 ChannelId;	STREAM* data_out;	ChannelId = drdynvc_read_variable_uint(s, cbChId);	pos = stream_get_pos(s);	DEBUG_DVC("ChannelId=%d ChannelName=%s", ChannelId, stream_get_tail(s));	error = dvcman_create_channel(drdynvc->channel_mgr, ChannelId, (char*) stream_get_tail(s));	data_out = stream_new(pos + 4);	stream_write_BYTE(data_out, 0x10 | cbChId);	stream_set_pos(s, 1);	stream_copy(data_out, s, pos - 1);		if (error == 0)	{		DEBUG_DVC("channel created");		stream_write_UINT32(data_out, 0);	}	else	{		DEBUG_DVC("no listener");		stream_write_UINT32(data_out, (UINT32)(-1));	}	error = svc_plugin_send((rdpSvcPlugin*) drdynvc, data_out);	if (error != CHANNEL_RC_OK)	{		DEBUG_WARN("VirtualChannelWrite failed %d", error);		return 1;	}	return 0;}