printer_main.c

 
#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/file.h>
#include <winpr/path.h>
#include <winpr/print.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/utils/rdpdr_utils.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];
  BOOL async;
} 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" };
 
WINPR_ATTR_MALLOC(free, 1)
WINPR_ATTR_NODISCARD
static char* get_printer_hash(const WCHAR* name, size_t length)
{
  BYTE hash[WINPR_SHA256_DIGEST_LENGTH] = WINPR_C_ARRAY_INIT;
 
  if (!winpr_Digest(WINPR_MD_SHA256, name, length, hash, sizeof(hash)))
    return nullptr;
 
  return winpr_BinToHexString(hash, sizeof(hash), FALSE);
}
 
WINPR_ATTR_MALLOC(free, 1)
WINPR_ATTR_NODISCARD
static char* get_printer_config_path(const rdpSettings* settings, const WCHAR* name, size_t length)
{
  char* config = nullptr;
  const char* path = freerdp_settings_get_string(settings, FreeRDP_ConfigPath);
  char* dir = GetCombinedPath(path, "printers");
  if (!dir)
    return nullptr;
  char* bname = get_printer_hash(name, length);
  if (!bname)
    goto fail;
  config = GetCombinedPath(dir, bname);
 
  if (config && !winpr_PathFileExists(config))
  {
    if (!winpr_PathMakePath(config, nullptr))
    {
      free(config);
      config = nullptr;
    }
  }
 
fail:
  free(dir);
  free(bname);
  return config;
}
 
static BOOL printer_write_setting(const char* path, prn_conf_t type, const void* data,
                                  size_t length)
{
  if (!path)
    return FALSE;
 
  DWORD written = 0;
  BOOL rc = FALSE;
  HANDLE file = nullptr;
  char* base64 = nullptr;
  const char* name = filemap[type];
  char* abs = GetCombinedPath(path, name);
 
  if (!abs || (length > INT32_MAX))
  {
    free(abs);
    return FALSE;
  }
 
  file = winpr_CreateFile(abs, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
                          nullptr);
  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 */
    const size_t b64len = strnlen(base64, 2 * length);
    rc = WriteFile(file, base64, (UINT32)b64len, &written, nullptr);
 
    if (b64len != written)
      rc = FALSE;
  }
  else
    rc = TRUE;
 
fail:
  (void)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;
  char* fdata = nullptr;
  const char* name = filemap[type];
 
  switch (type)
  {
    case PRN_CONF_DATA:
      break;
    default:
      WLog_DBG(TAG, "Printer option %s ignored", name);
      return FALSE;
  }
 
  char* abs = GetCombinedPath(path, name);
  if (!abs)
    return FALSE;
 
  HANDLE file = winpr_CreateFile(abs, GENERIC_READ, 0, nullptr, OPEN_EXISTING,
                                 FILE_ATTRIBUTE_NORMAL, nullptr);
  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, nullptr);
 
    if (lowSize != read)
      rc = FALSE;
  }
 
fail:
  (void)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 = nullptr;
  }
 
  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 = nullptr;
  size_t wlen = 0;
  char* path = nullptr;
  UINT32 flags = 0;
  void* DriverName = nullptr;
  UINT32 DriverNameLen = 0;
  void* PnPName = nullptr;
  UINT32 PnPNameLen = 0;
  void* CachedPrinterConfigData = nullptr;
  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));
  {
    const size_t plen = wlen * sizeof(WCHAR);
    if (plen > UINT32_MAX)
      goto fail;
    PrinterNameLen = (UINT32)plen;
  }
 
  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;
    const size_t dlen = (len + 1) * sizeof(WCHAR);
    if (dlen > UINT32_MAX)
      goto fail;
    DriverNameLen = (UINT32)dlen;
  }
 
  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 = nullptr;
  WCHAR* driver = nullptr;
  size_t wlen = 0;
  size_t dlen = 0;
  char* path = nullptr;
 
  if (!settings || !printer || !printer->name || !printer->driver)
    return FALSE;
 
  wname = ConvertUtf8ToWCharAlloc(printer->name, nullptr);
 
  if (!wname)
    goto fail;
 
  driver = ConvertUtf8ToWCharAlloc(printer->driver, nullptr);
 
  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;
}
 
static UINT printer_process_irp_create(PRINTER_DEVICE* printer_dev, IRP* irp)
{
  rdpPrintJob* printjob = nullptr;
 
  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 CHANNEL_RC_OK;
}
 
static UINT printer_process_irp_close(PRINTER_DEVICE* printer_dev, IRP* irp)
{
  rdpPrintJob* printjob = nullptr;
 
  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 CHANNEL_RC_OK;
}
 
static UINT printer_process_irp_write(PRINTER_DEVICE* printer_dev, IRP* irp)
{
  UINT32 Length = 0;
  UINT64 Offset = 0;
  rdpPrintJob* printjob = nullptr;
  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);
  (void)Offset; /* [MS-RDPEPC] 2.2.2.9 Server Printer Write Request (DR_PRN_WRITE_REQ)
                 * reserved for future use, ignore */
  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 */
  return CHANNEL_RC_OK;
}
 
static UINT printer_process_irp_device_control(WINPR_ATTR_UNUSED PRINTER_DEVICE* printer_dev,
                                               IRP* irp)
{
  WINPR_ASSERT(printer_dev);
  WINPR_ASSERT(irp);
 
  Stream_Write_UINT32(irp->output, 0); /* OutputBufferLength */
  return CHANNEL_RC_OK;
}
 
static UINT printer_evaluate(UINT error, IRP* irp)
{
  WINPR_ASSERT(irp);
  if (error == CHANNEL_RC_OK)
  {
    WINPR_ASSERT(irp->Complete);
    return irp->Complete(irp);
  }
 
  WLog_ERR(TAG, "IRP %s failed with %" PRIu32, rdpdr_irp_string(irp->MajorFunction), error);
  WINPR_ASSERT(irp->Discard);
  irp->Discard(irp);
  return error;
}
static UINT printer_process_irp(PRINTER_DEVICE* printer_dev, IRP* irp)
{
  UINT error = CHANNEL_RC_OK;
 
  WINPR_ASSERT(printer_dev);
  WINPR_ASSERT(irp);
 
  switch (irp->MajorFunction)
  {
    case IRP_MJ_CREATE:
      error = printer_process_irp_create(printer_dev, irp);
      break;
 
    case IRP_MJ_CLOSE:
      error = printer_process_irp_close(printer_dev, irp);
      break;
 
    case IRP_MJ_WRITE:
      error = printer_process_irp_write(printer_dev, irp);
      break;
 
    case IRP_MJ_DEVICE_CONTROL:
      error = printer_process_irp_device_control(printer_dev, irp);
      break;
 
    default:
      irp->IoStatus = STATUS_NOT_SUPPORTED;
      break;
  }
 
  return printer_evaluate(error, irp);
}
 
static DWORD WINAPI printer_thread_func(LPVOID arg)
{
  IRP* irp = nullptr;
  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;
 
    (void)ResetEvent(printer_dev->event);
    irp = (IRP*)InterlockedPopEntrySList(printer_dev->pIrpList);
 
    if (irp == nullptr)
    {
      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;
}
 
static UINT printer_irp_request(DEVICE* device, IRP* irp)
{
  PRINTER_DEVICE* printer_dev = (PRINTER_DEVICE*)device;
 
  WINPR_ASSERT(printer_dev);
  WINPR_ASSERT(irp);
 
  if (printer_dev->async)
  {
    InterlockedPushEntrySList(printer_dev->pIrpList, &(irp->ItemEntry));
    (void)SetEvent(printer_dev->event);
  }
  else
  {
    UINT error = printer_process_irp(printer_dev, irp);
    if (error)
    {
      WLog_ERR(TAG, "printer_process_irp failed with error %" PRIu32 "!", error);
      return error;
    }
  }
 
  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 = nullptr;
          const WCHAR* DriverName = nullptr;
          const WCHAR* PrinterName = nullptr;
          const BYTE* CachedPrinterConfigData = nullptr;
 
          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 = nullptr;
          const BYTE* ConfigData = nullptr;
 
          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 = nullptr;
 
          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 = nullptr;
          const WCHAR* NewPrinterName = nullptr;
 
          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;
}
 
static UINT printer_free(DEVICE* device)
{
  IRP* irp = nullptr;
  PRINTER_DEVICE* printer_dev = (PRINTER_DEVICE*)device;
  UINT error = 0;
 
  WINPR_ASSERT(printer_dev);
 
  if (printer_dev->async)
  {
    (void)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)) != nullptr)
    {
      WINPR_ASSERT(irp->Discard);
      irp->Discard(irp);
    }
 
    (void)CloseHandle(printer_dev->thread);
    (void)CloseHandle(printer_dev->stopEvent);
    (void)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;
}
 
static UINT printer_register(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, rdpPrinter* printer)
{
  PRINTER_DEVICE* printer_dev = nullptr;
  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(nullptr, 1024);
 
  if (!printer_dev->device.data)
    goto error_out;
 
  (void)sprintf_s(printer_dev->port, sizeof(printer_dev->port), "PRN%" PRIuz, 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;
 
  if (!freerdp_settings_get_bool(pEntryPoints->rdpcontext->settings,
                                 FreeRDP_SynchronousStaticChannels))
    printer_dev->async = TRUE;
 
  if (!printer_load_from_config(pEntryPoints->rdpcontext->settings, printer, printer_dev))
    goto error_out;
 
  if (printer_dev->async)
  {
    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;
    }
 
    InitializeSListHead(printer_dev->pIrpList);
 
    printer_dev->event = CreateEvent(nullptr, TRUE, FALSE, nullptr);
    if (!printer_dev->event)
    {
      WLog_ERR(TAG, "CreateEvent failed!");
      error = ERROR_INTERNAL_ERROR;
      goto error_out;
    }
 
    printer_dev->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
    if (!printer_dev->stopEvent)
    {
      WLog_ERR(TAG, "CreateEvent failed!");
      error = ERROR_INTERNAL_ERROR;
      goto error_out;
    }
  }
 
  error = pEntryPoints->RegisterDevice(pEntryPoints->devman, &printer_dev->device);
  if (error)
  {
    WLog_ERR(TAG, "RegisterDevice failed with error %" PRIu32 "!", error);
    goto error_out;
  }
 
  if (printer_dev->async)
  {
    printer_dev->thread =
        CreateThread(nullptr, 0, printer_thread_func, (void*)printer_dev, 0, nullptr);
    if (!printer_dev->thread)
    {
      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(VCAPITYPE * backend_load_t)(rdpPrinterDriver**);
  PVIRTUALCHANNELENTRY entry = freerdp_load_channel_addin_entry("printer", backend, nullptr, 0);
  backend_load_t func = WINPR_FUNC_PTR_CAST(entry, backend_load_t);
  if (!func)
    return nullptr;
 
  rdpPrinterDriver* printer = nullptr;
  const UINT rc = func(&printer);
  if (rc != CHANNEL_RC_OK)
    return nullptr;
 
  return printer;
}
 
FREERDP_ENTRY_POINT(
    UINT VCAPITYPE printer_DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints))
{
  char* name = nullptr;
  char* driver_name = nullptr;
  BOOL default_backend = TRUE;
  RDPDR_PRINTER* device = nullptr;
  rdpPrinterDriver* driver = nullptr;
  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;
}