Merge remote branch 'upstream/master'

CMakeLists.txt

@@ -98,8 +98,10 @@ endif()
 
 # Compiler-specific flags
 if(CMAKE_COMPILER_IS_GNUCC)
-	if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT ANDROID)
-    	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=i686")
+	if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "i686")
+		if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=i686")
+		endif()
 	endif()
 	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
 	CHECK_C_COMPILER_FLAG (-Wno-unused-result Wno-unused-result)
@@ -231,6 +233,10 @@ set(GSTREAMER_FEATURE_TYPE "RECOMMENDED")
 set(GSTREAMER_FEATURE_PURPOSE "multimedia")
 set(GSTREAMER_FEATURE_DESCRIPTION "multimedia redirection, audio and video playback")
 
+set(IPP_FEATURE_TYPE "OPTIONAL")
+set(IPP_FEATURE_PURPOSE "performance")
+set(IPP_FEATURE_DESCRIPTION "Intel Integrated Performance Primitives library")
+
 if(WIN32)
 	set(X11_FEATURE_TYPE "DISABLED")
 	set(ZLIB_FEATURE_TYPE "DISABLED")
@@ -285,6 +291,9 @@ find_feature(PCSC ${PCSC_FEATURE_TYPE} ${PCSC_FEATURE_PURPOSE} ${PCSC_FEATURE_DE
 find_feature(FFmpeg ${FFMPEG_FEATURE_TYPE} ${FFMPEG_FEATURE_PURPOSE} ${FFMPEG_FEATURE_DESCRIPTION})
 find_feature(Gstreamer ${GSTREAMER_FEATURE_TYPE} ${GSTREAMER_FEATURE_PURPOSE} ${GSTREAMER_FEATURE_DESCRIPTION})
 
+# Intel Performance Primitives
+find_feature(IPP ${IPP_FEATURE_TYPE} ${IPP_FEATURE_PURPOSE} ${IPP_FEATURE_DESCRIPTION})
+
 # Installation Paths
 if(WIN32)
 	set(CMAKE_INSTALL_BINDIR ".")
@@ -426,10 +435,25 @@ if(MSVC)
 		install(PROGRAMS ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS}
 			DESTINATION ${CMAKE_INSTALL_BINDIR}
 			COMPONENT libraries)
+
+
+		set(EXTRA_DATA_DIR "pre-requisites/")
+		file(GLOB EXTRA_FILES "${CMAKE_SOURCE_DIR}/extra/*")
+		install(FILES ${EXTRA_FILES}
+			DESTINATION ${EXTRA_DATA_DIR}
+			COMPONENT extra)
+
+		set(REV_DATA_DIR "REV/")
+		file(GLOB REV_FILES "${CMAKE_SOURCE_DIR}/REV/*")
+		install(FILES ${REV_FILES}
+			DESTINATION ${REV_DATA_DIR}
+			COMPONENT rev)
 	endif()
 endif()
 
-set(CPACK_COMPONENTS_ALL client server libraries headers)
+
+set(CPACK_COMPONENTS_ALL client server libraries headers extra rev)
+
 
 set(CPACK_COMPONENT_CLIENT_DISPLAY_NAME "Client")
 set(CPACK_COMPONENT_CLIENT_GROUP "Applications")

channels/cliprdr/client/cliprdr_format.c

@@ -144,6 +144,7 @@ void cliprdr_process_short_format_names(cliprdrPlugin* cliprdr, STREAM* s, UINT3
 		}
 		else
 		{
+			format_name->name = NULL;
 			format_name->length = ConvertFromUnicode(CP_UTF8, 0, (WCHAR*) s->p, 32 / 2, &format_name->name, 0, NULL, NULL);
 		}
 

channels/drive/client/drive_file.c

@@ -430,7 +430,7 @@ BOOL drive_file_query_information(DRIVE_FILE* file, UINT32 FsInformationClass, S
 
 BOOL drive_file_set_information(DRIVE_FILE* file, UINT32 FsInformationClass, UINT32 Length, STREAM* input)
 {
-	char* s;
+	char* s = NULL;
         mode_t m;
 	UINT64 size;
 	int status;
@@ -601,6 +601,7 @@ BOOL drive_file_query_directory(DRIVE_FILE* file, UINT32 FsInformationClass, BYT
 
 	DEBUG_SVC("  pattern %s matched %s", file->pattern, ent_path);
 	free(ent_path);
+	ent_path = NULL;
 
 	length = ConvertToUnicode(CP_UTF8, 0, ent->d_name, -1, &ent_path, 0) * 2;
 

channels/drive/client/drive_main.c

@@ -391,7 +391,7 @@ static void drive_process_irp_query_volume_information(DRIVE_DEVICE* disk, IRP*
 	struct STAT st;
 	char* volumeLabel = {"FREERDP"};
 	char* diskType = {"FAT32"};
-	WCHAR* outStr;
+	WCHAR* outStr = NULL;
 	int length;
 
 	stream_read_UINT32(irp->input, FsInformationClass);
@@ -471,7 +471,7 @@ static void drive_process_irp_query_volume_information(DRIVE_DEVICE* disk, IRP*
 
 static void drive_process_irp_query_directory(DRIVE_DEVICE* disk, IRP* irp)
 {
-	char* path;
+	char* path = NULL;
 	int status;
 	DRIVE_FILE* file;
 	BYTE InitialQuery;

channels/parallel/client/parallel_main.c

@@ -72,7 +72,7 @@ typedef struct _PARALLEL_DEVICE PARALLEL_DEVICE;
 
 static void parallel_process_irp_create(PARALLEL_DEVICE* parallel, IRP* irp)
 {
-	char* path;
+	char* path = NULL;
 	int status;
 	UINT32 PathLength;
 

channels/printer/client/printer_main.c

@@ -235,9 +235,9 @@ void printer_register(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, rdpPrinter* pri
 	char* port;
 	UINT32 Flags;
 	int DriverNameLen;
-	WCHAR* DriverName;
+	WCHAR* DriverName = NULL;
 	int PrintNameLen;
-	WCHAR* PrintName;
+	WCHAR* PrintName = NULL;
 	UINT32 CachedFieldsLen;
 	BYTE* CachedPrinterConfigData;
 	PRINTER_DEVICE* printer_dev;

channels/rail/client/rail_orders.c

@@ -70,7 +70,7 @@ static const char* const RAIL_ORDER_TYPE_STRINGS[] =
 
 void rail_string_to_unicode_string(rdpRailOrder* rail_order, char* string, RAIL_UNICODE_STRING* unicode_string)
 {
-	WCHAR* buffer;
+	WCHAR* buffer = NULL;
 	int length = 0;
 
 	if (unicode_string->string != NULL)
@@ -88,10 +88,13 @@ void rail_string_to_unicode_string(rdpRailOrder* rail_order, char* string, RAIL_
 	unicode_string->length = (UINT16) length;
 }
 
-void rail_read_pdu_header(STREAM* s, UINT16* orderType, UINT16* orderLength)
+BOOL rail_read_pdu_header(STREAM* s, UINT16* orderType, UINT16* orderLength)
 {
+	if(stream_get_left(s) < 4)
+		return FALSE;
 	stream_read_UINT16(s, *orderType); /* orderType (2 bytes) */
 	stream_read_UINT16(s, *orderLength); /* orderLength (2 bytes) */
+	return TRUE;
 }
 
 void rail_write_pdu_header(STREAM* s, UINT16 orderType, UINT16 orderLength)
@@ -133,23 +136,31 @@ void rail_write_high_contrast(STREAM* s, HIGH_CONTRAST* high_contrast)
 	rail_write_unicode_string(s, &high_contrast->colorScheme); /* colorScheme */
 }
 
-void rail_read_handshake_order(STREAM* s, RAIL_HANDSHAKE_ORDER* handshake)
+BOOL rail_read_handshake_order(STREAM* s, RAIL_HANDSHAKE_ORDER* handshake)
 {
+	if(stream_get_left(s) < 4)
+		return FALSE;
 	stream_read_UINT32(s, handshake->buildNumber); /* buildNumber (4 bytes) */
+	return TRUE;
 }
 
-void rail_read_server_exec_result_order(STREAM* s, RAIL_EXEC_RESULT_ORDER* exec_result)
+BOOL rail_read_server_exec_result_order(STREAM* s, RAIL_EXEC_RESULT_ORDER* exec_result)
 {
+	if(stream_get_left(s) < 8)
+		return FALSE;
 	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 */
+	return rail_read_unicode_string(s, &exec_result->exeOrFile); /* exeOrFile */
 }
 
-void rail_read_server_sysparam_order(STREAM* s, RAIL_SYSPARAM_ORDER* sysparam)
+BOOL rail_read_server_sysparam_order(STREAM* s, RAIL_SYSPARAM_ORDER* sysparam)
 {
 	BYTE body;
+
+	if(stream_get_left(s) < 5)
+		return FALSE;
 	stream_read_UINT32(s, sysparam->param); /* systemParam (4 bytes) */
 	stream_read_BYTE(s, body); /* body (1 byte) */
 
@@ -166,10 +177,13 @@ void rail_read_server_sysparam_order(STREAM* s, RAIL_SYSPARAM_ORDER* sysparam)
 		default:
 			break;
 	}
+	return TRUE;
 }
 
-void rail_read_server_minmaxinfo_order(STREAM* s, RAIL_MINMAXINFO_ORDER* minmaxinfo)
+BOOL rail_read_server_minmaxinfo_order(STREAM* s, RAIL_MINMAXINFO_ORDER* minmaxinfo)
 {
+	if(stream_get_left(s) < 20)
+		return FALSE;
 	stream_read_UINT32(s, minmaxinfo->windowId); /* windowId (4 bytes) */
 	stream_read_UINT16(s, minmaxinfo->maxWidth); /* maxWidth (2 bytes) */
 	stream_read_UINT16(s, minmaxinfo->maxHeight); /* maxHeight (2 bytes) */
@@ -179,11 +193,14 @@ void rail_read_server_minmaxinfo_order(STREAM* s, RAIL_MINMAXINFO_ORDER* minmaxi
 	stream_read_UINT16(s, minmaxinfo->minTrackHeight); /* minTrackHeight (2 bytes) */
 	stream_read_UINT16(s, minmaxinfo->maxTrackWidth); /* maxTrackWidth (2 bytes) */
 	stream_read_UINT16(s, minmaxinfo->maxTrackHeight); /* maxTrackHeight (2 bytes) */
+	return TRUE;
 }
 
-void rail_read_server_localmovesize_order(STREAM* s, RAIL_LOCALMOVESIZE_ORDER* localmovesize)
+BOOL rail_read_server_localmovesize_order(STREAM* s, RAIL_LOCALMOVESIZE_ORDER* localmovesize)
 {
 	UINT16 isMoveSizeStart;
+	if(stream_get_left(s) < 12)
+		return FALSE;
 	stream_read_UINT32(s, localmovesize->windowId); /* windowId (4 bytes) */
 
 	stream_read_UINT16(s, isMoveSizeStart); /* isMoveSizeStart (2 bytes) */
@@ -192,20 +209,27 @@ void rail_read_server_localmovesize_order(STREAM* s, RAIL_LOCALMOVESIZE_ORDER* l
 	stream_read_UINT16(s, localmovesize->moveSizeType); /* moveSizeType (2 bytes) */
 	stream_read_UINT16(s, localmovesize->posX); /* posX (2 bytes) */
 	stream_read_UINT16(s, localmovesize->posY); /* posY (2 bytes) */
+	return TRUE;
 }
 
-void rail_read_server_get_appid_resp_order(STREAM* s, RAIL_GET_APPID_RESP_ORDER* get_appid_resp)
+BOOL rail_read_server_get_appid_resp_order(STREAM* s, RAIL_GET_APPID_RESP_ORDER* get_appid_resp)
 {
+	if(stream_get_left(s) < 516)
+		return FALSE;
 	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];
+	return TRUE;
 }
 
-void rail_read_langbar_info_order(STREAM* s, RAIL_LANGBAR_INFO_ORDER* langbar_info)
+BOOL rail_read_langbar_info_order(STREAM* s, RAIL_LANGBAR_INFO_ORDER* langbar_info)
 {
+	if(stream_get_left(s) < 4)
+		return FALSE;
 	stream_read_UINT32(s, langbar_info->languageBarStatus); /* languageBarStatus (4 bytes) */
+	return TRUE;
 }
 
 void rail_write_handshake_order(STREAM* s, RAIL_HANDSHAKE_ORDER* handshake)
@@ -332,9 +356,10 @@ void rail_write_langbar_info_order(STREAM* s, RAIL_LANGBAR_INFO_ORDER* langbar_i
 	stream_write_UINT32(s, langbar_info->languageBarStatus); /* languageBarStatus (4 bytes) */
 }
 
-void rail_recv_handshake_order(rdpRailOrder* rail_order, STREAM* s)
+BOOL rail_recv_handshake_order(rdpRailOrder* rail_order, STREAM* s)
 {
-	rail_read_handshake_order(s, &rail_order->handshake);
+	if(!rail_read_handshake_order(s, &rail_order->handshake))
+		return FALSE;
 
 	rail_order->handshake.buildNumber = 0x00001DB0;
 	rail_send_handshake_order(rail_order);
@@ -371,94 +396,102 @@ void rail_recv_handshake_order(rdpRailOrder* rail_order, STREAM* s)
 
 	rail_send_channel_event(rail_order->plugin,
 		RDP_EVENT_TYPE_RAIL_CHANNEL_GET_SYSPARAMS, &rail_order->sysparam);
+	return TRUE;
 }
 
-void rail_recv_exec_result_order(rdpRailOrder* rail_order, STREAM* s)
+BOOL rail_recv_exec_result_order(rdpRailOrder* rail_order, STREAM* s)
 {
-	rail_read_server_exec_result_order(s, &rail_order->exec_result);
+	if(!rail_read_server_exec_result_order(s, &rail_order->exec_result))
+		return FALSE;
 	rail_send_channel_event(rail_order->plugin,
 		RDP_EVENT_TYPE_RAIL_CHANNEL_EXEC_RESULTS, &rail_order->exec_result);
+	return TRUE;
 }
 
-void rail_recv_server_sysparam_order(rdpRailOrder* rail_order, STREAM* s)
+BOOL rail_recv_server_sysparam_order(rdpRailOrder* rail_order, STREAM* s)
 {
-	rail_read_server_sysparam_order(s, &rail_order->sysparam);
+	if(!rail_read_server_sysparam_order(s, &rail_order->sysparam))
+		return FALSE;
 	rail_send_channel_event(rail_order->plugin,
 		RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_SYSPARAM, &rail_order->sysparam);
+	return TRUE;
 }
 
-void rail_recv_server_minmaxinfo_order(rdpRailOrder* rail_order, STREAM* s)
+BOOL rail_recv_server_minmaxinfo_order(rdpRailOrder* rail_order, STREAM* s)
 {
-	rail_read_server_minmaxinfo_order(s, &rail_order->minmaxinfo);
+	if(!rail_read_server_minmaxinfo_order(s, &rail_order->minmaxinfo))
+		return FALSE;
 	rail_send_channel_event(rail_order->plugin,
 		RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_MINMAXINFO, &rail_order->minmaxinfo);
+	return TRUE;
 }
 
-void rail_recv_server_localmovesize_order(rdpRailOrder* rail_order, STREAM* s)
+BOOL rail_recv_server_localmovesize_order(rdpRailOrder* rail_order, STREAM* s)
 {
-	rail_read_server_localmovesize_order(s, &rail_order->localmovesize);
+	if(!rail_read_server_localmovesize_order(s, &rail_order->localmovesize))
+		return FALSE;
 	rail_send_channel_event(rail_order->plugin,
 		RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_LOCALMOVESIZE, &rail_order->localmovesize);
+	return TRUE;
 }
 
-void rail_recv_server_get_appid_resp_order(rdpRailOrder* rail_order, STREAM* s)
+BOOL rail_recv_server_get_appid_resp_order(rdpRailOrder* rail_order, STREAM* s)
 {
-	rail_read_server_get_appid_resp_order(s, &rail_order->get_appid_resp);
+	if(!rail_read_server_get_appid_resp_order(s, &rail_order->get_appid_resp))
+		return FALSE;
 	rail_send_channel_event(rail_order->plugin,
 		RDP_EVENT_TYPE_RAIL_CHANNEL_APPID_RESP, &rail_order->get_appid_resp);
+	return TRUE;
 }
 
-void rail_recv_langbar_info_order(rdpRailOrder* rail_order, STREAM* s)
+BOOL rail_recv_langbar_info_order(rdpRailOrder* rail_order, STREAM* s)
 {
-	rail_read_langbar_info_order(s, &rail_order->langbar_info);
+	if(!rail_read_langbar_info_order(s, &rail_order->langbar_info))
+		return FALSE;
 	rail_send_channel_event(rail_order->plugin,
 		RDP_EVENT_TYPE_RAIL_CHANNEL_LANGBARINFO, &rail_order->langbar_info);
+	return TRUE;
 }
 
-void rail_order_recv(rdpRailOrder* rail_order, STREAM* s)
+BOOL rail_order_recv(rdpRailOrder* rail_order, STREAM* s)
 {
 	UINT16 orderType;
 	UINT16 orderLength;
 
-	rail_read_pdu_header(s, &orderType, &orderLength);
+	if(!rail_read_pdu_header(s, &orderType, &orderLength))
+		return FALSE;
 
 	DEBUG_RAIL("Received %s PDU, length:%d",
 			RAIL_ORDER_TYPE_STRINGS[((orderType & 0xF0) >> 3) + (orderType & 0x0F)], orderLength);
 
 	switch (orderType)
 	{
 		case RDP_RAIL_ORDER_HANDSHAKE:
-			rail_recv_handshake_order(rail_order, s);
-			break;
+			return rail_recv_handshake_order(rail_order, s);
 
 		case RDP_RAIL_ORDER_EXEC_RESULT:
-			rail_recv_exec_result_order(rail_order, s);
-			break;
+			return rail_recv_exec_result_order(rail_order, s);
 
 		case RDP_RAIL_ORDER_SYSPARAM:
-			rail_recv_server_sysparam_order(rail_order, s);
-			break;
+			return rail_recv_server_sysparam_order(rail_order, s);
 
 		case RDP_RAIL_ORDER_MINMAXINFO:
-			rail_recv_server_minmaxinfo_order(rail_order, s);
-			break;
+			return rail_recv_server_minmaxinfo_order(rail_order, s);
 
 		case RDP_RAIL_ORDER_LOCALMOVESIZE:
-			rail_recv_server_localmovesize_order(rail_order, s);
-			break;
+			return rail_recv_server_localmovesize_order(rail_order, s);
 
 		case RDP_RAIL_ORDER_GET_APPID_RESP:
-			rail_recv_server_get_appid_resp_order(rail_order, s);
-			break;
+			return rail_recv_server_get_appid_resp_order(rail_order, s);
 
 		case RDP_RAIL_ORDER_LANGBARINFO:
-			rail_recv_langbar_info_order(rail_order, s);
-			break;
+			return rail_recv_langbar_info_order(rail_order, s);
 
 		default:
 			printf("Unknown RAIL PDU order reveived.");
 			break;
 	}
+	return TRUE;
 }
 
 void rail_send_handshake_order(rdpRailOrder* rail_order)