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

boolean gcc_read_server_core_data(STREAM* s, rdpSettings* settings){	uint32 version;	uint32 clientRequestedProtocols;	stream_read_uint32(s, version); /* version */	stream_read_uint32(s, clientRequestedProtocols); /* clientRequestedProtocols */	if (version == RDP_VERSION_4 && settings->rdp_version > 4)		settings->rdp_version = 4;	else if (version == RDP_VERSION_5_PLUS && settings->rdp_version < 5)		settings->rdp_version = 7;	return true;}

void rdp_recv_set_error_info_data_pdu(rdpRdp* rdp, STREAM* s){	stream_read_uint32(s, rdp->errorInfo); /* errorInfo (4 bytes) */	if (rdp->errorInfo != ERRINFO_SUCCESS)		rdp_print_errinfo(rdp->errorInfo);}

void cliprdr_process_long_format_names(cliprdrPlugin* cliprdr, STREAM* s, uint32 length, uint16 flags){	int num_formats;	uint8* start_mark;	uint8* end_mark;	CLIPRDR_FORMAT_NAME* format_name;	num_formats = 0;	stream_get_mark(s, start_mark);	stream_get_mark(s, end_mark);	end_mark += length;	while (s->p < end_mark)	{		stream_seek_uint32(s);		stream_seek(s, 32);		num_formats++;	}	stream_set_mark(s, start_mark);	cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) xmalloc(sizeof(CLIPRDR_FORMAT_NAME) * num_formats);	cliprdr->num_format_names = num_formats;	num_formats = 0;	while (s->p < end_mark)	{		format_name = &cliprdr->format_names[num_formats++];		stream_read_uint32(s, format_name->id);		format_name->name = freerdp_uniconv_in(cliprdr->uniconv, s->p, 32);		format_name->length = strlen(format_name->name);		stream_seek(s, 32);	}}

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

void test_stream(void){	STREAM * stream;	int pos;	uint32 n;	uint64 n64;	stream = stream_new(1);	pos = stream_get_pos(stream);	stream_write_uint8(stream, 0xFE);	stream_check_size(stream, 14);	stream_write_uint16(stream, 0x0102);	stream_write_uint32(stream, 0x03040506);	stream_write_uint64(stream, 0x0708091011121314LL);	/* freerdp_hexdump(stream->buffer, 15); */	stream_set_pos(stream, pos);	stream_seek(stream, 3);	stream_read_uint32(stream, n);	stream_read_uint64(stream, n64);	CU_ASSERT(n == 0x03040506);	CU_ASSERT(n64 == 0x0708091011121314LL);	stream_free(stream);}

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

void rts_padding_command_read(rdpRpc* rpc, STREAM* s){	uint32 ConformanceCount;	stream_read_uint32(s, ConformanceCount); /* ConformanceCount (4 bytes) */	stream_seek(s, ConformanceCount); /* Padding (variable) */}

boolean rdp_recv_save_session_info(rdpRdp* rdp, STREAM* s){	uint32 infoType;	stream_read_uint32(s, infoType); /* infoType (4 bytes) */	//printf("%s/n", INFO_TYPE_LOGON_STRINGS[infoType]);	switch (infoType)	{		case INFO_TYPE_LOGON:			rdp_recv_logon_info_v1(rdp, s);			break;		case INFO_TYPE_LOGON_LONG:			rdp_recv_logon_info_v2(rdp, s);			break;		case INFO_TYPE_LOGON_PLAIN_NOTIFY:			rdp_recv_logon_plain_notify(rdp, s);			break;		case INFO_TYPE_LOGON_EXTENDED_INF:			rdp_recv_logon_info_extended(rdp, s);			break;		default:			break;	}	return true;}

boolean rdp_recv_deactivate_all(rdpRdp* rdp, STREAM* s){	uint16 lengthSourceDescriptor;	/*	 * Windows XP can send short DEACTIVATE_ALL PDU that doesn't contain	 * the following fields.	 */	if (stream_get_left(s) > 0)	{		stream_read_uint32(s, rdp->settings->share_id); /* shareId (4 bytes) */		stream_read_uint16(s, lengthSourceDescriptor); /* lengthSourceDescriptor (2 bytes) */		stream_seek(s, lengthSourceDescriptor); /* sourceDescriptor (should be 0x00) */	}	rdp->state = CONNECTION_STATE_CAPABILITY;	while (rdp->state != CONNECTION_STATE_ACTIVE)	{		if (rdp_check_fds(rdp) < 0)			return false;		if (rdp->disconnect)			break;	}	return true;}

void rdp_read_window_list_capability_set(STREAM* s, rdpSettings* settings){	// TODO:	// 2011-07-27: In current time icon cache is not supported by any	//             Microsoft implementation of server or client.	//	// But we must process this values according to 3.2.5.1.4	//	uint8 numIconCaches;	uint16 numIconCacheEntries;	uint32 wndSupportLevel;	stream_read_uint32(s, wndSupportLevel); /* wndSupportLevel (4 bytes) */	stream_read_uint8(s, numIconCaches); /* numIconCaches (1 byte) */	stream_read_uint16(s, numIconCacheEntries); /* numIconCacheEntries (2 bytes) */	settings->rail_window_supported = False;	settings->rail_icon_cache_number = MIN(3, numIconCaches);	settings->rail_icon_cache_entries_number = MIN(12, numIconCacheEntries);	if (		(wndSupportLevel == WINDOW_LEVEL_SUPPORTED) ||		(wndSupportLevel == WINDOW_LEVEL_SUPPORTED_EX)	   )	{		settings->rail_window_supported = True;	}}

void update_recv_window_info_order(rdpUpdate* update, STREAM* s, WINDOW_ORDER_INFO* orderInfo){	stream_read_uint32(s, orderInfo->windowId); /* windowId (4 bytes) */	if (orderInfo->fieldFlags & WINDOW_ORDER_ICON)	{		DEBUG_WND("Window Icon Order");		update_read_window_icon_order(s, orderInfo, &update->window_icon);		IFCALL(update->WindowIcon, update, orderInfo, &update->window_icon);	}	else if (orderInfo->fieldFlags & WINDOW_ORDER_CACHED_ICON)	{		DEBUG_WND("Window Cached Icon Order");		update_read_window_cached_icon_order(s, orderInfo, &update->window_cached_icon);		IFCALL(update->WindowCachedIcon, update, orderInfo, &update->window_cached_icon);	}	else if (orderInfo->fieldFlags & WINDOW_ORDER_STATE_DELETED)	{		DEBUG_WND("Window Deleted Order");		update_read_window_delete_order(s, orderInfo);		IFCALL(update->WindowDelete, update, orderInfo);	}	else	{		DEBUG_WND("Window State Order");		update_read_window_state_order(s, orderInfo, &update->window_state);		if (orderInfo->fieldFlags & WINDOW_ORDER_STATE_NEW)			IFCALL(update->WindowCreate, update, orderInfo, &update->window_state);		else			IFCALL(update->WindowUpdate, update, orderInfo, &update->window_state);	}}

void freerdp_string_read_length32(STREAM* s, rdpString* string, UNICONV* uniconv){	stream_read_uint32(s, string->length);	string->unicode = (char*) xmalloc(string->length);	stream_read(s, string->unicode, string->length);	string->ascii = freerdp_uniconv_in(uniconv, (uint8*) string->unicode, string->length);}

boolean rdp_read_share_data_header(STREAM* s, uint16* length, uint8* type, uint32* share_id,					uint8 *compressed_type, uint16 *compressed_len){	if (stream_get_left(s) < 12)		return false;	/* Share Data Header */	stream_read_uint32(s, *share_id); /* shareId (4 bytes) */	stream_seek_uint8(s); /* pad1 (1 byte) */	stream_seek_uint8(s); /* streamId (1 byte) */	stream_read_uint16(s, *length); /* uncompressedLength (2 bytes) */	stream_read_uint8(s, *type); /* pduType2, Data PDU Type (1 byte) */	if (*type & 0x80)	{		stream_read_uint8(s, *compressed_type); /* compressedType (1 byte) */		stream_read_uint16(s, *compressed_len); /* compressedLength (2 bytes) */	}	else	{		stream_seek(s, 3);		*compressed_type = 0;		*compressed_len = 0;	}	return true;}

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

void cliprdr_process_format_data_request(cliprdrPlugin* cliprdr, STREAM* data_in){	FRDP_CB_DATA_REQUEST_EVENT* cb_event;	cb_event = (FRDP_CB_DATA_REQUEST_EVENT*)freerdp_event_new(FRDP_EVENT_TYPE_CB_DATA_REQUEST, NULL, NULL);	stream_read_uint32(data_in, cb_event->format);	svc_plugin_send_event((rdpSvcPlugin*)cliprdr, (FRDP_EVENT*)cb_event);}

void rail_read_server_get_appid_resp_order(STREAM* s, RAIL_GET_APPID_RESP_ORDER* get_appid_resp){	stream_read_uint32(s, get_appid_resp->windowId); /* windowId (4 bytes) */	stream_read(s, &get_appid_resp->applicationIdBuffer[0], 512); /* applicationId (256 UNICODE chars) */	get_appid_resp->applicationId.length = 512;	get_appid_resp->applicationId.string = &get_appid_resp->applicationIdBuffer[0];}

void rail_read_server_exec_result_order(STREAM* s, RAIL_EXEC_RESULT_ORDER* exec_result){	stream_read_uint16(s, exec_result->flags); /* flags (2 bytes) */	stream_read_uint16(s, exec_result->execResult); /* execResult (2 bytes) */	stream_read_uint32(s, exec_result->rawResult); /* rawResult (4 bytes) */	stream_seek_uint16(s); /* padding (2 bytes) */	rail_read_unicode_string(s, &exec_result->exeOrFile); /* exeOrFile */}

boolean gcc_read_client_security_data(STREAM* s, rdpSettings* settings, uint16 blockLength){	if (blockLength < 8)		return false;	if (settings->encryption)	{		stream_read_uint32(s, settings->encryption_method); /* encryptionMethods */		if (settings->encryption_method == 0)			stream_read_uint32(s, settings->encryption_method); /* extEncryptionMethods */	}	else	{		stream_seek(s, 8);	}	return true;}

static void rdpdr_process_server_announce_request(rdpdrPlugin* rdpdr, STREAM* data_in){	stream_read_uint16(data_in, rdpdr->versionMajor);	stream_read_uint16(data_in, rdpdr->versionMinor);	stream_read_uint32(data_in, rdpdr->clientID);	DEBUG_SVC("version %d.%d clientID %d", rdpdr->versionMajor, rdpdr->versionMinor, rdpdr->clientID);}

void rdp_read_set_error_info_data_pdu(STREAM* s){	uint32 errorInfo;	stream_read_uint32(s, errorInfo); /* errorInfo (4 bytes) */	printf("Error Info: 0x%08X/n", errorInfo);}

static uint32 handle_Connect(IRP* irp, tbool wide){	LONG rv;	SCARDCONTEXT hContext;	char *readerName = NULL;	DWORD dwShareMode = 0;	DWORD dwPreferredProtocol = 0;	DWORD dwActiveProtocol = 0;	SCARDHANDLE hCard;	stream_seek(irp->input, 0x1c);	stream_read_uint32(irp->input, dwShareMode);	stream_read_uint32(irp->input, dwPreferredProtocol);	sc_input_reader_name(irp, &readerName, wide);	stream_seek(irp->input, 4);	stream_read_uint32(irp->input, hContext);	DEBUG_SCARD("(context: 0x%08x, share: 0x%08x, proto: 0x%08x, reader: /"%s/")",		(unsigned) hContext, (unsigned) dwShareMode,		(unsigned) dwPreferredProtocol, readerName ? readerName : "NULL");	rv = SCardConnect(hContext, readerName, (DWORD) dwShareMode,		(DWORD) dwPreferredProtocol, &hCard, (DWORD *) &dwActiveProtocol);	if (rv != SCARD_S_SUCCESS)		DEBUG_SCARD("Failure: %s 0x%08x", pcsc_stringify_error(rv), (unsigned) rv);	else		DEBUG_SCARD("Success 0x%08x", (unsigned) hCard);	stream_write_uint32(irp->output, 0x00000000);	stream_write_uint32(irp->output, 0x00000000);	stream_write_uint32(irp->output, 0x00000004);	stream_write_uint32(irp->output, 0x016Cff34);	stream_write_uint32(irp->output, dwActiveProtocol);	stream_write_uint32(irp->output, 0x00000004);	stream_write_uint32(irp->output, hCard);	stream_seek(irp->output, 28);	sc_output_alignment(irp, 8);	xfree(readerName);	return rv;}

boolean certificate_read_server_proprietary_certificate(rdpCertificate* certificate, STREAM* s){    uint32 dwSigAlgId;    uint32 dwKeyAlgId;    uint32 wPublicKeyBlobType;    uint32 wPublicKeyBlobLen;    uint32 wSignatureBlobType;    uint32 wSignatureBlobLen;    printf("Server Proprietary Certificate/n");    stream_read_uint32(s, dwSigAlgId);    stream_read_uint32(s, dwKeyAlgId);    if (!(dwSigAlgId == 1 && dwKeyAlgId == 1))    {        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;    }    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 (!certificate_process_server_public_signature(certificate, s, wSignatureBlobLen))    {        printf("certificate_read_server_proprietary_certificate: parse error 5/n");        return False;    }    return True;}

static void rdpsnd_process_message_setvolume(rdpsndPlugin* rdpsnd, STREAM* data_in){	uint32 dwVolume;	stream_read_uint32(data_in, dwVolume);	DEBUG_SVC("dwVolume 0x%X", dwVolume);	if (rdpsnd->device)		IFCALL(rdpsnd->device->SetVolume, rdpsnd->device, dwVolume);}

void rdp_recv_set_error_info_data_pdu(STREAM* s){	uint32 errorInfo;	stream_read_uint32(s, errorInfo); /* errorInfo (4 bytes) */	if (errorInfo != ERRINFO_SUCCESS)		rdp_print_errinfo(errorInfo);}

void rdp_read_draw_gdiplus_cache_capability_set(STREAM* s, rdpSettings* settings){	uint32 drawGDIPlusSupportLevel;	uint32 drawGdiplusCacheLevel;	stream_read_uint32(s, drawGDIPlusSupportLevel); /* drawGDIPlusSupportLevel (4 bytes) */	stream_seek_uint32(s); /* GdipVersion (4 bytes) */	stream_read_uint32(s, drawGdiplusCacheLevel); /* drawGdiplusCacheLevel (4 bytes) */	stream_seek(s, 10); /* GdipCacheEntries (10 bytes) */	stream_seek(s, 8); /* GdipCacheChunkSize (8 bytes) */	stream_seek(s, 6); /* GdipImageCacheProperties (6 bytes) */	if (drawGDIPlusSupportLevel & DRAW_GDIPLUS_SUPPORTED)		settings->draw_gdi_plus = True;	if (drawGdiplusCacheLevel & DRAW_GDIPLUS_CACHE_LEVEL_ONE)		settings->draw_gdi_plus_cache = True;}

void rdp_read_input_capability_set(STREAM* s, rdpSettings* settings){	uint16 inputFlags;	stream_read_uint16(s, inputFlags); /* inputFlags (2 bytes) */	stream_seek_uint16(s); /* pad2OctetsA (2 bytes) */	stream_read_uint32(s, settings->kbd_layout); /* keyboardLayout (4 bytes) */	stream_read_uint32(s, settings->kbd_type); /* keyboardType (4 bytes) */	stream_read_uint32(s, settings->kbd_subtype); /* keyboardSubType (4 bytes) */	stream_read_uint32(s, settings->kbd_fn_keys); /* keyboardFunctionKeys (4 bytes) */	stream_seek(s, 64); /* imeFileName (64 bytes) */	if ((inputFlags & INPUT_FLAG_FASTPATH_INPUT) || (inputFlags & INPUT_FLAG_FASTPATH_INPUT2))	{		if (settings->fast_path_input != False)			settings->fast_path_input = True;	}}

static uint32 handle_ReleaseContext(IRP* irp){	uint32 len, rv;	SCARDCONTEXT hContext = -1;	stream_seek(irp->input, 8);	stream_read_uint32(irp->input, len);	stream_seek(irp->input, 0x10);	stream_read_uint32(irp->input, hContext);	rv = SCardReleaseContext(hContext);	if (rv)		DEBUG_SCARD("%s (0x%08x)", pcsc_stringify_error(rv), (unsigned) rv);	else		DEBUG_SCARD("success 0x%08lx", hContext);	return rv;}

static void sc_input_reader_name(IRP* irp, char **dest, tbool wide){	uint32 dataLength;	stream_seek(irp->input, 8);	stream_read_uint32(irp->input, dataLength);	DEBUG_SCARD("datalength %d", dataLength);	sc_input_repos(irp, sc_input_string(irp, dest, dataLength, wide));}

void cliprdr_process_format_data_request(cliprdrPlugin* cliprdr, STREAM* s, uint32 dataLen, uint16 msgFlags){	RDP_CB_DATA_REQUEST_EVENT* cb_event;	cb_event = (RDP_CB_DATA_REQUEST_EVENT*) freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR,		RDP_EVENT_TYPE_CB_DATA_REQUEST, NULL, NULL);	stream_read_uint32(s, cb_event->format);	svc_plugin_send_event((rdpSvcPlugin*) cliprdr, (RDP_EVENT*) cb_event);}