Adding upstream version 3.3.0+dfsg1.upstream/3.3.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

9 files changed, 2273 insertions, 0 deletions

diff --git a/channels/printer/CMakeLists.txt b/channels/printer/CMakeLists.txt
new file mode 100644
index 0000000..73cb415
--- /dev/null
+++ b/channels/printer/CMakeLists.txt
@@ -0,0 +1,22 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+define_channel("printer")
+
+if(WITH_CLIENT_CHANNELS)
+	add_channel_client(${MODULE_PREFIX} ${CHANNEL_NAME})
+endif()
\ No newline at end of file
diff --git a/channels/printer/ChannelOptions.cmake b/channels/printer/ChannelOptions.cmake
new file mode 100644
index 0000000..2989ba5
--- /dev/null
+++ b/channels/printer/ChannelOptions.cmake
@@ -0,0 +1,33 @@
+
+set(OPTION_DEFAULT OFF)
+set(OPTION_CLIENT_DEFAULT ON)
+set(OPTION_SERVER_DEFAULT OFF)
+
+if(WIN32)
+	set(OPTION_CLIENT_DEFAULT ON)
+	set(OPTION_SERVER_DEFAULT OFF)
+else()
+    # cups is available on mac os and linux by default, on android it is optional.
+    if (NOT IOS AND NOT ANDROID)
+        set(CUPS_DEFAULT ON)
+    else()
+        set(CUPS_DEFAULT OFF)
+    endif()
+    option(WITH_CUPS "CUPS printer support" ${CUPS_DEFAULT})
+    if(WITH_CUPS)
+        set(OPTION_CLIENT_DEFAULT ON)
+        set(OPTION_SERVER_DEFAULT OFF)
+    else()
+        set(OPTION_CLIENT_DEFAULT OFF)
+        set(OPTION_SERVER_DEFAULT OFF)
+    endif()
+endif()
+
+define_channel_options(NAME "printer" TYPE "device"
+	DESCRIPTION "Print Virtual Channel Extension"
+	SPECIFICATIONS "[MS-RDPEPC]"
+	DEFAULT ${OPTION_DEFAULT})
+
+define_channel_client_options(${OPTION_CLIENT_DEFAULT})
+define_channel_server_options(${OPTION_SERVER_DEFAULT})
+
diff --git a/channels/printer/client/CMakeLists.txt b/channels/printer/client/CMakeLists.txt
new file mode 100644
index 0000000..e7bab09
--- /dev/null
+++ b/channels/printer/client/CMakeLists.txt
@@ -0,0 +1,35 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+define_channel_client("printer")
+
+set(${MODULE_PREFIX}_SRCS
+	printer_main.c
+)
+
+set(${MODULE_PREFIX}_LIBS
+	winpr freerdp
+)
+add_channel_client_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} TRUE "DeviceServiceEntry")
+
+if(WITH_CUPS)
+	add_channel_client_subsystem(${MODULE_PREFIX} ${CHANNEL_NAME} "cups" "")
+endif()
+
+if(WIN32 AND NOT UWP)
+	add_channel_client_subsystem(${MODULE_PREFIX} ${CHANNEL_NAME} "win" "")
+endif()
diff --git a/channels/printer/client/cups/CMakeLists.txt b/channels/printer/client/cups/CMakeLists.txt
new file mode 100644
index 0000000..c6b6f0e
--- /dev/null
+++ b/channels/printer/client/cups/CMakeLists.txt
@@ -0,0 +1,33 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP cmake build script
+#
+# Copyright 2019 Armin Novak <armin.novak@thincast.com>
+# Copyright 2019 Thincast Technologies GmbH
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+define_channel_client_subsystem("printer" "cups" "")
+
+find_package(Cups 2.0 REQUIRED)
+set(${MODULE_PREFIX}_SRCS
+		printer_cups.c)
+
+set(${MODULE_PREFIX}_LIBS
+    winpr
+    freerdp
+     ${CUPS_LIBRARIES}
+)
+
+include_directories(..)
+include_directories(${CUPS_INCLUDE_DIRS})
+
+add_channel_client_subsystem_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} "" TRUE "")
diff --git a/channels/printer/client/cups/printer_cups.c b/channels/printer/client/cups/printer_cups.c
new file mode 100644
index 0000000..043b44e
--- /dev/null
+++ b/channels/printer/client/cups/printer_cups.c
@@ -0,0 +1,462 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Print Virtual Channel - CUPS driver
+ *
+ * Copyright 2010-2011 Vic Lee
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
+ * Copyright 2016 Armin Novak <armin.novak@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <winpr/assert.h>
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+#include <time.h>
+#include <cups/cups.h>
+
+#include <winpr/crt.h>
+#include <winpr/file.h>
+#include <winpr/string.h>
+
+#include <freerdp/channels/rdpdr.h>
+
+#include <freerdp/client/printer.h>
+
+#include <freerdp/channels/log.h>
+#define TAG CHANNELS_TAG("printer.client.cups")
+
+#if defined(__APPLE__)
+#include <errno.h>
+#include <sys/sysctl.h>
+
+static bool is_mac_os_sonoma_or_later(void)
+{
+	char str[256] = { 0 };
+	size_t size = sizeof(str);
+
+	errno = 0;
+	int ret = sysctlbyname("kern.osrelease", str, &size, NULL, 0);
+	if (ret != 0)
+	{
+		char buffer[256] = { 0 };
+		WLog_WARN(TAG, "sysctlbyname('kern.osrelease') failed with %s [%d]",
+		          winpr_strerror(errno, buffer, sizeof(buffer)), errno);
+		return false;
+	}
+
+	int major = 0;
+	int minor = 0;
+	int patch = 0;
+	const int rc = sscanf(str, "%d.%d.%d", &major, &minor, &patch);
+	if (rc != 3)
+	{
+		WLog_WARN(TAG, "could not match '%s' to format '%d.%d.%d'");
+		return false;
+	}
+
+	if (major < 23)
+		return false;
+	return true;
+}
+#endif
+
+typedef struct
+{
+	rdpPrinterDriver driver;
+
+	size_t id_sequence;
+	size_t references;
+} rdpCupsPrinterDriver;
+
+typedef struct
+{
+	rdpPrintJob printjob;
+
+	http_t* printjob_object;
+	int printjob_id;
+} rdpCupsPrintJob;
+
+typedef struct
+{
+	rdpPrinter printer;
+
+	rdpCupsPrintJob* printjob;
+} rdpCupsPrinter;
+
+static void printer_cups_get_printjob_name(char* buf, size_t size, size_t id)
+{
+	struct tm tres;
+	const time_t tt = time(NULL);
+	const struct tm* t = localtime_r(&tt, &tres);
+
+	WINPR_ASSERT(buf);
+	WINPR_ASSERT(size > 0);
+
+	sprintf_s(buf, size - 1, "FreeRDP Print %04d-%02d-%02d %02d-%02d-%02d - Job %" PRIdz,
+	          t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, id);
+}
+
+static bool http_status_ok(http_status_t status)
+{
+	switch (status)
+	{
+		case HTTP_OK:
+		case HTTP_CONTINUE:
+			return true;
+		default:
+			return false;
+	}
+}
+
+static UINT write_printjob(rdpPrintJob* printjob, const BYTE* data, size_t size)
+{
+	rdpCupsPrintJob* cups_printjob = (rdpCupsPrintJob*)printjob;
+
+	WINPR_ASSERT(cups_printjob);
+
+	http_status_t rc =
+	    cupsWriteRequestData(cups_printjob->printjob_object, (const char*)data, size);
+	if (!http_status_ok(rc))
+		WLog_WARN(TAG, "cupsWriteRequestData returned %s", httpStatus(rc));
+
+	return CHANNEL_RC_OK;
+}
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_cups_write_printjob(rdpPrintJob* printjob, const BYTE* data, size_t size)
+{
+	rdpCupsPrintJob* cups_printjob = (rdpCupsPrintJob*)printjob;
+
+	WINPR_ASSERT(cups_printjob);
+
+	return write_printjob(printjob, data, size);
+}
+
+static void printer_cups_close_printjob(rdpPrintJob* printjob)
+{
+	rdpCupsPrintJob* cups_printjob = (rdpCupsPrintJob*)printjob;
+	rdpCupsPrinter* cups_printer = NULL;
+
+	WINPR_ASSERT(cups_printjob);
+
+	ipp_status_t rc = cupsFinishDocument(cups_printjob->printjob_object, printjob->printer->name);
+	if (rc != IPP_OK)
+		WLog_WARN(TAG, "cupsFinishDocument returned %s", ippErrorString(rc));
+
+	cups_printjob->printjob_id = 0;
+	httpClose(cups_printjob->printjob_object);
+
+	cups_printer = (rdpCupsPrinter*)printjob->printer;
+	WINPR_ASSERT(cups_printer);
+
+	cups_printer->printjob = NULL;
+	free(cups_printjob);
+}
+
+static rdpPrintJob* printer_cups_create_printjob(rdpPrinter* printer, UINT32 id)
+{
+	rdpCupsPrinter* cups_printer = (rdpCupsPrinter*)printer;
+	rdpCupsPrintJob* cups_printjob = NULL;
+
+	WINPR_ASSERT(cups_printer);
+
+	if (cups_printer->printjob != NULL)
+	{
+		WLog_WARN(TAG, "printjob [printer '%s'] already existing, abort!", printer->name);
+		return NULL;
+	}
+
+	cups_printjob = (rdpCupsPrintJob*)calloc(1, sizeof(rdpCupsPrintJob));
+	if (!cups_printjob)
+		return NULL;
+
+	cups_printjob->printjob.id = id;
+	cups_printjob->printjob.printer = printer;
+
+	cups_printjob->printjob.Write = printer_cups_write_printjob;
+	cups_printjob->printjob.Close = printer_cups_close_printjob;
+
+	{
+		char buf[100] = { 0 };
+
+		cups_printjob->printjob_object = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC,
+		                                              HTTP_ENCRYPT_IF_REQUESTED, 1, 10000, NULL);
+
+		if (!cups_printjob->printjob_object)
+		{
+			WLog_WARN(TAG, "httpConnect2 failed for '%s:%d", cupsServer(), ippPort());
+			free(cups_printjob);
+			return NULL;
+		}
+
+		printer_cups_get_printjob_name(buf, sizeof(buf), cups_printjob->printjob.id);
+
+		cups_printjob->printjob_id =
+		    cupsCreateJob(cups_printjob->printjob_object, printer->name, buf, 0, NULL);
+
+		if (!cups_printjob->printjob_id)
+		{
+			WLog_WARN(TAG, "cupsCreateJob failed for printer '%s', driver '%s'", printer->name,
+			          printer->driver);
+			httpClose(cups_printjob->printjob_object);
+			free(cups_printjob);
+			return NULL;
+		}
+
+		http_status_t rc = cupsStartDocument(cups_printjob->printjob_object, printer->name,
+		                                     cups_printjob->printjob_id, buf, CUPS_FORMAT_AUTO, 1);
+		if (!http_status_ok(rc))
+			WLog_WARN(TAG, "cupsStartDocument [printer '%s', driver '%s'] returned %s",
+			          printer->name, printer->driver, httpStatus(rc));
+	}
+
+	cups_printer->printjob = cups_printjob;
+
+	return &cups_printjob->printjob;
+}
+
+static rdpPrintJob* printer_cups_find_printjob(rdpPrinter* printer, UINT32 id)
+{
+	rdpCupsPrinter* cups_printer = (rdpCupsPrinter*)printer;
+
+	WINPR_ASSERT(cups_printer);
+
+	if (cups_printer->printjob == NULL)
+		return NULL;
+	if (cups_printer->printjob->printjob.id != id)
+		return NULL;
+
+	return &cups_printer->printjob->printjob;
+}
+
+static void printer_cups_free_printer(rdpPrinter* printer)
+{
+	rdpCupsPrinter* cups_printer = (rdpCupsPrinter*)printer;
+
+	WINPR_ASSERT(cups_printer);
+
+	if (cups_printer->printjob)
+	{
+		WINPR_ASSERT(cups_printer->printjob->printjob.Close);
+		cups_printer->printjob->printjob.Close(&cups_printer->printjob->printjob);
+	}
+
+	if (printer->backend)
+	{
+		WINPR_ASSERT(printer->backend->ReleaseRef);
+		printer->backend->ReleaseRef(printer->backend);
+	}
+	free(printer->name);
+	free(printer->driver);
+	free(printer);
+}
+
+static void printer_cups_add_ref_printer(rdpPrinter* printer)
+{
+	if (printer)
+		printer->references++;
+}
+
+static void printer_cups_release_ref_printer(rdpPrinter* printer)
+{
+	if (!printer)
+		return;
+	if (printer->references <= 1)
+		printer_cups_free_printer(printer);
+	else
+		printer->references--;
+}
+
+static rdpPrinter* printer_cups_new_printer(rdpCupsPrinterDriver* cups_driver, const char* name,
+                                            const char* driverName, BOOL is_default)
+{
+	rdpCupsPrinter* cups_printer = NULL;
+
+	cups_printer = (rdpCupsPrinter*)calloc(1, sizeof(rdpCupsPrinter));
+	if (!cups_printer)
+		return NULL;
+
+	cups_printer->printer.backend = &cups_driver->driver;
+
+	cups_printer->printer.id = cups_driver->id_sequence++;
+	cups_printer->printer.name = _strdup(name);
+	if (!cups_printer->printer.name)
+		goto fail;
+
+	if (driverName)
+		cups_printer->printer.driver = _strdup(driverName);
+	else
+	{
+		const char* dname = "MS Publisher Imagesetter";
+#if defined(__APPLE__)
+		if (is_mac_os_sonoma_or_later())
+			dname = "Microsoft Print to PDF";
+#endif
+		cups_printer->printer.driver = _strdup(dname);
+	}
+	if (!cups_printer->printer.driver)
+		goto fail;
+
+	cups_printer->printer.is_default = is_default;
+
+	cups_printer->printer.CreatePrintJob = printer_cups_create_printjob;
+	cups_printer->printer.FindPrintJob = printer_cups_find_printjob;
+	cups_printer->printer.AddRef = printer_cups_add_ref_printer;
+	cups_printer->printer.ReleaseRef = printer_cups_release_ref_printer;
+
+	WINPR_ASSERT(cups_printer->printer.AddRef);
+	cups_printer->printer.AddRef(&cups_printer->printer);
+
+	WINPR_ASSERT(cups_printer->printer.backend->AddRef);
+	cups_printer->printer.backend->AddRef(cups_printer->printer.backend);
+
+	return &cups_printer->printer;
+
+fail:
+	printer_cups_free_printer(&cups_printer->printer);
+	return NULL;
+}
+
+static void printer_cups_release_enum_printers(rdpPrinter** printers)
+{
+	rdpPrinter** cur = printers;
+
+	while ((cur != NULL) && ((*cur) != NULL))
+	{
+		if ((*cur)->ReleaseRef)
+			(*cur)->ReleaseRef(*cur);
+		cur++;
+	}
+	free(printers);
+}
+
+static rdpPrinter** printer_cups_enum_printers(rdpPrinterDriver* driver)
+{
+	rdpPrinter** printers = NULL;
+	int num_printers = 0;
+	cups_dest_t* dests = NULL;
+	BOOL haveDefault = FALSE;
+	const int num_dests = cupsGetDests(&dests);
+
+	WINPR_ASSERT(driver);
+	if (num_dests >= 0)
+		printers = (rdpPrinter**)calloc((size_t)num_dests + 1, sizeof(rdpPrinter*));
+	if (!printers)
+		return NULL;
+
+	for (size_t i = 0; i < num_dests; i++)
+	{
+		const cups_dest_t* dest = &dests[i];
+		if (dest->instance == NULL)
+		{
+			rdpPrinter* current = printer_cups_new_printer((rdpCupsPrinterDriver*)driver,
+			                                               dest->name, NULL, dest->is_default);
+			if (!current)
+			{
+				printer_cups_release_enum_printers(printers);
+				printers = NULL;
+				break;
+			}
+
+			if (current->is_default)
+				haveDefault = TRUE;
+
+			printers[num_printers++] = current;
+		}
+	}
+	cupsFreeDests(num_dests, dests);
+
+	if (!haveDefault && (num_dests > 0) && printers)
+	{
+		if (printers[0])
+			printers[0]->is_default = TRUE;
+	}
+
+	return printers;
+}
+
+static rdpPrinter* printer_cups_get_printer(rdpPrinterDriver* driver, const char* name,
+                                            const char* driverName, BOOL isDefault)
+{
+	rdpCupsPrinterDriver* cups_driver = (rdpCupsPrinterDriver*)driver;
+
+	WINPR_ASSERT(cups_driver);
+	return printer_cups_new_printer(cups_driver, name, driverName, isDefault);
+}
+
+static void printer_cups_add_ref_driver(rdpPrinterDriver* driver)
+{
+	rdpCupsPrinterDriver* cups_driver = (rdpCupsPrinterDriver*)driver;
+	if (cups_driver)
+		cups_driver->references++;
+}
+
+/* Singleton */
+static rdpCupsPrinterDriver* uniq_cups_driver = NULL;
+
+static void printer_cups_release_ref_driver(rdpPrinterDriver* driver)
+{
+	rdpCupsPrinterDriver* cups_driver = (rdpCupsPrinterDriver*)driver;
+
+	WINPR_ASSERT(cups_driver);
+
+	if (cups_driver->references <= 1)
+	{
+		if (uniq_cups_driver == cups_driver)
+			uniq_cups_driver = NULL;
+		free(cups_driver);
+	}
+	else
+		cups_driver->references--;
+}
+
+FREERDP_ENTRY_POINT(UINT cups_freerdp_printer_client_subsystem_entry(void* arg))
+{
+	rdpPrinterDriver** ppPrinter = (rdpPrinterDriver**)arg;
+	if (!ppPrinter)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!uniq_cups_driver)
+	{
+		uniq_cups_driver = (rdpCupsPrinterDriver*)calloc(1, sizeof(rdpCupsPrinterDriver));
+
+		if (!uniq_cups_driver)
+			return ERROR_OUTOFMEMORY;
+
+		uniq_cups_driver->driver.EnumPrinters = printer_cups_enum_printers;
+		uniq_cups_driver->driver.ReleaseEnumPrinters = printer_cups_release_enum_printers;
+		uniq_cups_driver->driver.GetPrinter = printer_cups_get_printer;
+
+		uniq_cups_driver->driver.AddRef = printer_cups_add_ref_driver;
+		uniq_cups_driver->driver.ReleaseRef = printer_cups_release_ref_driver;
+
+		uniq_cups_driver->id_sequence = 1;
+	}
+
+	WINPR_ASSERT(uniq_cups_driver->driver.AddRef);
+	uniq_cups_driver->driver.AddRef(&uniq_cups_driver->driver);
+
+	*ppPrinter = &uniq_cups_driver->driver;
+	return CHANNEL_RC_OK;
+}
diff --git a/channels/printer/client/printer_main.c b/channels/printer/client/printer_main.c
new file mode 100644
index 0000000..2aeb3f4
--- /dev/null
+++ b/channels/printer/client/printer_main.c
@@ -0,0 +1,1159 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Print Virtual Channel
+ *
+ * Copyright 2010-2011 Vic Lee
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
+ * Copyright 2016 Armin Novak <armin.novak@gmail.com>
+ * Copyright 2016 David PHAM-VAN <d.phamvan@inuvika.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+#include <winpr/string.h>
+#include <winpr/synch.h>
+#include <winpr/thread.h>
+#include <winpr/stream.h>
+#include <winpr/interlocked.h>
+#include <winpr/path.h>
+
+#include <freerdp/channels/rdpdr.h>
+#include <freerdp/crypto/crypto.h>
+#include <freerdp/freerdp.h>
+
+#include "../printer.h"
+
+#include <freerdp/client/printer.h>
+
+#include <freerdp/channels/log.h>
+
+#define TAG CHANNELS_TAG("printer.client")
+
+typedef struct
+{
+	DEVICE device;
+
+	rdpPrinter* printer;
+
+	WINPR_PSLIST_HEADER pIrpList;
+
+	HANDLE event;
+	HANDLE stopEvent;
+
+	HANDLE thread;
+	rdpContext* rdpcontext;
+	char port[64];
+} PRINTER_DEVICE;
+
+typedef enum
+{
+	PRN_CONF_PORT = 0,
+	PRN_CONF_PNP = 1,
+	PRN_CONF_DRIVER = 2,
+	PRN_CONF_DATA = 3
+} prn_conf_t;
+
+static const char* filemap[] = { "PortDosName", "PnPName", "DriverName",
+	                             "CachedPrinterConfigData" };
+
+static char* get_printer_config_path(const rdpSettings* settings, const WCHAR* name, size_t length)
+{
+	const char* path = freerdp_settings_get_string(settings, FreeRDP_ConfigPath);
+	char* dir = GetCombinedPath(path, "printers");
+	char* bname = crypto_base64_encode((const BYTE*)name, length);
+	char* config = GetCombinedPath(dir, bname);
+
+	if (config && !winpr_PathFileExists(config))
+	{
+		if (!winpr_PathMakePath(config, NULL))
+		{
+			free(config);
+			config = NULL;
+		}
+	}
+
+	free(dir);
+	free(bname);
+	return config;
+}
+
+static BOOL printer_write_setting(const char* path, prn_conf_t type, const void* data,
+                                  size_t length)
+{
+	DWORD written = 0;
+	BOOL rc = FALSE;
+	HANDLE file = NULL;
+	size_t b64len = 0;
+	char* base64 = NULL;
+	const char* name = filemap[type];
+	char* abs = GetCombinedPath(path, name);
+
+	if (!abs || (length > INT32_MAX))
+	{
+		free(abs);
+		return FALSE;
+	}
+
+	file = CreateFileA(abs, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+	free(abs);
+
+	if (file == INVALID_HANDLE_VALUE)
+		return FALSE;
+
+	if (length > 0)
+	{
+		base64 = crypto_base64_encode(data, length);
+
+		if (!base64)
+			goto fail;
+
+		/* base64 char represents 6bit -> 4*(n/3) is the length which is
+		 * always smaller than 2*n */
+		b64len = strnlen(base64, 2 * length);
+		rc = WriteFile(file, base64, b64len, &written, NULL);
+
+		if (b64len != written)
+			rc = FALSE;
+	}
+	else
+		rc = TRUE;
+
+fail:
+	CloseHandle(file);
+	free(base64);
+	return rc;
+}
+
+static BOOL printer_config_valid(const char* path)
+{
+	if (!path)
+		return FALSE;
+
+	if (!winpr_PathFileExists(path))
+		return FALSE;
+
+	return TRUE;
+}
+
+static BOOL printer_read_setting(const char* path, prn_conf_t type, void** data, UINT32* length)
+{
+	DWORD lowSize = 0;
+	DWORD highSize = 0;
+	DWORD read = 0;
+	BOOL rc = FALSE;
+	HANDLE file = NULL;
+	char* fdata = NULL;
+	const char* name = filemap[type];
+	char* abs = GetCombinedPath(path, name);
+
+	if (!abs)
+		return FALSE;
+
+	file = CreateFileA(abs, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	free(abs);
+
+	if (file == INVALID_HANDLE_VALUE)
+		return FALSE;
+
+	lowSize = GetFileSize(file, &highSize);
+
+	if ((lowSize == INVALID_FILE_SIZE) || (highSize != 0))
+		goto fail;
+
+	if (lowSize != 0)
+	{
+		fdata = malloc(lowSize);
+
+		if (!fdata)
+			goto fail;
+
+		rc = ReadFile(file, fdata, lowSize, &read, NULL);
+
+		if (lowSize != read)
+			rc = FALSE;
+	}
+
+fail:
+	CloseHandle(file);
+
+	if (rc && (lowSize <= INT_MAX))
+	{
+		size_t blen = 0;
+		crypto_base64_decode(fdata, lowSize, (BYTE**)data, &blen);
+
+		if (*data && (blen > 0))
+			*length = (UINT32)blen;
+		else
+		{
+			rc = FALSE;
+			*length = 0;
+		}
+	}
+	else
+	{
+		*length = 0;
+		*data = NULL;
+	}
+
+	free(fdata);
+	return rc;
+}
+
+static BOOL printer_save_to_config(const rdpSettings* settings, const char* PortDosName,
+                                   size_t PortDosNameLen, const WCHAR* PnPName, size_t PnPNameLen,
+                                   const WCHAR* DriverName, size_t DriverNameLen,
+                                   const WCHAR* PrinterName, size_t PrintNameLen,
+                                   const BYTE* CachedPrinterConfigData, size_t CacheFieldsLen)
+{
+	BOOL rc = FALSE;
+	char* path = get_printer_config_path(settings, PrinterName, PrintNameLen);
+
+	if (!path)
+		goto fail;
+
+	if (!printer_write_setting(path, PRN_CONF_PORT, PortDosName, PortDosNameLen))
+		goto fail;
+
+	if (!printer_write_setting(path, PRN_CONF_PNP, PnPName, PnPNameLen))
+		goto fail;
+
+	if (!printer_write_setting(path, PRN_CONF_DRIVER, DriverName, DriverNameLen))
+		goto fail;
+
+	if (!printer_write_setting(path, PRN_CONF_DATA, CachedPrinterConfigData, CacheFieldsLen))
+		goto fail;
+
+fail:
+	free(path);
+	return rc;
+}
+
+static BOOL printer_update_to_config(const rdpSettings* settings, const WCHAR* name, size_t length,
+                                     const BYTE* data, size_t datalen)
+{
+	BOOL rc = FALSE;
+	char* path = get_printer_config_path(settings, name, length);
+	rc = printer_write_setting(path, PRN_CONF_DATA, data, datalen);
+	free(path);
+	return rc;
+}
+
+static BOOL printer_remove_config(const rdpSettings* settings, const WCHAR* name, size_t length)
+{
+	BOOL rc = FALSE;
+	char* path = get_printer_config_path(settings, name, length);
+
+	if (!printer_config_valid(path))
+		goto fail;
+
+	rc = winpr_RemoveDirectory(path);
+fail:
+	free(path);
+	return rc;
+}
+
+static BOOL printer_move_config(const rdpSettings* settings, const WCHAR* oldName, size_t oldLength,
+                                const WCHAR* newName, size_t newLength)
+{
+	BOOL rc = FALSE;
+	char* oldPath = get_printer_config_path(settings, oldName, oldLength);
+	char* newPath = get_printer_config_path(settings, newName, newLength);
+
+	if (printer_config_valid(oldPath))
+		rc = winpr_MoveFile(oldPath, newPath);
+
+	free(oldPath);
+	free(newPath);
+	return rc;
+}
+
+static BOOL printer_load_from_config(const rdpSettings* settings, rdpPrinter* printer,
+                                     PRINTER_DEVICE* printer_dev)
+{
+	BOOL res = FALSE;
+	WCHAR* wname = NULL;
+	size_t wlen = 0;
+	char* path = NULL;
+	UINT32 flags = 0;
+	void* DriverName = NULL;
+	UINT32 DriverNameLen = 0;
+	void* PnPName = NULL;
+	UINT32 PnPNameLen = 0;
+	void* CachedPrinterConfigData = NULL;
+	UINT32 CachedFieldsLen = 0;
+	UINT32 PrinterNameLen = 0;
+
+	if (!settings || !printer || !printer->name)
+		return FALSE;
+
+	wname = ConvertUtf8ToWCharAlloc(printer->name, &wlen);
+
+	if (!wname)
+		goto fail;
+
+	wlen++;
+	path = get_printer_config_path(settings, wname, wlen * sizeof(WCHAR));
+	PrinterNameLen = wlen * sizeof(WCHAR);
+
+	if (!path)
+		goto fail;
+
+	if (printer->is_default)
+		flags |= RDPDR_PRINTER_ANNOUNCE_FLAG_DEFAULTPRINTER;
+
+	if (!printer_read_setting(path, PRN_CONF_PNP, &PnPName, &PnPNameLen))
+	{
+	}
+
+	if (!printer_read_setting(path, PRN_CONF_DRIVER, &DriverName, &DriverNameLen))
+	{
+		size_t len = 0;
+		DriverName = ConvertUtf8ToWCharAlloc(printer->driver, &len);
+		if (!DriverName)
+			goto fail;
+		DriverNameLen = (len + 1) * sizeof(WCHAR);
+	}
+
+	if (!printer_read_setting(path, PRN_CONF_DATA, &CachedPrinterConfigData, &CachedFieldsLen))
+	{
+	}
+
+	Stream_SetPosition(printer_dev->device.data, 0);
+
+	if (!Stream_EnsureRemainingCapacity(printer_dev->device.data, 24))
+		goto fail;
+
+	Stream_Write_UINT32(printer_dev->device.data, flags);
+	Stream_Write_UINT32(printer_dev->device.data, 0);          /* CodePage, reserved */
+	Stream_Write_UINT32(printer_dev->device.data, PnPNameLen); /* PnPNameLen */
+	Stream_Write_UINT32(printer_dev->device.data, DriverNameLen);
+	Stream_Write_UINT32(printer_dev->device.data, PrinterNameLen);
+	Stream_Write_UINT32(printer_dev->device.data, CachedFieldsLen);
+
+	if (!Stream_EnsureRemainingCapacity(printer_dev->device.data, PnPNameLen))
+		goto fail;
+
+	if (PnPNameLen > 0)
+		Stream_Write(printer_dev->device.data, PnPName, PnPNameLen);
+
+	if (!Stream_EnsureRemainingCapacity(printer_dev->device.data, DriverNameLen))
+		goto fail;
+
+	Stream_Write(printer_dev->device.data, DriverName, DriverNameLen);
+
+	if (!Stream_EnsureRemainingCapacity(printer_dev->device.data, PrinterNameLen))
+		goto fail;
+
+	union
+	{
+		char c[2];
+		WCHAR w;
+	} backslash;
+	backslash.c[0] = '\\';
+	backslash.c[1] = '\0';
+
+	for (WCHAR* wptr = wname; (wptr = _wcschr(wptr, backslash.w));)
+		*wptr = L'_';
+	Stream_Write(printer_dev->device.data, wname, PrinterNameLen);
+
+	if (!Stream_EnsureRemainingCapacity(printer_dev->device.data, CachedFieldsLen))
+		goto fail;
+
+	Stream_Write(printer_dev->device.data, CachedPrinterConfigData, CachedFieldsLen);
+	res = TRUE;
+fail:
+	free(path);
+	free(wname);
+	free(PnPName);
+	free(DriverName);
+	free(CachedPrinterConfigData);
+	return res;
+}
+
+static BOOL printer_save_default_config(const rdpSettings* settings, rdpPrinter* printer)
+{
+	BOOL res = FALSE;
+	WCHAR* wname = NULL;
+	WCHAR* driver = NULL;
+	size_t wlen = 0;
+	size_t dlen = 0;
+	char* path = NULL;
+
+	if (!settings || !printer || !printer->name || !printer->driver)
+		return FALSE;
+
+	wname = ConvertUtf8ToWCharAlloc(printer->name, NULL);
+
+	if (!wname)
+		goto fail;
+
+	driver = ConvertUtf8ToWCharAlloc(printer->driver, NULL);
+
+	if (!driver)
+		goto fail;
+
+	wlen = _wcslen(wname) + 1;
+	dlen = _wcslen(driver) + 1;
+	path = get_printer_config_path(settings, wname, wlen * sizeof(WCHAR));
+
+	if (!path)
+		goto fail;
+
+	if (dlen > 1)
+	{
+		if (!printer_write_setting(path, PRN_CONF_DRIVER, driver, dlen * sizeof(WCHAR)))
+			goto fail;
+	}
+
+	res = TRUE;
+fail:
+	free(path);
+	free(wname);
+	free(driver);
+	return res;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_process_irp_create(PRINTER_DEVICE* printer_dev, IRP* irp)
+{
+	rdpPrintJob* printjob = NULL;
+
+	WINPR_ASSERT(printer_dev);
+	WINPR_ASSERT(irp);
+
+	if (printer_dev->printer)
+	{
+		WINPR_ASSERT(printer_dev->printer->CreatePrintJob);
+		printjob =
+		    printer_dev->printer->CreatePrintJob(printer_dev->printer, irp->devman->id_sequence++);
+	}
+
+	if (printjob)
+	{
+		Stream_Write_UINT32(irp->output, printjob->id); /* FileId */
+	}
+	else
+	{
+		Stream_Write_UINT32(irp->output, 0); /* FileId */
+		irp->IoStatus = STATUS_PRINT_QUEUE_FULL;
+	}
+
+	return irp->Complete(irp);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_process_irp_close(PRINTER_DEVICE* printer_dev, IRP* irp)
+{
+	rdpPrintJob* printjob = NULL;
+
+	WINPR_ASSERT(printer_dev);
+	WINPR_ASSERT(irp);
+
+	if (printer_dev->printer)
+	{
+		WINPR_ASSERT(printer_dev->printer->FindPrintJob);
+		printjob = printer_dev->printer->FindPrintJob(printer_dev->printer, irp->FileId);
+	}
+
+	if (!printjob)
+	{
+		irp->IoStatus = STATUS_UNSUCCESSFUL;
+	}
+	else
+	{
+		printjob->Close(printjob);
+	}
+
+	Stream_Zero(irp->output, 4); /* Padding(4) */
+	return irp->Complete(irp);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_process_irp_write(PRINTER_DEVICE* printer_dev, IRP* irp)
+{
+	UINT32 Length = 0;
+	UINT64 Offset = 0;
+	rdpPrintJob* printjob = NULL;
+	UINT error = CHANNEL_RC_OK;
+
+	WINPR_ASSERT(printer_dev);
+	WINPR_ASSERT(irp);
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, irp->input, 32))
+		return ERROR_INVALID_DATA;
+	Stream_Read_UINT32(irp->input, Length);
+	Stream_Read_UINT64(irp->input, Offset);
+	Stream_Seek(irp->input, 20); /* Padding */
+	const void* ptr = Stream_ConstPointer(irp->input);
+	if (!Stream_SafeSeek(irp->input, Length))
+		return ERROR_INVALID_DATA;
+	if (printer_dev->printer)
+	{
+		WINPR_ASSERT(printer_dev->printer->FindPrintJob);
+		printjob = printer_dev->printer->FindPrintJob(printer_dev->printer, irp->FileId);
+	}
+
+	if (!printjob)
+	{
+		irp->IoStatus = STATUS_UNSUCCESSFUL;
+		Length = 0;
+	}
+	else
+	{
+		error = printjob->Write(printjob, ptr, Length);
+	}
+
+	if (error)
+	{
+		WLog_ERR(TAG, "printjob->Write failed with error %" PRIu32 "!", error);
+		return error;
+	}
+
+	Stream_Write_UINT32(irp->output, Length);
+	Stream_Write_UINT8(irp->output, 0); /* Padding */
+
+	WINPR_ASSERT(irp->Complete);
+	return irp->Complete(irp);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_process_irp_device_control(PRINTER_DEVICE* printer_dev, IRP* irp)
+{
+	WINPR_ASSERT(printer_dev);
+	WINPR_ASSERT(irp);
+
+	Stream_Write_UINT32(irp->output, 0); /* OutputBufferLength */
+
+	WINPR_ASSERT(irp->Complete);
+	return irp->Complete(irp);
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_process_irp(PRINTER_DEVICE* printer_dev, IRP* irp)
+{
+	UINT error = 0;
+
+	WINPR_ASSERT(printer_dev);
+	WINPR_ASSERT(irp);
+
+	switch (irp->MajorFunction)
+	{
+		case IRP_MJ_CREATE:
+			if ((error = printer_process_irp_create(printer_dev, irp)))
+			{
+				WLog_ERR(TAG, "printer_process_irp_create failed with error %" PRIu32 "!", error);
+				return error;
+			}
+
+			break;
+
+		case IRP_MJ_CLOSE:
+			if ((error = printer_process_irp_close(printer_dev, irp)))
+			{
+				WLog_ERR(TAG, "printer_process_irp_close failed with error %" PRIu32 "!", error);
+				return error;
+			}
+
+			break;
+
+		case IRP_MJ_WRITE:
+			if ((error = printer_process_irp_write(printer_dev, irp)))
+			{
+				WLog_ERR(TAG, "printer_process_irp_write failed with error %" PRIu32 "!", error);
+				return error;
+			}
+
+			break;
+
+		case IRP_MJ_DEVICE_CONTROL:
+			if ((error = printer_process_irp_device_control(printer_dev, irp)))
+			{
+				WLog_ERR(TAG, "printer_process_irp_device_control failed with error %" PRIu32 "!",
+				         error);
+				return error;
+			}
+
+			break;
+
+		default:
+			irp->IoStatus = STATUS_NOT_SUPPORTED;
+			WINPR_ASSERT(irp->Complete);
+			return irp->Complete(irp);
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+static DWORD WINAPI printer_thread_func(LPVOID arg)
+{
+	IRP* irp = NULL;
+	PRINTER_DEVICE* printer_dev = (PRINTER_DEVICE*)arg;
+	UINT error = CHANNEL_RC_OK;
+
+	WINPR_ASSERT(printer_dev);
+
+	while (1)
+	{
+		HANDLE obj[] = { printer_dev->event, printer_dev->stopEvent };
+		DWORD rc = WaitForMultipleObjects(ARRAYSIZE(obj), obj, FALSE, INFINITE);
+
+		if (rc == WAIT_FAILED)
+		{
+			error = GetLastError();
+			WLog_ERR(TAG, "WaitForMultipleObjects failed with error %" PRIu32 "!", error);
+			break;
+		}
+
+		if (rc == WAIT_OBJECT_0 + 1)
+			break;
+		else if (rc != WAIT_OBJECT_0)
+			continue;
+
+		ResetEvent(printer_dev->event);
+		irp = (IRP*)InterlockedPopEntrySList(printer_dev->pIrpList);
+
+		if (irp == NULL)
+		{
+			WLog_ERR(TAG, "InterlockedPopEntrySList failed!");
+			error = ERROR_INTERNAL_ERROR;
+			break;
+		}
+
+		if ((error = printer_process_irp(printer_dev, irp)))
+		{
+			WLog_ERR(TAG, "printer_process_irp failed with error %" PRIu32 "!", error);
+			break;
+		}
+	}
+
+	if (error && printer_dev->rdpcontext)
+		setChannelError(printer_dev->rdpcontext, error, "printer_thread_func reported an error");
+
+	ExitThread(error);
+	return error;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_irp_request(DEVICE* device, IRP* irp)
+{
+	PRINTER_DEVICE* printer_dev = (PRINTER_DEVICE*)device;
+
+	WINPR_ASSERT(printer_dev);
+	WINPR_ASSERT(irp);
+
+	InterlockedPushEntrySList(printer_dev->pIrpList, &(irp->ItemEntry));
+	SetEvent(printer_dev->event);
+	return CHANNEL_RC_OK;
+}
+
+static UINT printer_custom_component(DEVICE* device, UINT16 component, UINT16 packetId, wStream* s)
+{
+	UINT32 eventID = 0;
+	PRINTER_DEVICE* printer_dev = (PRINTER_DEVICE*)device;
+
+	WINPR_ASSERT(printer_dev);
+	WINPR_ASSERT(printer_dev->rdpcontext);
+
+	const rdpSettings* settings = printer_dev->rdpcontext->settings;
+	WINPR_ASSERT(settings);
+
+	if (component != RDPDR_CTYP_PRN)
+		return ERROR_INVALID_DATA;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, eventID);
+
+	switch (packetId)
+	{
+		case PAKID_PRN_CACHE_DATA:
+			switch (eventID)
+			{
+				case RDPDR_ADD_PRINTER_EVENT:
+				{
+					char PortDosName[8];
+					UINT32 PnPNameLen = 0;
+					UINT32 DriverNameLen = 0;
+					UINT32 PrintNameLen = 0;
+					UINT32 CacheFieldsLen = 0;
+					const WCHAR* PnPName = NULL;
+					const WCHAR* DriverName = NULL;
+					const WCHAR* PrinterName = NULL;
+					const BYTE* CachedPrinterConfigData = NULL;
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, 24))
+						return ERROR_INVALID_DATA;
+
+					Stream_Read(s, PortDosName, sizeof(PortDosName));
+					Stream_Read_UINT32(s, PnPNameLen);
+					Stream_Read_UINT32(s, DriverNameLen);
+					Stream_Read_UINT32(s, PrintNameLen);
+					Stream_Read_UINT32(s, CacheFieldsLen);
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, PnPNameLen))
+						return ERROR_INVALID_DATA;
+
+					PnPName = Stream_ConstPointer(s);
+					Stream_Seek(s, PnPNameLen);
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, DriverNameLen))
+						return ERROR_INVALID_DATA;
+
+					DriverName = Stream_ConstPointer(s);
+					Stream_Seek(s, DriverNameLen);
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, PrintNameLen))
+						return ERROR_INVALID_DATA;
+
+					PrinterName = Stream_ConstPointer(s);
+					Stream_Seek(s, PrintNameLen);
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, CacheFieldsLen))
+						return ERROR_INVALID_DATA;
+
+					CachedPrinterConfigData = Stream_ConstPointer(s);
+					Stream_Seek(s, CacheFieldsLen);
+
+					if (!printer_save_to_config(settings, PortDosName, sizeof(PortDosName), PnPName,
+					                            PnPNameLen, DriverName, DriverNameLen, PrinterName,
+					                            PrintNameLen, CachedPrinterConfigData,
+					                            CacheFieldsLen))
+						return ERROR_INTERNAL_ERROR;
+				}
+				break;
+
+				case RDPDR_UPDATE_PRINTER_EVENT:
+				{
+					UINT32 PrinterNameLen = 0;
+					UINT32 ConfigDataLen = 0;
+					const WCHAR* PrinterName = NULL;
+					const BYTE* ConfigData = NULL;
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+						return ERROR_INVALID_DATA;
+
+					Stream_Read_UINT32(s, PrinterNameLen);
+					Stream_Read_UINT32(s, ConfigDataLen);
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, PrinterNameLen))
+						return ERROR_INVALID_DATA;
+
+					PrinterName = Stream_ConstPointer(s);
+					Stream_Seek(s, PrinterNameLen);
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, ConfigDataLen))
+						return ERROR_INVALID_DATA;
+
+					ConfigData = Stream_ConstPointer(s);
+					Stream_Seek(s, ConfigDataLen);
+
+					if (!printer_update_to_config(settings, PrinterName, PrinterNameLen, ConfigData,
+					                              ConfigDataLen))
+						return ERROR_INTERNAL_ERROR;
+				}
+				break;
+
+				case RDPDR_DELETE_PRINTER_EVENT:
+				{
+					UINT32 PrinterNameLen = 0;
+					const WCHAR* PrinterName = NULL;
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+						return ERROR_INVALID_DATA;
+
+					Stream_Read_UINT32(s, PrinterNameLen);
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, PrinterNameLen))
+						return ERROR_INVALID_DATA;
+
+					PrinterName = Stream_ConstPointer(s);
+					Stream_Seek(s, PrinterNameLen);
+					printer_remove_config(settings, PrinterName, PrinterNameLen);
+				}
+				break;
+
+				case RDPDR_RENAME_PRINTER_EVENT:
+				{
+					UINT32 OldPrinterNameLen = 0;
+					UINT32 NewPrinterNameLen = 0;
+					const WCHAR* OldPrinterName = NULL;
+					const WCHAR* NewPrinterName = NULL;
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
+						return ERROR_INVALID_DATA;
+
+					Stream_Read_UINT32(s, OldPrinterNameLen);
+					Stream_Read_UINT32(s, NewPrinterNameLen);
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, OldPrinterNameLen))
+						return ERROR_INVALID_DATA;
+
+					OldPrinterName = Stream_ConstPointer(s);
+					Stream_Seek(s, OldPrinterNameLen);
+
+					if (!Stream_CheckAndLogRequiredLength(TAG, s, NewPrinterNameLen))
+						return ERROR_INVALID_DATA;
+
+					NewPrinterName = Stream_ConstPointer(s);
+					Stream_Seek(s, NewPrinterNameLen);
+
+					if (!printer_move_config(settings, OldPrinterName, OldPrinterNameLen,
+					                         NewPrinterName, NewPrinterNameLen))
+						return ERROR_INTERNAL_ERROR;
+				}
+				break;
+
+				default:
+					WLog_ERR(TAG, "Unknown cache data eventID: 0x%08" PRIX32 "", eventID);
+					return ERROR_INVALID_DATA;
+			}
+
+			break;
+
+		case PAKID_PRN_USING_XPS:
+		{
+			UINT32 flags = 0;
+
+			if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
+				return ERROR_INVALID_DATA;
+
+			Stream_Read_UINT32(s, flags);
+			WLog_ERR(TAG,
+			         "Ignoring unhandled message PAKID_PRN_USING_XPS [printerID=%08" PRIx32
+			         ", flags=%08" PRIx32 "]",
+			         eventID, flags);
+		}
+		break;
+
+		default:
+			WLog_ERR(TAG, "Unknown printing component packetID: 0x%04" PRIX16 "", packetId);
+			return ERROR_INVALID_DATA;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_free(DEVICE* device)
+{
+	IRP* irp = NULL;
+	PRINTER_DEVICE* printer_dev = (PRINTER_DEVICE*)device;
+	UINT error = 0;
+
+	WINPR_ASSERT(printer_dev);
+
+	SetEvent(printer_dev->stopEvent);
+
+	if (WaitForSingleObject(printer_dev->thread, INFINITE) == WAIT_FAILED)
+	{
+		error = GetLastError();
+		WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "", error);
+
+		/* The analyzer is confused by this premature return value.
+		 * Since this case can not be handled gracefully silence the
+		 * analyzer here. */
+#ifndef __clang_analyzer__
+		return error;
+#endif
+	}
+
+	while ((irp = (IRP*)InterlockedPopEntrySList(printer_dev->pIrpList)) != NULL)
+	{
+		WINPR_ASSERT(irp->Discard);
+		irp->Discard(irp);
+	}
+
+	CloseHandle(printer_dev->thread);
+	CloseHandle(printer_dev->stopEvent);
+	CloseHandle(printer_dev->event);
+	winpr_aligned_free(printer_dev->pIrpList);
+
+	if (printer_dev->printer)
+	{
+		WINPR_ASSERT(printer_dev->printer->ReleaseRef);
+		printer_dev->printer->ReleaseRef(printer_dev->printer);
+	}
+
+	Stream_Free(printer_dev->device.data, TRUE);
+	free(printer_dev);
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_register(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, rdpPrinter* printer)
+{
+	PRINTER_DEVICE* printer_dev = NULL;
+	UINT error = ERROR_INTERNAL_ERROR;
+
+	WINPR_ASSERT(pEntryPoints);
+	WINPR_ASSERT(printer);
+
+	printer_dev = (PRINTER_DEVICE*)calloc(1, sizeof(PRINTER_DEVICE));
+
+	if (!printer_dev)
+	{
+		WLog_ERR(TAG, "calloc failed!");
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	printer_dev->device.data = Stream_New(NULL, 1024);
+
+	if (!printer_dev->device.data)
+		goto error_out;
+
+	sprintf_s(printer_dev->port, sizeof(printer_dev->port), "PRN%" PRIdz, printer->id);
+	printer_dev->device.type = RDPDR_DTYP_PRINT;
+	printer_dev->device.name = printer_dev->port;
+	printer_dev->device.IRPRequest = printer_irp_request;
+	printer_dev->device.CustomComponentRequest = printer_custom_component;
+	printer_dev->device.Free = printer_free;
+	printer_dev->rdpcontext = pEntryPoints->rdpcontext;
+	printer_dev->printer = printer;
+	printer_dev->pIrpList = (WINPR_PSLIST_HEADER)winpr_aligned_malloc(sizeof(WINPR_SLIST_HEADER),
+	                                                                  MEMORY_ALLOCATION_ALIGNMENT);
+
+	if (!printer_dev->pIrpList)
+	{
+		WLog_ERR(TAG, "_aligned_malloc failed!");
+		error = CHANNEL_RC_NO_MEMORY;
+		goto error_out;
+	}
+
+	if (!printer_load_from_config(pEntryPoints->rdpcontext->settings, printer, printer_dev))
+		goto error_out;
+
+	InitializeSListHead(printer_dev->pIrpList);
+
+	if (!(printer_dev->event = CreateEvent(NULL, TRUE, FALSE, NULL)))
+	{
+		WLog_ERR(TAG, "CreateEvent failed!");
+		error = ERROR_INTERNAL_ERROR;
+		goto error_out;
+	}
+
+	if (!(printer_dev->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
+	{
+		WLog_ERR(TAG, "CreateEvent failed!");
+		error = ERROR_INTERNAL_ERROR;
+		goto error_out;
+	}
+
+	if ((error = pEntryPoints->RegisterDevice(pEntryPoints->devman, &printer_dev->device)))
+	{
+		WLog_ERR(TAG, "RegisterDevice failed with error %" PRIu32 "!", error);
+		goto error_out;
+	}
+
+	if (!(printer_dev->thread =
+	          CreateThread(NULL, 0, printer_thread_func, (void*)printer_dev, 0, NULL)))
+	{
+		WLog_ERR(TAG, "CreateThread failed!");
+		error = ERROR_INTERNAL_ERROR;
+		goto error_out;
+	}
+
+	WINPR_ASSERT(printer->AddRef);
+	printer->AddRef(printer);
+	return CHANNEL_RC_OK;
+error_out:
+	printer_free(&printer_dev->device);
+	return error;
+}
+
+static rdpPrinterDriver* printer_load_backend(const char* backend)
+{
+	typedef UINT (*backend_load_t)(rdpPrinterDriver**);
+	union
+	{
+		PVIRTUALCHANNELENTRY entry;
+		backend_load_t backend;
+	} fktconv;
+
+	fktconv.entry = freerdp_load_channel_addin_entry("printer", backend, NULL, 0);
+	if (!fktconv.entry)
+		return NULL;
+
+	rdpPrinterDriver* printer = NULL;
+	const UINT rc = fktconv.backend(&printer);
+	if (rc != CHANNEL_RC_OK)
+		return NULL;
+
+	return printer;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+FREERDP_ENTRY_POINT(UINT printer_DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints))
+{
+	char* name = NULL;
+	char* driver_name = NULL;
+	BOOL default_backend = TRUE;
+	RDPDR_PRINTER* device = NULL;
+	rdpPrinterDriver* driver = NULL;
+	UINT error = CHANNEL_RC_OK;
+
+	if (!pEntryPoints || !pEntryPoints->device)
+		return ERROR_INVALID_PARAMETER;
+
+	device = (RDPDR_PRINTER*)pEntryPoints->device;
+	name = device->device.Name;
+	driver_name = _strdup(device->DriverName);
+
+	/* Secondary argument is one of the following:
+	 *
+	 * <driver_name>                ... name of a printer driver
+	 * <driver_name>:<backend_name> ... name of a printer driver and local printer backend to use
+	 */
+	if (driver_name)
+	{
+		char* sep = strstr(driver_name, ":");
+		if (sep)
+		{
+			const char* backend = sep + 1;
+			*sep = '\0';
+			driver = printer_load_backend(backend);
+			default_backend = FALSE;
+		}
+	}
+
+	if (!driver && default_backend)
+	{
+		const char* backend =
+#if defined(WITH_CUPS)
+		    "cups"
+#elif defined(_WIN32)
+		    "win"
+#else
+		    ""
+#endif
+		    ;
+
+		driver = printer_load_backend(backend);
+	}
+
+	if (!driver)
+	{
+		WLog_ERR(TAG, "Could not get a printer driver!");
+		error = CHANNEL_RC_INITIALIZATION_ERROR;
+		goto fail;
+	}
+
+	if (name && name[0])
+	{
+		WINPR_ASSERT(driver->GetPrinter);
+		rdpPrinter* printer = driver->GetPrinter(driver, name, driver_name, device->IsDefault);
+
+		if (!printer)
+		{
+			WLog_ERR(TAG, "Could not get printer %s!", name);
+			error = CHANNEL_RC_INITIALIZATION_ERROR;
+			goto fail;
+		}
+
+		WINPR_ASSERT(printer->ReleaseRef);
+		if (!printer_save_default_config(pEntryPoints->rdpcontext->settings, printer))
+		{
+			error = CHANNEL_RC_INITIALIZATION_ERROR;
+			printer->ReleaseRef(printer);
+			goto fail;
+		}
+
+		error = printer_register(pEntryPoints, printer);
+		printer->ReleaseRef(printer);
+		if (error)
+		{
+			WLog_ERR(TAG, "printer_register failed with error %" PRIu32 "!", error);
+			goto fail;
+		}
+	}
+	else
+	{
+		WINPR_ASSERT(driver->EnumPrinters);
+		rdpPrinter** printers = driver->EnumPrinters(driver);
+		if (printers)
+		{
+			for (rdpPrinter** current = printers; *current; ++current)
+			{
+				error = printer_register(pEntryPoints, *current);
+				if (error)
+				{
+					WLog_ERR(TAG, "printer_register failed with error %" PRIu32 "!", error);
+					break;
+				}
+			}
+		}
+		else
+		{
+			WLog_ERR(TAG, "Failed to enumerate printers!");
+			error = CHANNEL_RC_INITIALIZATION_ERROR;
+		}
+
+		WINPR_ASSERT(driver->ReleaseEnumPrinters);
+		driver->ReleaseEnumPrinters(printers);
+	}
+
+fail:
+	free(driver_name);
+	if (driver)
+	{
+		WINPR_ASSERT(driver->ReleaseRef);
+		driver->ReleaseRef(driver);
+	}
+
+	return error;
+}
diff --git a/channels/printer/client/win/CMakeLists.txt b/channels/printer/client/win/CMakeLists.txt
new file mode 100644
index 0000000..7f0960a
--- /dev/null
+++ b/channels/printer/client/win/CMakeLists.txt
@@ -0,0 +1,30 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP cmake build script
+#
+# Copyright 2019 Armin Novak <armin.novak@thincast.com>
+# Copyright 2019 Thincast Technologies GmbH
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+define_channel_client_subsystem("printer" "win" "")
+
+set(${MODULE_PREFIX}_SRCS
+		printer_win.c)
+
+set(${MODULE_PREFIX}_LIBS
+    winpr
+    freerdp
+)
+
+include_directories(..)
+
+add_channel_client_subsystem_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} "" TRUE "")
diff --git a/channels/printer/client/win/printer_win.c b/channels/printer/client/win/printer_win.c
new file mode 100644
index 0000000..9bd7589
--- /dev/null
+++ b/channels/printer/client/win/printer_win.c
@@ -0,0 +1,463 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Print Virtual Channel - WIN driver
+ *
+ * Copyright 2012 Gerald Richter
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
+ * Copyright 2016 Armin Novak <armin.novak@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+#include <winpr/string.h>
+#include <winpr/windows.h>
+
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <winspool.h>
+
+#include <freerdp/client/printer.h>
+
+#define WIDEN_INT(x) L##x
+#define WIDEN(x) WIDEN_INT(x)
+#define PRINTER_TAG CHANNELS_TAG("printer.client")
+#ifdef WITH_DEBUG_WINPR
+#define DEBUG_WINPR(...) WLog_DBG(PRINTER_TAG, __VA_ARGS__)
+#else
+#define DEBUG_WINPR(...) \
+	do                   \
+	{                    \
+	} while (0)
+#endif
+
+typedef struct
+{
+	rdpPrinterDriver driver;
+
+	size_t id_sequence;
+	size_t references;
+} rdpWinPrinterDriver;
+
+typedef struct
+{
+	rdpPrintJob printjob;
+	DOC_INFO_1 di;
+	DWORD handle;
+
+	void* printjob_object;
+	int printjob_id;
+} rdpWinPrintJob;
+
+typedef struct
+{
+	rdpPrinter printer;
+	HANDLE hPrinter;
+	rdpWinPrintJob* printjob;
+} rdpWinPrinter;
+
+static WCHAR* printer_win_get_printjob_name(size_t id)
+{
+	time_t tt;
+	struct tm tres;
+	errno_t err;
+	WCHAR* str;
+	size_t len = 1024;
+	int rc;
+
+	tt = time(NULL);
+	err = localtime_s(&tres, &tt);
+
+	str = calloc(len, sizeof(WCHAR));
+	if (!str)
+		return NULL;
+
+	rc = swprintf_s(str, len,
+	                WIDEN("FreeRDP Print %04d-%02d-%02d% 02d-%02d-%02d - Job %") WIDEN(PRIuz)
+	                    WIDEN("\0"),
+	                tres.tm_year + 1900, tres.tm_mon + 1, tres.tm_mday, tres.tm_hour, tres.tm_min,
+	                tres.tm_sec, id);
+
+	return str;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT printer_win_write_printjob(rdpPrintJob* printjob, const BYTE* data, size_t size)
+{
+	rdpWinPrinter* printer;
+	LPCVOID pBuf = data;
+	DWORD cbBuf = size;
+	DWORD pcWritten;
+
+	if (!printjob || !data)
+		return ERROR_BAD_ARGUMENTS;
+
+	printer = (rdpWinPrinter*)printjob->printer;
+	if (!printer)
+		return ERROR_BAD_ARGUMENTS;
+
+	if (!WritePrinter(printer->hPrinter, pBuf, cbBuf, &pcWritten))
+		return ERROR_INTERNAL_ERROR;
+	return CHANNEL_RC_OK;
+}
+
+static void printer_win_close_printjob(rdpPrintJob* printjob)
+{
+	rdpWinPrintJob* win_printjob = (rdpWinPrintJob*)printjob;
+	rdpWinPrinter* win_printer;
+
+	if (!printjob)
+		return;
+
+	win_printer = (rdpWinPrinter*)printjob->printer;
+	if (!win_printer)
+		return;
+
+	if (!EndPagePrinter(win_printer->hPrinter))
+	{
+	}
+
+	if (!ClosePrinter(win_printer->hPrinter))
+	{
+	}
+
+	win_printer->printjob = NULL;
+
+	free(win_printjob->di.pDocName);
+	free(win_printjob);
+}
+
+static rdpPrintJob* printer_win_create_printjob(rdpPrinter* printer, UINT32 id)
+{
+	rdpWinPrinter* win_printer = (rdpWinPrinter*)printer;
+	rdpWinPrintJob* win_printjob;
+
+	if (win_printer->printjob != NULL)
+		return NULL;
+
+	win_printjob = (rdpWinPrintJob*)calloc(1, sizeof(rdpWinPrintJob));
+	if (!win_printjob)
+		return NULL;
+
+	win_printjob->printjob.id = id;
+	win_printjob->printjob.printer = printer;
+	win_printjob->di.pDocName = printer_win_get_printjob_name(id);
+	win_printjob->di.pDatatype = NULL;
+	win_printjob->di.pOutputFile = NULL;
+
+	win_printjob->handle = StartDocPrinter(win_printer->hPrinter, 1, (LPBYTE) & (win_printjob->di));
+
+	if (!win_printjob->handle)
+	{
+		free(win_printjob->di.pDocName);
+		free(win_printjob);
+		return NULL;
+	}
+
+	if (!StartPagePrinter(win_printer->hPrinter))
+	{
+		free(win_printjob->di.pDocName);
+		free(win_printjob);
+		return NULL;
+	}
+
+	win_printjob->printjob.Write = printer_win_write_printjob;
+	win_printjob->printjob.Close = printer_win_close_printjob;
+
+	win_printer->printjob = win_printjob;
+
+	return &win_printjob->printjob;
+}
+
+static rdpPrintJob* printer_win_find_printjob(rdpPrinter* printer, UINT32 id)
+{
+	rdpWinPrinter* win_printer = (rdpWinPrinter*)printer;
+
+	if (!win_printer->printjob)
+		return NULL;
+
+	if (win_printer->printjob->printjob.id != id)
+		return NULL;
+
+	return (rdpPrintJob*)win_printer->printjob;
+}
+
+static void printer_win_free_printer(rdpPrinter* printer)
+{
+	rdpWinPrinter* win_printer = (rdpWinPrinter*)printer;
+
+	if (win_printer->printjob)
+		win_printer->printjob->printjob.Close((rdpPrintJob*)win_printer->printjob);
+
+	if (printer->backend)
+		printer->backend->ReleaseRef(printer->backend);
+
+	free(printer->name);
+	free(printer->driver);
+	free(printer);
+}
+
+static void printer_win_add_ref_printer(rdpPrinter* printer)
+{
+	if (printer)
+		printer->references++;
+}
+
+static void printer_win_release_ref_printer(rdpPrinter* printer)
+{
+	if (!printer)
+		return;
+	if (printer->references <= 1)
+		printer_win_free_printer(printer);
+	else
+		printer->references--;
+}
+
+static rdpPrinter* printer_win_new_printer(rdpWinPrinterDriver* win_driver, const WCHAR* name,
+                                           const WCHAR* drivername, BOOL is_default)
+{
+	rdpWinPrinter* win_printer;
+	DWORD needed = 0;
+	PRINTER_INFO_2* prninfo = NULL;
+
+	if (!name)
+		return NULL;
+
+	win_printer = (rdpWinPrinter*)calloc(1, sizeof(rdpWinPrinter));
+	if (!win_printer)
+		return NULL;
+
+	win_printer->printer.backend = &win_driver->driver;
+	win_printer->printer.id = win_driver->id_sequence++;
+	win_printer->printer.name = ConvertWCharToUtf8Alloc(name, NULL);
+	if (!win_printer->printer.name)
+		goto fail;
+
+	if (!win_printer->printer.name)
+		goto fail;
+	win_printer->printer.is_default = is_default;
+
+	win_printer->printer.CreatePrintJob = printer_win_create_printjob;
+	win_printer->printer.FindPrintJob = printer_win_find_printjob;
+	win_printer->printer.AddRef = printer_win_add_ref_printer;
+	win_printer->printer.ReleaseRef = printer_win_release_ref_printer;
+
+	if (!OpenPrinter(name, &(win_printer->hPrinter), NULL))
+		goto fail;
+
+	/* How many memory should be allocated for printer data */
+	GetPrinter(win_printer->hPrinter, 2, (LPBYTE)prninfo, 0, &needed);
+	if (needed == 0)
+		goto fail;
+
+	prninfo = (PRINTER_INFO_2*)GlobalAlloc(GPTR, needed);
+	if (!prninfo)
+		goto fail;
+
+	if (!GetPrinter(win_printer->hPrinter, 2, (LPBYTE)prninfo, needed, &needed))
+	{
+		GlobalFree(prninfo);
+		goto fail;
+	}
+
+	if (drivername)
+		win_printer->printer.driver = ConvertWCharToUtf8Alloc(drivername, NULL);
+	else
+		win_printer->printer.driver = ConvertWCharToUtf8Alloc(prninfo->pDriverName, NULL);
+	GlobalFree(prninfo);
+	if (!win_printer->printer.driver)
+		goto fail;
+
+	win_printer->printer.AddRef(&win_printer->printer);
+	win_printer->printer.backend->AddRef(win_printer->printer.backend);
+	return &win_printer->printer;
+
+fail:
+	printer_win_free_printer(&win_printer->printer);
+	return NULL;
+}
+
+static void printer_win_release_enum_printers(rdpPrinter** printers)
+{
+	rdpPrinter** cur = printers;
+
+	while ((cur != NULL) && ((*cur) != NULL))
+	{
+		if ((*cur)->ReleaseRef)
+			(*cur)->ReleaseRef(*cur);
+		cur++;
+	}
+	free(printers);
+}
+
+static rdpPrinter** printer_win_enum_printers(rdpPrinterDriver* driver)
+{
+	rdpPrinter** printers;
+	int num_printers;
+	PRINTER_INFO_2* prninfo = NULL;
+	DWORD needed, returned;
+	BOOL haveDefault = FALSE;
+	LPWSTR defaultPrinter = NULL;
+
+	GetDefaultPrinter(NULL, &needed);
+	if (needed)
+	{
+		defaultPrinter = (LPWSTR)calloc(needed, sizeof(WCHAR));
+
+		if (!defaultPrinter)
+			return NULL;
+
+		if (!GetDefaultPrinter(defaultPrinter, &needed))
+			defaultPrinter[0] = '\0';
+	}
+
+	/* find required size for the buffer */
+	EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 2, NULL, 0, &needed,
+	             &returned);
+
+	/* allocate array of PRINTER_INFO structures */
+	prninfo = (PRINTER_INFO_2*)GlobalAlloc(GPTR, needed);
+	if (!prninfo)
+	{
+		free(defaultPrinter);
+		return NULL;
+	}
+
+	/* call again */
+	if (!EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 2, (LPBYTE)prninfo,
+	                  needed, &needed, &returned))
+	{
+	}
+
+	printers = (rdpPrinter**)calloc((returned + 1), sizeof(rdpPrinter*));
+	if (!printers)
+	{
+		GlobalFree(prninfo);
+		free(defaultPrinter);
+		return NULL;
+	}
+
+	num_printers = 0;
+
+	for (int i = 0; i < (int)returned; i++)
+	{
+		rdpPrinter* current = printers[num_printers];
+		current = printer_win_new_printer((rdpWinPrinterDriver*)driver, prninfo[i].pPrinterName,
+		                                  prninfo[i].pDriverName,
+		                                  _wcscmp(prninfo[i].pPrinterName, defaultPrinter) == 0);
+		if (!current)
+		{
+			printer_win_release_enum_printers(printers);
+			printers = NULL;
+			break;
+		}
+		if (current->is_default)
+			haveDefault = TRUE;
+		printers[num_printers++] = current;
+	}
+
+	if (!haveDefault && (returned > 0))
+		printers[0]->is_default = TRUE;
+
+	GlobalFree(prninfo);
+	free(defaultPrinter);
+	return printers;
+}
+
+static rdpPrinter* printer_win_get_printer(rdpPrinterDriver* driver, const char* name,
+                                           const char* driverName, BOOL isDefault)
+{
+	WCHAR* driverNameW = NULL;
+	WCHAR* nameW = NULL;
+	rdpWinPrinterDriver* win_driver = (rdpWinPrinterDriver*)driver;
+	rdpPrinter* myPrinter = NULL;
+
+	if (name)
+	{
+		nameW = ConvertUtf8ToWCharAlloc(name, NULL);
+		if (!nameW)
+			return NULL;
+	}
+	if (driverName)
+	{
+		driverNameW = ConvertUtf8ToWCharAlloc(driverName, NULL);
+		if (!driverNameW)
+			return NULL;
+	}
+
+	myPrinter = printer_win_new_printer(win_driver, nameW, driverNameW, isDefault);
+	free(driverNameW);
+	free(nameW);
+
+	return myPrinter;
+}
+
+static void printer_win_add_ref_driver(rdpPrinterDriver* driver)
+{
+	rdpWinPrinterDriver* win = (rdpWinPrinterDriver*)driver;
+	if (win)
+		win->references++;
+}
+
+/* Singleton */
+static rdpWinPrinterDriver* win_driver = NULL;
+
+static void printer_win_release_ref_driver(rdpPrinterDriver* driver)
+{
+	rdpWinPrinterDriver* win = (rdpWinPrinterDriver*)driver;
+	if (win->references <= 1)
+	{
+		free(win);
+		win_driver = NULL;
+	}
+	else
+		win->references--;
+}
+
+FREERDP_ENTRY_POINT(UINT win_freerdp_printer_client_subsystem_entry(void* arg))
+{
+	rdpPrinterDriver** ppPrinter = (rdpPrinterDriver**)arg;
+	if (!ppPrinter)
+		return ERROR_INVALID_PARAMETER;
+
+	if (!win_driver)
+	{
+		win_driver = (rdpWinPrinterDriver*)calloc(1, sizeof(rdpWinPrinterDriver));
+
+		if (!win_driver)
+			return ERROR_OUTOFMEMORY;
+
+		win_driver->driver.EnumPrinters = printer_win_enum_printers;
+		win_driver->driver.ReleaseEnumPrinters = printer_win_release_enum_printers;
+		win_driver->driver.GetPrinter = printer_win_get_printer;
+
+		win_driver->driver.AddRef = printer_win_add_ref_driver;
+		win_driver->driver.ReleaseRef = printer_win_release_ref_driver;
+
+		win_driver->id_sequence = 1;
+	}
+
+	win_driver->driver.AddRef(&win_driver->driver);
+
+	*ppPrinter = &win_driver->driver;
+	return CHANNEL_RC_OK;
+}
diff --git a/channels/printer/printer.h b/channels/printer/printer.h
new file mode 100644
index 0000000..ae0902d
--- /dev/null
+++ b/channels/printer/printer.h
@@ -0,0 +1,36 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Definition for the printer channel
+ *
+ * Copyright 2016 David Fort <contact@hardening-consulting.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_CHANNEL_PRINTER_PRINTER_H
+#define FREERDP_CHANNEL_PRINTER_PRINTER_H
+
+/* SERVER_PRINTER_CACHE_EVENT.cachedata */
+#define RDPDR_ADD_PRINTER_EVENT 0x00000001
+#define RDPDR_UPDATE_PRINTER_EVENT 0x00000002
+#define RDPDR_DELETE_PRINTER_EVENT 0x00000003
+#define RDPDR_RENAME_PRINTER_EVENT 0x00000004
+
+/* DR_PRN_DEVICE_ANNOUNCE.Flags */
+#define RDPDR_PRINTER_ANNOUNCE_FLAG_ASCII 0x00000001
+#define RDPDR_PRINTER_ANNOUNCE_FLAG_DEFAULTPRINTER 0x00000002
+#define RDPDR_PRINTER_ANNOUNCE_FLAG_NETWORKPRINTER 0x00000004
+#define RDPDR_PRINTER_ANNOUNCE_FLAG_TSPRINTER 0x00000008
+#define RDPDR_PRINTER_ANNOUNCE_FLAG_XPSFORMAT 0x00000010
+
+#endif /* FREERDP_CHANNEL_PRINTER_PRINTER_H */