示例#1
0
文件: gcc.c 项目: ArthurGodoy/FreeRDP
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;
}
示例#2
0
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);
}
示例#3
0
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);
	}
}
示例#4
0
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);
}
示例#5
0
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);
}
示例#6
0
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;
}
示例#7
0
文件: rts.c 项目: ArthurGodoy/FreeRDP
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) */
}
示例#8
0
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;
}
示例#9
0
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;
}
示例#10
0
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;
	}
}
示例#11
0
文件: window.c 项目: kidfolk/FreeRDP
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);
	}
}
示例#12
0
文件: string.c 项目: felfert/FreeRDP
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);
}
示例#13
0
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;
}
示例#14
0
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);
}
示例#15
0
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);
}
示例#16
0
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];
}
示例#17
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 */
}
示例#18
0
文件: gcc.c 项目: ArthurGodoy/FreeRDP
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;
}
示例#19
0
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);
}
示例#20
0
文件: rdp.c 项目: mwu406/FreeRDP-1.0
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);
}
示例#21
0
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;
}
示例#22
0
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;
}
示例#23
0
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);
}
示例#24
0
文件: rdp.c 项目: kidfolk/FreeRDP
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);
}
示例#25
0
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;
}
示例#26
0
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;
	}
}
示例#27
0
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;
}
示例#28
0
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));
}
示例#29
0
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);
}
示例#30
0
static void rfx_process_message_frame_begin(RFX_CONTEXT* context, RFX_MESSAGE* message, STREAM* s)
{
	uint32 frameIdx;
	uint16 numRegions;

	stream_read_uint32(s, frameIdx); /* frameIdx (4 bytes), if codec is in video mode, must be ignored */
	stream_read_uint16(s, numRegions); /* numRegions (2 bytes) */

	DEBUG_RFX("RFX_FRAME_BEGIN: frameIdx:%d numRegions:%d", frameIdx, numRegions);
}