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

static void rfx_compose_message_context(RFX_CONTEXT* context, STREAM* s){	UINT16 properties;	stream_write_UINT16(s, WBT_CONTEXT); /* CodecChannelT.blockType */	stream_write_UINT32(s, 13); /* CodecChannelT.blockLen */	stream_write_BYTE(s, 1); /* CodecChannelT.codecId */	stream_write_BYTE(s, 0); /* CodecChannelT.channelId */	stream_write_BYTE(s, 0); /* ctxId */	stream_write_UINT16(s, CT_TILE_64x64); /* tileSize */	/* properties */	properties = context->flags; /* flags */	properties |= (COL_CONV_ICT << 3); /* cct */	properties |= (CLW_XFORM_DWT_53_A << 5); /* xft */	properties |= ((context->mode == RLGR1 ? CLW_ENTROPY_RLGR1 : CLW_ENTROPY_RLGR3) << 9); /* et */	properties |= (SCALAR_QUANTIZATION << 13); /* qt */	stream_write_UINT16(s, properties);	/* properties in tilesets: note that this has different format from the one in TS_RFX_CONTEXT */	properties = 1; /* lt */	properties |= (context->flags << 1); /* flags */	properties |= (COL_CONV_ICT << 4); /* cct */	properties |= (CLW_XFORM_DWT_53_A << 6); /* xft */	properties |= ((context->mode == RLGR1 ? CLW_ENTROPY_RLGR1 : CLW_ENTROPY_RLGR3) << 10); /* et */	properties |= (SCALAR_QUANTIZATION << 14); /* qt */	context->properties = properties;}

static void rfx_compose_message_codec_versions(RFX_CONTEXT* context, STREAM* s){	stream_write_UINT16(s, WBT_CODEC_VERSIONS); /* BlockT.blockType */	stream_write_UINT32(s, 10); /* BlockT.blockLen */	stream_write_BYTE(s, 1); /* numCodecs */	stream_write_BYTE(s, 1); /* codecs.codecId */	stream_write_UINT16(s, WF_VERSION_1_0); /* codecs.version */}

static void rfx_compose_message_frame_end(RFX_CONTEXT* context, STREAM* s){	stream_check_size(s, 8);	stream_write_UINT16(s, WBT_FRAME_END); /* CodecChannelT.blockType */	stream_write_UINT32(s, 8); /* CodecChannelT.blockLen */	stream_write_BYTE(s, 1); /* CodecChannelT.codecId */	stream_write_BYTE(s, 0); /* CodecChannelT.channelId */}

static void rfx_compose_message_channels(RFX_CONTEXT* context, STREAM* s){	stream_write_UINT16(s, WBT_CHANNELS); /* BlockT.blockType */	stream_write_UINT32(s, 12); /* BlockT.blockLen */	stream_write_BYTE(s, 1); /* numChannels */	stream_write_BYTE(s, 0); /* Channel.channelId */	stream_write_UINT16(s, context->width); /* Channel.width */	stream_write_UINT16(s, context->height); /* Channel.height */}

BOOL nego_send_negotiation_request(rdpNego* nego){	STREAM* s;	int length;	BYTE *bm, *em;	int cookie_length;	s = transport_send_stream_init(nego->transport, 256);	length = TPDU_CONNECTION_REQUEST_LENGTH;	stream_get_mark(s, bm);	stream_seek(s, length);	if (nego->RoutingToken != NULL)	{		stream_write(s, nego->RoutingToken, nego->RoutingTokenLength);		length += nego->RoutingTokenLength;	}	else if (nego->cookie != NULL)	{		cookie_length = strlen(nego->cookie);		if (cookie_length > (int) nego->cookie_max_length)			cookie_length = nego->cookie_max_length;		stream_write(s, "Cookie: mstshash=", 17);		stream_write(s, (BYTE*) nego->cookie, cookie_length);		stream_write_BYTE(s, 0x0D); /* CR */		stream_write_BYTE(s, 0x0A); /* LF */		length += cookie_length + 19;	}	DEBUG_NEGO("requested_protocols: %d", nego->requested_protocols);	if (nego->requested_protocols > PROTOCOL_RDP)	{		/* RDP_NEG_DATA must be present for TLS and NLA */		stream_write_BYTE(s, TYPE_RDP_NEG_REQ);		stream_write_BYTE(s, 0); /* flags, must be set to zero */		stream_write_UINT16(s, 8); /* RDP_NEG_DATA length (8) */		stream_write_UINT32(s, nego->requested_protocols); /* requestedProtocols */		length += 8;	}	stream_get_mark(s, em);	stream_set_mark(s, bm);	tpkt_write_header(s, length);	tpdu_write_connection_request(s, length - 5);	stream_set_mark(s, em);	if (transport_write(nego->transport, s) < 0)		return FALSE;	return TRUE;}

static UINT32 rdp_security_stream_out(rdpRdp* rdp, STREAM* s, int length){	BYTE* data;	UINT32 sec_flags;	UINT32 pad = 0;	sec_flags = rdp->sec_flags;	if (sec_flags != 0)	{		rdp_write_security_header(s, sec_flags);		if (sec_flags & SEC_ENCRYPT)		{			if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)			{				data = s->p + 12;				length = length - (data - s->data);				stream_write_UINT16(s, 0x10); /* length */				stream_write_BYTE(s, 0x1); /* TSFIPS_VERSION 1*/				/* handle padding */				pad = 8 - (length % 8);				if (pad == 8)					pad = 0;				if (pad)					memset(data+length, 0, pad);				stream_write_BYTE(s, pad);				security_hmac_signature(data, length, s->p, rdp);				stream_seek(s, 8);				security_fips_encrypt(data, length + pad, rdp);			}			else			{				data = s->p + 8;				length = length - (data - s->data);				if (sec_flags & SEC_SECURE_CHECKSUM)					security_salted_mac_signature(rdp, data, length, TRUE, s->p);				else					security_mac_signature(rdp, data, length, s->p);				stream_seek(s, 8);				security_encrypt(s->p, length, rdp);			}		}		rdp->sec_flags = 0;	}	return pad;}

void rail_write_client_sysparam_order(STREAM* s, RAIL_SYSPARAM_ORDER* sysparam){	BYTE body;	stream_write_UINT32(s, sysparam->param); /* systemParam (4 bytes) */	switch (sysparam->param)	{		case SPI_SET_DRAG_FULL_WINDOWS:			body = sysparam->dragFullWindows;			stream_write_BYTE(s, body);			break;		case SPI_SET_KEYBOARD_CUES:			body = sysparam->keyboardCues;			stream_write_BYTE(s, body);			break;		case SPI_SET_KEYBOARD_PREF:			body = sysparam->keyboardPref;			stream_write_BYTE(s, body);			break;		case SPI_SET_MOUSE_BUTTON_SWAP:			body = sysparam->mouseButtonSwap;			stream_write_BYTE(s, body);			break;		case SPI_SET_WORK_AREA:			stream_write_UINT16(s, sysparam->workArea.left); /* left (2 bytes) */			stream_write_UINT16(s, sysparam->workArea.top); /* top (2 bytes) */			stream_write_UINT16(s, sysparam->workArea.right); /* right (2 bytes) */			stream_write_UINT16(s, sysparam->workArea.bottom); /* bottom (2 bytes) */			break;		case SPI_DISPLAY_CHANGE:			stream_write_UINT16(s, sysparam->displayChange.left); /* left (2 bytes) */			stream_write_UINT16(s, sysparam->displayChange.top); /* top (2 bytes) */			stream_write_UINT16(s, sysparam->displayChange.right); /* right (2 bytes) */			stream_write_UINT16(s, sysparam->displayChange.bottom); /* bottom (2 bytes) */			break;		case SPI_TASKBAR_POS:			stream_write_UINT16(s, sysparam->taskbarPos.left); /* left (2 bytes) */			stream_write_UINT16(s, sysparam->taskbarPos.top); /* top (2 bytes) */			stream_write_UINT16(s, sysparam->taskbarPos.right); /* right (2 bytes) */			stream_write_UINT16(s, sysparam->taskbarPos.bottom); /* bottom (2 bytes) */			break;		case SPI_SET_HIGH_CONTRAST:			rail_write_high_contrast(s, &sysparam->highContrast);			break;	}}

static void rfx_compose_message_frame_begin(RFX_CONTEXT* context, STREAM* s){	stream_check_size(s, 14);	stream_write_UINT16(s, WBT_FRAME_BEGIN); /* CodecChannelT.blockType */	stream_write_UINT32(s, 14); /* CodecChannelT.blockLen */	stream_write_BYTE(s, 1); /* CodecChannelT.codecId */	stream_write_BYTE(s, 0); /* CodecChannelT.channelId */	stream_write_UINT32(s, context->frame_idx); /* frameIdx */	stream_write_UINT16(s, 1); /* numRegions */	context->frame_idx++;}

BOOL drive_file_query_information(DRIVE_FILE* file, UINT32 FsInformationClass, STREAM* output){	struct STAT st;	if (STAT(file->fullpath, &st) != 0)	{		stream_write_UINT32(output, 0); /* Length */		return FALSE;	}	switch (FsInformationClass)	{		case FileBasicInformation:			/* http://msdn.microsoft.com/en-us/library/cc232094.aspx */			stream_write_UINT32(output, 36); /* Length */			stream_check_size(output, 36);			stream_write_UINT64(output, FILE_TIME_SYSTEM_TO_RDP(st.st_mtime)); /* CreationTime */			stream_write_UINT64(output, FILE_TIME_SYSTEM_TO_RDP(st.st_atime)); /* LastAccessTime */			stream_write_UINT64(output, FILE_TIME_SYSTEM_TO_RDP(st.st_mtime)); /* LastWriteTime */			stream_write_UINT64(output, FILE_TIME_SYSTEM_TO_RDP(st.st_ctime)); /* ChangeTime */			stream_write_UINT32(output, FILE_ATTR_SYSTEM_TO_RDP(file, st)); /* FileAttributes */			/* Reserved(4), MUST NOT be added! */			break;		case FileStandardInformation:			/*  http://msdn.microsoft.com/en-us/library/cc232088.aspx */			stream_write_UINT32(output, 22); /* Length */			stream_check_size(output, 22);			stream_write_UINT64(output, st.st_size); /* AllocationSize */			stream_write_UINT64(output, st.st_size); /* EndOfFile */			stream_write_UINT32(output, st.st_nlink); /* NumberOfLinks */			stream_write_BYTE(output, file->delete_pending ? 1 : 0); /* DeletePending */			stream_write_BYTE(output, file->is_dir ? 1 : 0); /* Directory */			/* Reserved(2), MUST NOT be added! */			break;		case FileAttributeTagInformation:			/* http://msdn.microsoft.com/en-us/library/cc232093.aspx */			stream_write_UINT32(output, 8); /* Length */			stream_check_size(output, 8);			stream_write_UINT32(output, FILE_ATTR_SYSTEM_TO_RDP(file, st)); /* FileAttributes */			stream_write_UINT32(output, 0); /* ReparseTag */			break;		default:			stream_write_UINT32(output, 0); /* Length */			DEBUG_WARN("invalid FsInformationClass %d", FsInformationClass);			return FALSE;	}	return TRUE;}

int ber_write_length(wStream* s, int length){	if (length > 0x7F)	{		stream_write_BYTE(s, 0x82);		stream_write_UINT16_be(s, length);		return 3;	}	else	{		stream_write_BYTE(s, length);		return 1;	}}

void ber_write_application_tag(wStream* s, BYTE tag, int length){	if (tag > 30)	{		stream_write_BYTE(s, (BER_CLASS_APPL | BER_CONSTRUCT) | BER_TAG_MASK);		stream_write_BYTE(s, tag);		ber_write_length(s, length);	}	else	{		stream_write_BYTE(s, (BER_CLASS_APPL | BER_CONSTRUCT) | (BER_TAG_MASK & tag));		ber_write_length(s, length);	}}

void rdp_write_share_data_header(STREAM* s, UINT16 length, BYTE type, UINT32 share_id){	length -= RDP_PACKET_HEADER_MAX_LENGTH;	length -= RDP_SHARE_CONTROL_HEADER_LENGTH;	length -= RDP_SHARE_DATA_HEADER_LENGTH;	/* Share Data Header */	stream_write_UINT32(s, share_id); /* shareId (4 bytes) */	stream_write_BYTE(s, 0); /* pad1 (1 byte) */	stream_write_BYTE(s, STREAM_LOW); /* streamId (1 byte) */	stream_write_UINT16(s, length); /* uncompressedLength (2 bytes) */	stream_write_BYTE(s, type); /* pduType2, Data PDU Type (1 byte) */	stream_write_BYTE(s, 0); /* compressedType (1 byte) */	stream_write_UINT16(s, 0); /* compressedLength (2 bytes) */}

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

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

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

void rdp_write_header(rdpRdp* rdp, STREAM* s, UINT16 length, UINT16 channel_id){	int body_length;	enum DomainMCSPDU MCSPDU;	MCSPDU = (rdp->settings->ServerMode) ? DomainMCSPDU_SendDataIndication : DomainMCSPDU_SendDataRequest;	if ((rdp->sec_flags & SEC_ENCRYPT) && (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS))	{		int pad;		body_length = length - RDP_PACKET_HEADER_MAX_LENGTH - 16;		pad = 8 - (body_length % 8);		if (pad != 8)			length += pad;	}	mcs_write_domain_mcspdu_header(s, MCSPDU, length, 0);	per_write_integer16(s, rdp->mcs->user_id, MCS_BASE_CHANNEL_ID); /* initiator */	per_write_integer16(s, channel_id, 0); /* channelId */	stream_write_BYTE(s, 0x70); /* dataPriority + segmentation */	/*	 * We always encode length in two bytes, eventhough we could use	 * only one byte if length <= 0x7F. It is just easier that way,	 * because we can leave room for fixed-length header, store all	 * the data first and then store the header.	 */	length = (length - RDP_PACKET_HEADER_MAX_LENGTH) | 0x8000;	stream_write_UINT16_be(s, length); /* userData (OCTET_STRING) */}

void tpdu_write_header(STREAM* s, UINT16 length, BYTE code){	stream_write_BYTE(s, length); /* LI */	stream_write_BYTE(s, code); /* code */	if (code == X224_TPDU_DATA)	{		stream_write_BYTE(s, 0x80); /* EOT */	}	else	{		stream_write_UINT16(s, 0); /* DST-REF */		stream_write_UINT16(s, 0); /* SRC-REF */		stream_write_BYTE(s, 0); /* Class 0 */	}}

void update_write_surfcmd_surface_bits_header(STREAM* s, SURFACE_BITS_COMMAND* cmd){	stream_check_size(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH);	stream_write_UINT16(s, CMDTYPE_STREAM_SURFACE_BITS);	stream_write_UINT16(s, cmd->destLeft);	stream_write_UINT16(s, cmd->destTop);	stream_write_UINT16(s, cmd->destRight);	stream_write_UINT16(s, cmd->destBottom);	stream_write_BYTE(s, cmd->bpp);	stream_write_UINT16(s, 0); /* reserved1, reserved2 */	stream_write_BYTE(s, cmd->codecID);	stream_write_UINT16(s, cmd->width);	stream_write_UINT16(s, cmd->height);	stream_write_UINT32(s, cmd->bitmapDataLength);}

void rail_write_client_activate_order(STREAM* s, RAIL_ACTIVATE_ORDER* activate){	BYTE enabled;	stream_write_UINT32(s, activate->windowId); /* windowId (4 bytes) */	enabled = activate->enabled;	stream_write_BYTE(s, enabled); /* enabled (1 byte) */}

void rdp_write_client_persistent_key_list_pdu(STREAM* s, rdpSettings* settings){	stream_write_UINT16(s, 0); /* numEntriesCache0 (2 bytes) */	stream_write_UINT16(s, 0); /* numEntriesCache1 (2 bytes) */	stream_write_UINT16(s, 0); /* numEntriesCache2 (2 bytes) */	stream_write_UINT16(s, 0); /* numEntriesCache3 (2 bytes) */	stream_write_UINT16(s, 0); /* numEntriesCache4 (2 bytes) */	stream_write_UINT16(s, 0); /* totalEntriesCache0 (2 bytes) */	stream_write_UINT16(s, 0); /* totalEntriesCache1 (2 bytes) */	stream_write_UINT16(s, 0); /* totalEntriesCache2 (2 bytes) */	stream_write_UINT16(s, 0); /* totalEntriesCache3 (2 bytes) */	stream_write_UINT16(s, 0); /* totalEntriesCache4 (2 bytes) */	stream_write_BYTE(s, PERSIST_FIRST_PDU | PERSIST_LAST_PDU); /* bBitMask (1 byte) */	stream_write_BYTE(s, 0); /* pad1 (1 byte) */	stream_write_UINT16(s, 0); /* pad3 (2 bytes) */	/* entries */}

int der_write_length(wStream* s, int length){	if (length > 0x7F && length <= 0xFF)	{		stream_write_BYTE(s, 0x81);		stream_write_BYTE(s, length);		return 2;	}	else if (length > 0xFF)	{		stream_write_BYTE(s, 0x82);		stream_write_UINT16_be(s, length);		return 3;	}	else	{		stream_write_BYTE(s, length);		return 1;	}}

static void rfx_compose_message_tile(RFX_CONTEXT* context, STREAM* s,	BYTE* tile_data, int tile_width, int tile_height, int rowstride,	const UINT32* quantVals, int quantIdxY, int quantIdxCb, int quantIdxCr,	int xIdx, int yIdx){	int YLen = 0;	int CbLen = 0;	int CrLen = 0;	int start_pos, end_pos;	stream_check_size(s, 19);	start_pos = stream_get_pos(s);	stream_write_UINT16(s, CBT_TILE); /* BlockT.blockType */	stream_seek_UINT32(s); /* set BlockT.blockLen later */	stream_write_BYTE(s, quantIdxY);	stream_write_BYTE(s, quantIdxCb);	stream_write_BYTE(s, quantIdxCr);	stream_write_UINT16(s, xIdx);	stream_write_UINT16(s, yIdx);	stream_seek(s, 6); /* YLen, CbLen, CrLen */	rfx_encode_rgb(context, tile_data, tile_width, tile_height, rowstride,		quantVals + quantIdxY * 10, quantVals + quantIdxCb * 10, quantVals + quantIdxCr * 10,		s, &YLen, &CbLen, &CrLen);	DEBUG_RFX("xIdx=%d yIdx=%d width=%d height=%d YLen=%d CbLen=%d CrLen=%d",		xIdx, yIdx, tile_width, tile_height, YLen, CbLen, CrLen);	end_pos = stream_get_pos(s);	stream_set_pos(s, start_pos + 2);	stream_write_UINT32(s, 19 + YLen + CbLen + CrLen); /* BlockT.blockLen */	stream_set_pos(s, start_pos + 13);	stream_write_UINT16(s, YLen);	stream_write_UINT16(s, CbLen);	stream_write_UINT16(s, CrLen);	stream_set_pos(s, end_pos);}

void input_send_fastpath_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code){	STREAM* s;	BYTE eventFlags = 0;	rdpRdp* rdp = input->context->rdp;	eventFlags |= (flags & KBD_FLAGS_RELEASE) ? FASTPATH_INPUT_KBDFLAGS_RELEASE : 0;	eventFlags |= (flags & KBD_FLAGS_EXTENDED) ? FASTPATH_INPUT_KBDFLAGS_EXTENDED : 0;	s = fastpath_input_pdu_init(rdp->fastpath, eventFlags, FASTPATH_INPUT_EVENT_SCANCODE);	stream_write_BYTE(s, code); /* keyCode (1 byte) */	fastpath_send_input_pdu(rdp->fastpath, s);}

BOOL rdp_send_deactivate_all(rdpRdp* rdp){	STREAM* s;	s = rdp_pdu_init(rdp);	stream_write_UINT32(s, rdp->settings->share_id); /* shareId (4 bytes) */	stream_write_UINT16(s, 1); /* lengthSourceDescriptor (2 bytes) */	stream_write_BYTE(s, 0); /* sourceDescriptor (should be 0x00) */	return rdp_send_pdu(rdp, s, PDU_TYPE_DEACTIVATE_ALL, rdp->mcs->user_id);}

static BOOL rdpsnd_server_send_formats(rdpsnd_server* rdpsnd, STREAM* s){	UINT16 i;	RDPSND_PDU_INIT(s, SNDC_FORMATS);	stream_write_UINT32(s, 0); /* dwFlags */	stream_write_UINT32(s, 0); /* dwVolume */	stream_write_UINT32(s, 0); /* dwPitch */	stream_write_UINT16(s, 0); /* wDGramPort */	stream_write_UINT16(s, rdpsnd->context.num_server_formats); /* wNumberOfFormats */	stream_write_BYTE(s, rdpsnd->context.block_no); /* cLastBlockConfirmed */	stream_write_UINT16(s, 0x06); /* wVersion */	stream_write_BYTE(s, 0); /* bPad */	for (i = 0; i < rdpsnd->context.num_server_formats; i++)	{		stream_write_UINT16(s, rdpsnd->context.server_formats[i].wFormatTag); /* wFormatTag (WAVE_FORMAT_PCM) */		stream_write_UINT16(s, rdpsnd->context.server_formats[i].nChannels); /* nChannels */		stream_write_UINT32(s, rdpsnd->context.server_formats[i].nSamplesPerSec); /* nSamplesPerSec */		stream_write_UINT32(s, rdpsnd->context.server_formats[i].nSamplesPerSec *			rdpsnd->context.server_formats[i].nChannels *			rdpsnd->context.server_formats[i].wBitsPerSample / 8); /* nAvgBytesPerSec */		stream_write_UINT16(s, rdpsnd->context.server_formats[i].nBlockAlign); /* nBlockAlign */		stream_write_UINT16(s, rdpsnd->context.server_formats[i].wBitsPerSample); /* wBitsPerSample */		stream_write_UINT16(s, rdpsnd->context.server_formats[i].cbSize); /* cbSize */		if (rdpsnd->context.server_formats[i].cbSize > 0)		{			stream_write(s, rdpsnd->context.server_formats[i].data, rdpsnd->context.server_formats[i].cbSize);		}	}	RDPSND_PDU_FINISH(s);	return TRUE;}

static void update_write_suppress_output(STREAM* s, BYTE allow, RECTANGLE_16* area){	stream_write_BYTE(s, allow); /* allowDisplayUpdates (1 byte) */	stream_seek(s, 3); /* pad3Octets (3 bytes) */	if (allow > 0)	{		stream_write_UINT16(s, area->left); /* left (2 bytes) */		stream_write_UINT16(s, area->top); /* top (2 bytes) */		stream_write_UINT16(s, area->right); /* right (2 bytes) */		stream_write_UINT16(s, area->bottom); /* bottom (2 bytes) */	}}

static void update_send_scrblt(rdpContext* context, SCRBLT_ORDER* scrblt){	STREAM* s;	rdpRdp* rdp = context->rdp;	s = fastpath_update_pdu_init(rdp->fastpath);	stream_write_UINT16(s, 1); /* numberOrders (2 bytes) */	stream_write_BYTE(s, ORDER_STANDARD | ORDER_TYPE_CHANGE); /* controlFlags (1 byte) */	stream_write_BYTE(s, ORDER_TYPE_SCRBLT); /* orderType (1 byte) */	stream_write_BYTE(s, 0x7F); /* fieldFlags (variable) */	stream_write_UINT16(s, scrblt->nLeftRect);	stream_write_UINT16(s, scrblt->nTopRect);	stream_write_UINT16(s, scrblt->nWidth);	stream_write_UINT16(s, scrblt->nHeight);	stream_write_BYTE(s, scrblt->bRop);	stream_write_UINT16(s, scrblt->nXSrc);	stream_write_UINT16(s, scrblt->nYSrc);	fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_ORDERS, s);}

static void xf_cliprdr_process_dib(clipboardContext* cb, BYTE* data, int size){	STREAM* s;	UINT16 bpp;	UINT32 offset;	UINT32 ncolors;	/* size should be at least sizeof(BITMAPINFOHEADER) */	if (size < 40)	{		DEBUG_X11_CLIPRDR("dib size %d too short", size);		return;	}	s = stream_new(0);	stream_attach(s, data, size);	stream_seek(s, 14);	stream_read_UINT16(s, bpp);	stream_read_UINT32(s, ncolors);	offset = 14 + 40 + (bpp <= 8 ? (ncolors == 0 ? (1 << bpp) : ncolors) * 4 : 0);	stream_detach(s);	stream_free(s);	DEBUG_X11_CLIPRDR("offset=%d bpp=%d ncolors=%d", offset, bpp, ncolors);	s = stream_new(14 + size);	stream_write_BYTE(s, 'B');	stream_write_BYTE(s, 'M');	stream_write_UINT32(s, 14 + size);	stream_write_UINT32(s, 0);	stream_write_UINT32(s, offset);	stream_write(s, data, size);	cb->data = stream_get_head(s);	cb->data_length = stream_get_length(s);	stream_detach(s);	stream_free(s);}

void drive_register_drive_path(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, char* name, char* path){	int i, length;	DRIVE_DEVICE* disk;#ifdef WIN32	/*	 * We cannot enter paths like c:/ because : is an arg separator	 * thus, paths are entered as c+/ and the + is substituted here	 */	if ( path[1] == '+' )	{		if ( (path[0]>='a' && path[0]<='z') || (path[0]>='A' && path[0]<='Z') )		{			path[1] = ':';		}	}#endif	if (name[0] && path[0])	{		disk = (DRIVE_DEVICE*) malloc(sizeof(DRIVE_DEVICE));		ZeroMemory(disk, sizeof(DRIVE_DEVICE));		disk->device.type = RDPDR_DTYP_FILESYSTEM;		disk->device.name = name;		disk->device.IRPRequest = drive_irp_request;		disk->device.Free = drive_free;		length = strlen(name);		disk->device.data = stream_new(length + 1);		for (i = 0; i <= length; i++)			stream_write_BYTE(disk->device.data, name[i] < 0 ? '_' : name[i]);		disk->path = path;		disk->files = list_new();		disk->pIrpList = (PSLIST_HEADER) _aligned_malloc(sizeof(SLIST_HEADER), MEMORY_ALLOCATION_ALIGNMENT);		InitializeSListHead(disk->pIrpList);		disk->irpEvent = CreateEvent(NULL, TRUE, FALSE, NULL);		disk->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);		disk->thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) drive_thread_func, disk, CREATE_SUSPENDED, NULL);		pEntryPoints->RegisterDevice(pEntryPoints->devman, (DEVICE*) disk);                ResumeThread(disk->thread);	}}

void rts_pdu_header_write(STREAM* s, RTS_PDU_HEADER* header){	stream_write_BYTE(s, header->rpc_vers); /* rpc_vers (1 byte) */	stream_write_BYTE(s, header->rpc_vers_minor); /* rpc_vers_minor (1 byte) */	stream_write_BYTE(s, header->ptype); /* PTYPE (1 byte) */	stream_write_BYTE(s, header->pfc_flags); /* pfc_flags (1 byte) */	stream_write_BYTE(s, header->packed_drep[0]); /* packet_drep[0] (1 byte) */	stream_write_BYTE(s, header->packed_drep[1]); /* packet_drep[1] (1 byte) */	stream_write_BYTE(s, header->packed_drep[2]); /* packet_drep[2] (1 byte) */	stream_write_BYTE(s, header->packed_drep[3]); /* packet_drep[3] (1 byte) */	stream_write_UINT16(s, header->frag_length); /* frag_length (2 bytes) */	stream_write_UINT16(s, header->auth_length); /* auth_length (2 bytes) */	stream_write_UINT32(s, header->call_id); /* call_id (4 bytes) */	stream_write_UINT16(s, header->flags); /* flags (2 bytes) */	stream_write_UINT16(s, header->numberOfCommands); /* numberOfCommands (2 bytes) */}