text: /*
   * Implementation of the Local Printprovider
   *
   * Copyright 2006-2009 Detlef Riekenberg
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
   */
  
  #include <stdarg.h>
  
  #define COBJMACROS
  
  #include "windef.h"
  #include "winbase.h"
  #include "wingdi.h"
  #include "winreg.h"
  #include "winspool.h"
  #include "winuser.h"
  #include "ddk/winddiui.h"
  #include "ddk/winsplp.h"
  
  #include "wine/debug.h"
  #include "wine/heap.h"
  #include "wine/list.h"
  #include "wine/unicode.h"
  #include "localspl_private.h"
  
  WINE_DEFAULT_DEBUG_CHANNEL(localspl);
  
  /* ############################### */
  
  static CRITICAL_SECTION monitor_handles_cs;
  static CRITICAL_SECTION_DEBUG monitor_handles_cs_debug =
  {
      0, 0, &monitor_handles_cs,
      { &monitor_handles_cs_debug.ProcessLocksList, &monitor_handles_cs_debug.ProcessLocksList },
        0, 0, { (DWORD_PTR)(__FILE__ ": monitor_handles_cs") }
  };
  static CRITICAL_SECTION monitor_handles_cs = { &monitor_handles_cs_debug, -1, 0, 0, 0, 0 };
  
  /* ############################### */
  
  typedef struct {
      WCHAR   src[MAX_PATH+MAX_PATH];
      WCHAR   dst[MAX_PATH+MAX_PATH];
      DWORD   srclen;
      DWORD   dstlen;
      DWORD   copyflags;
      BOOL    lazy;
  } apd_data_t;
  
  typedef struct {
      struct list     entry;
      LPWSTR          name;
      LPWSTR          dllname;
      PMONITORUI      monitorUI;
      LPMONITOR       monitor;
      HMODULE         hdll;
      DWORD           refcount;
      DWORD           dwMonitorSize;
  } monitor_t;
  
  typedef struct {
      LPCWSTR  envname;
      LPCWSTR  subdir;
      DWORD    driverversion;
      LPCWSTR  versionregpath;
      LPCWSTR  versionsubdir;
  } printenv_t;
  
  typedef struct {
      LPWSTR name;
      LPWSTR printername;
      monitor_t * pm;
      HANDLE hXcv;
  } printer_t;
  
  /* ############################### */
  
  static struct list monitor_handles = LIST_INIT( monitor_handles );
  static monitor_t * pm_localport;
  
  static const PRINTPROVIDOR * pprovider = NULL;
  
  static const WCHAR backslashW[] = {'\\',0};
  static const WCHAR bs_ports_bsW[] = {'\\','P','o','r','t','s','\\',0};
  static const WCHAR configuration_fileW[] = {'C','o','n','f','i','g','u','r','a','t','i','o','n',' ','F','i','l','e',0};
  static const WCHAR datatypeW[] = {'D','a','t','a','t','y','p','e',0};
  static const WCHAR data_fileW[] = {'D','a','t','a',' ','F','i','l','e',0};
  static const WCHAR dependent_filesW[] = {'D','e','p','e','n','d','e','n','t',' ','F','i','l','e','s',0};
  static const WCHAR driverW[] = {'D','r','i','v','e','r',0};
  static const WCHAR emptyW[] = {0};
  static const WCHAR fmt_driversW[] = { 'S','y','s','t','e','m','\\',
                                    'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
                                    'c','o','n','t','r','o','l','\\',
                                    'P','r','i','n','t','\\',
                                    'E','n','v','i','r','o','n','m','e','n','t','s','\\',
                                    '%','s','\\','D','r','i','v','e','r','s','%','s',0 };
  static const WCHAR fmt_printprocessorsW[] = { 'S','y','s','t','e','m','\\',
                                    'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
                                    'C','o','n','t','r','o','l','\\',
                                    'P','r','i','n','t','\\',
                                    'E','n','v','i','r','o','n','m','e','n','t','s','\\','%','s','\\',
                                    'P','r','i','n','t',' ','P','r','o','c','e','s','s','o','r','s',0 };
  static const WCHAR help_fileW[] = {'H','e','l','p',' ','F','i','l','e',0};
  static const WCHAR ia64_envnameW[] = {'W','i','n','d','o','w','s',' ','I','A','6','4',0};
  static const WCHAR ia64_subdirW[] = {'i','a','6','4',0};
  static const WCHAR localportW[] = {'L','o','c','a','l',' ','P','o','r','t',0};
  static const WCHAR monitorW[] = {'M','o','n','i','t','o','r',0};
  static const WCHAR monitorsW[] = {'S','y','s','t','e','m','\\',
                                  'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
                                  'C','o','n','t','r','o','l','\\',
                                  'P','r','i','n','t','\\',
                                  'M','o','n','i','t','o','r','s','\\',0};
  static const WCHAR monitorUIW[] = {'M','o','n','i','t','o','r','U','I',0};
  static const WCHAR previous_namesW[] = {'P','r','e','v','i','o','u','s',' ','N','a','m','e','s',0};
  static const WCHAR printersW[] = {'S','y','s','t','e','m','\\',
                                    'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
                                    'C','o','n','t','r','o','l','\\',
                                    'P','r','i','n','t','\\',
                                    'P','r','i','n','t','e','r','s',0};
  static const WCHAR spoolW[] = {'\\','s','p','o','o','l',0};
  static const WCHAR driversW[] = {'\\','d','r','i','v','e','r','s','\\',0};
  static const WCHAR spoolprtprocsW[] = {'\\','s','p','o','o','l','\\','p','r','t','p','r','o','c','s','\\',0};
  static const WCHAR version0_regpathW[] = {'\\','V','e','r','s','i','o','n','-','0',0};
  static const WCHAR version0_subdirW[] = {'\\','0',0};
  static const WCHAR version3_regpathW[] = {'\\','V','e','r','s','i','o','n','-','3',0};
  static const WCHAR version3_subdirW[] = {'\\','3',0};
  static const WCHAR versionW[] = {'V','e','r','s','i','o','n',0};
  static const WCHAR win40_envnameW[] = {'W','i','n','d','o','w','s',' ','4','.','0',0};
  static const WCHAR win40_subdirW[] = {'w','i','n','4','0',0};
  static const WCHAR winnt_cv_portsW[] = {'S','o','f','t','w','a','r','e','\\',
                                          'M','i','c','r','o','s','o','f','t','\\',
                                          'W','i','n','d','o','w','s',' ','N','T','\\',
                                          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
                                          'P','o','r','t','s',0};
  static const WCHAR winprintW[] = {'w','i','n','p','r','i','n','t',0};
  static const WCHAR x64_envnameW[] = {'W','i','n','d','o','w','s',' ','x','6','4',0};
  static const WCHAR x64_subdirW[] = {'x','6','4',0};
  static const WCHAR x86_envnameW[] = {'W','i','n','d','o','w','s',' ','N','T',' ','x','8','6',0};
  static const WCHAR x86_subdirW[] = {'w','3','2','x','8','6',0};
  static const WCHAR XcvMonitorW[] = {',','X','c','v','M','o','n','i','t','o','r',' ',0};
  static const WCHAR XcvPortW[] = {',','X','c','v','P','o','r','t',' ',0};
  
  
  static const printenv_t env_ia64 =  {ia64_envnameW, ia64_subdirW, 3,
                                       version3_regpathW, version3_subdirW};
  
  static const printenv_t env_x86 =   {x86_envnameW, x86_subdirW, 3,
                                       version3_regpathW, version3_subdirW};
  
  static const printenv_t env_x64 =   {x64_envnameW, x64_subdirW, 3,
                                       version3_regpathW, version3_subdirW};
  
  static const printenv_t env_win40 = {win40_envnameW, win40_subdirW, 0,
                                       version0_regpathW, version0_subdirW};
  
  static const printenv_t * const all_printenv[] = {&env_x86, &env_x64, &env_ia64, &env_win40};
  
  
  static const DWORD di_sizeof[] = {0, sizeof(DRIVER_INFO_1W), sizeof(DRIVER_INFO_2W),
                                       sizeof(DRIVER_INFO_3W), sizeof(DRIVER_INFO_4W),
                                       sizeof(DRIVER_INFO_5W), sizeof(DRIVER_INFO_6W),
                                    0, sizeof(DRIVER_INFO_8W)};
  
  
  /******************************************************************
   * strdupW [internal]
   *
   * create a copy of a unicode-string
   *
   */
  static LPWSTR strdupW(LPCWSTR p)
  {
      LPWSTR ret;
      DWORD len;
  
      if(!p) return NULL;
      len = (lstrlenW(p) + 1) * sizeof(WCHAR);
      ret = heap_alloc(len);
      if (ret) memcpy(ret, p, len);
      return ret;
  }
  
  /******************************************************************
   *  apd_copyfile [internal]
   *
   * Copy a file from the driverdirectory to the versioned directory
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE
   *
   */
  static BOOL apd_copyfile( WCHAR *pathname, WCHAR *file_part, apd_data_t *apd )
  {
      WCHAR *srcname;
      BOOL res;
  
      apd->src[apd->srclen] = '\0';
      apd->dst[apd->dstlen] = '\0';
  
      if (!pathname || !pathname[0]) {
          /* nothing to copy */
          return TRUE;
      }
  
      if (apd->copyflags & APD_COPY_FROM_DIRECTORY)
          srcname = pathname;
      else
      {
          srcname = apd->src;
          strcatW( srcname, file_part );
      }
      strcatW( apd->dst, file_part );
  
      TRACE("%s => %s\n", debugstr_w(srcname), debugstr_w(apd->dst));
  
      /* FIXME: handle APD_COPY_NEW_FILES */
      res = CopyFileW(srcname, apd->dst, FALSE);
      TRACE("got %d with %u\n", res, GetLastError());
  
      return apd->lazy || res;
  }
  
  /******************************************************************
   * copy_servername_from_name  (internal)
   *
   * for an external server, the serverpart from the name is copied.
   *
   * RETURNS
   *  the length (in WCHAR) of the serverpart (0 for the local computer)
   *  (-length), when the name is too long
   *
   */
  static LONG copy_servername_from_name(LPCWSTR name, LPWSTR target)
  {
      LPCWSTR server;
      LPWSTR  ptr;
      WCHAR   buffer[MAX_COMPUTERNAME_LENGTH +1];
      DWORD   len;
      DWORD   serverlen;
  
      if (target) *target = '\0';
  
      if (name == NULL) return 0;
      if ((name[0] != '\\') || (name[1] != '\\')) return 0;
  
      server = &name[2];
      /* skip over both backslash, find separator '\' */
      ptr = strchrW(server, '\\');
      serverlen = (ptr) ? ptr - server : lstrlenW(server);
  
      /* servername is empty */
      if (serverlen == 0) return 0;
  
      TRACE("found %s\n", debugstr_wn(server, serverlen));
  
      if (serverlen > MAX_COMPUTERNAME_LENGTH) return -serverlen;
  
      if (target) {
          memcpy(target, server, serverlen * sizeof(WCHAR));
          target[serverlen] = '\0';
      }
  
      len = sizeof(buffer) / sizeof(buffer[0]);
      if (GetComputerNameW(buffer, &len)) {
          if ((serverlen == len) && (strncmpiW(server, buffer, len) == 0)) {
              /* The requested Servername is our computername */
              return 0;
          }
      }
      return serverlen;
  }
  
  /******************************************************************
   * get_basename_from_name  (internal)
   *
   * skip over the serverpart from the full name
   *
   */
  static LPCWSTR get_basename_from_name(LPCWSTR name)
  {
      if (name == NULL)  return NULL;
      if ((name[0] == '\\') && (name[1] == '\\')) {
          /* skip over the servername and search for the following '\'  */
          name = strchrW(&name[2], '\\');
          if ((name) && (name[1])) {
              /* found a separator ('\') followed by a name:
                 skip over the separator and return the rest */
              name++;
          }
          else
          {
              /* no basename present (we found only a servername) */
              return NULL;
          }
      }
      return name;
  }
  
  /******************************************************************
   * monitor_unload [internal]
   *
   * release a printmonitor and unload it from memory, when needed
   *
   */
  static void monitor_unload(monitor_t * pm)
  {
      if (pm == NULL) return;
      TRACE("%p (refcount: %d) %s\n", pm, pm->refcount, debugstr_w(pm->name));
  
      EnterCriticalSection(&monitor_handles_cs);
  
      if (pm->refcount) pm->refcount--;
  
      if (pm->refcount == 0) {
          list_remove(&pm->entry);
          FreeLibrary(pm->hdll);
          heap_free(pm->name);
          heap_free(pm->dllname);
          heap_free(pm);
      }
      LeaveCriticalSection(&monitor_handles_cs);
  }
  
  /******************************************************************
   * monitor_unloadall [internal]
   *
   * release all registered printmonitors and unload them from memory, when needed
   *
   */
  
  static void monitor_unloadall(void)
  {
      monitor_t * pm;
      monitor_t * next;
  
      EnterCriticalSection(&monitor_handles_cs);
      /* iterate through the list, with safety against removal */
      LIST_FOR_EACH_ENTRY_SAFE(pm, next, &monitor_handles, monitor_t, entry)
      {
          /* skip monitorui dlls */
          if (pm->monitor) monitor_unload(pm);
      }
      LeaveCriticalSection(&monitor_handles_cs);
  }
  
  /******************************************************************
   * monitor_load [internal]
   *
   * load a printmonitor, get the dllname from the registry, when needed
   * initialize the monitor and dump found function-pointers
   *
   * On failure, SetLastError() is called and NULL is returned
   */
  
  static monitor_t * monitor_load(LPCWSTR name, LPWSTR dllname)
  {
      LPMONITOR2  (WINAPI *pInitializePrintMonitor2) (PMONITORINIT, LPHANDLE);
      PMONITORUI  (WINAPI *pInitializePrintMonitorUI)(VOID);
      LPMONITOREX (WINAPI *pInitializePrintMonitor)  (LPWSTR);
      DWORD (WINAPI *pInitializeMonitorEx)(LPWSTR, LPMONITOR);
      DWORD (WINAPI *pInitializeMonitor)  (LPWSTR);
  
      monitor_t * pm = NULL;
      monitor_t * cursor;
      LPWSTR  regroot = NULL;
      LPWSTR  driver = dllname;
  
      TRACE("(%s, %s)\n", debugstr_w(name), debugstr_w(dllname));
      /* Is the Monitor already loaded? */
      EnterCriticalSection(&monitor_handles_cs);
  
      if (name) {
          LIST_FOR_EACH_ENTRY(cursor, &monitor_handles, monitor_t, entry)
          {
              if (cursor->name && (lstrcmpW(name, cursor->name) == 0)) {
                  pm = cursor;
                  break;
              }
          }
      }
  
      if (pm == NULL) {
          pm = heap_alloc_zero(sizeof(monitor_t));
          if (pm == NULL) goto cleanup;
          list_add_tail(&monitor_handles, &pm->entry);
      }
      pm->refcount++;
  
      if (pm->name == NULL) {
          /* Load the monitor */
          LPMONITOREX pmonitorEx;
          DWORD   len;
  
          if (name) {
              len = lstrlenW(monitorsW) + lstrlenW(name) + 2;
              regroot = heap_alloc(len * sizeof(WCHAR));
          }
  
          if (regroot) {
              lstrcpyW(regroot, monitorsW);
              lstrcatW(regroot, name);
              /* Get the Driver from the Registry */
              if (driver == NULL) {
                  HKEY    hroot;
                  DWORD   namesize;
                  if (RegOpenKeyW(HKEY_LOCAL_MACHINE, regroot, &hroot) == ERROR_SUCCESS) {
                      if (RegQueryValueExW(hroot, driverW, NULL, NULL, NULL,
                                          &namesize) == ERROR_SUCCESS) {
                          driver = heap_alloc(namesize);
                          RegQueryValueExW(hroot, driverW, NULL, NULL, (LPBYTE) driver, &namesize) ;
                      }
                      RegCloseKey(hroot);
                  }
              }
          }
  
          pm->name = strdupW(name);
          pm->dllname = strdupW(driver);
  
          if ((name && (!regroot || !pm->name)) || !pm->dllname) {
              monitor_unload(pm);
              SetLastError(ERROR_NOT_ENOUGH_MEMORY);
              pm = NULL;
              goto cleanup;
          }
  
          pm->hdll = LoadLibraryW(driver);
          TRACE("%p: LoadLibrary(%s) => %d\n", pm->hdll, debugstr_w(driver), GetLastError());
  
          if (pm->hdll == NULL) {
              monitor_unload(pm);
              SetLastError(ERROR_MOD_NOT_FOUND);
              pm = NULL;
              goto cleanup;
          }
  
          pInitializePrintMonitor2  = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitor2");
          pInitializePrintMonitorUI = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitorUI");
          pInitializePrintMonitor   = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitor");
          pInitializeMonitorEx = (void *)GetProcAddress(pm->hdll, "InitializeMonitorEx");
          pInitializeMonitor   = (void *)GetProcAddress(pm->hdll, "InitializeMonitor");
  
  
          TRACE("%p: %s,pInitializePrintMonitor2\n", pInitializePrintMonitor2, debugstr_w(driver));
          TRACE("%p: %s,pInitializePrintMonitorUI\n", pInitializePrintMonitorUI, debugstr_w(driver));
          TRACE("%p: %s,pInitializePrintMonitor\n", pInitializePrintMonitor, debugstr_w(driver));
          TRACE("%p: %s,pInitializeMonitorEx\n", pInitializeMonitorEx, debugstr_w(driver));
          TRACE("%p: %s,pInitializeMonitor\n", pInitializeMonitor, debugstr_w(driver));
  
          if (pInitializePrintMonitorUI  != NULL) {
              pm->monitorUI = pInitializePrintMonitorUI();
              TRACE("%p: MONITORUI from %s,InitializePrintMonitorUI()\n", pm->monitorUI, debugstr_w(driver));
              if (pm->monitorUI) {
                  TRACE("0x%08x: dwMonitorSize (%d)\n",
                          pm->monitorUI->dwMonitorUISize, pm->monitorUI->dwMonitorUISize);
  
              }
          }
  
          if (pInitializePrintMonitor && regroot) {
              pmonitorEx = pInitializePrintMonitor(regroot);
              TRACE("%p: LPMONITOREX from %s,InitializePrintMonitor(%s)\n",
                      pmonitorEx, debugstr_w(driver), debugstr_w(regroot));
  
              if (pmonitorEx) {
                  pm->dwMonitorSize = pmonitorEx->dwMonitorSize;
                  pm->monitor = &(pmonitorEx->Monitor);
              }
          }
  
          if (pm->monitor) {
              TRACE("0x%08x: dwMonitorSize (%d)\n", pm->dwMonitorSize, pm->dwMonitorSize);
  
          }
  
          if (!pm->monitor && regroot) {
              if (pInitializePrintMonitor2 != NULL) {
                  FIXME("%s,InitializePrintMonitor2 not implemented\n", debugstr_w(driver));
              }
              if (pInitializeMonitorEx != NULL) {
                  FIXME("%s,InitializeMonitorEx not implemented\n", debugstr_w(driver));
              }
              if (pInitializeMonitor != NULL) {
                  FIXME("%s,InitializeMonitor not implemented\n", debugstr_w(driver));
              }
          }
          if (!pm->monitor && !pm->monitorUI) {
              monitor_unload(pm);
              SetLastError(ERROR_PROC_NOT_FOUND);
              pm = NULL;
          }
      }
  cleanup:
      if ((pm_localport ==  NULL) && (pm != NULL) && (lstrcmpW(pm->name, localportW) == 0)) {
          pm->refcount++;
          pm_localport = pm;
      }
      LeaveCriticalSection(&monitor_handles_cs);
      if (driver != dllname) heap_free(driver);
      heap_free(regroot);
      TRACE("=> %p\n", pm);
      return pm;
  }
  
  /******************************************************************
   * monitor_loadall [internal]
   *
   * Load all registered monitors
   *
   */
  static DWORD monitor_loadall(void)
  {
      monitor_t * pm;
      DWORD   registered = 0;
      DWORD   loaded = 0;
      HKEY    hmonitors;
      WCHAR   buffer[MAX_PATH];
      DWORD   id = 0;
  
      if (RegOpenKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hmonitors) == ERROR_SUCCESS) {
          RegQueryInfoKeyW(hmonitors, NULL, NULL, NULL, &registered, NULL, NULL,
                          NULL, NULL, NULL, NULL, NULL);
  
          TRACE("%d monitors registered\n", registered);
  
          while (id < registered) {
              buffer[0] = '\0';
              RegEnumKeyW(hmonitors, id, buffer, MAX_PATH);
              pm = monitor_load(buffer, NULL);
              if (pm) loaded++;
              id++;
          }
          RegCloseKey(hmonitors);
      }
      TRACE("%d monitors loaded\n", loaded);
      return loaded;
  }
  
  /******************************************************************
   * monitor_loadui [internal]
   *
   * load the userinterface-dll for a given portmonitor
   *
   * On failure, NULL is returned
   */
  static monitor_t * monitor_loadui(monitor_t * pm)
  {
      monitor_t * pui = NULL;
      WCHAR   buffer[MAX_PATH];
      HANDLE  hXcv;
      DWORD   len;
      DWORD   res;
  
      if (pm == NULL) return NULL;
      TRACE("(%p) => dllname: %s\n", pm, debugstr_w(pm->dllname));
  
      /* Try the Portmonitor first; works for many monitors */
      if (pm->monitorUI) {
          EnterCriticalSection(&monitor_handles_cs);
          pm->refcount++;
          LeaveCriticalSection(&monitor_handles_cs);
          return pm;
      }
  
      /* query the userinterface-dllname from the Portmonitor */
      if ((pm->monitor) && (pm->monitor->pfnXcvDataPort)) {
          /* building (",XcvMonitor %s",pm->name) not needed yet */
          res = pm->monitor->pfnXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
          TRACE("got %u with %p\n", res, hXcv);
          if (res) {
              res = pm->monitor->pfnXcvDataPort(hXcv, monitorUIW, NULL, 0, (BYTE *) buffer, sizeof(buffer), &len);
              TRACE("got %u with %s\n", res, debugstr_w(buffer));
              if (res == ERROR_SUCCESS) pui = monitor_load(NULL, buffer);
              pm->monitor->pfnXcvClosePort(hXcv);
          }
      }
      return pui;
  }
  
  /******************************************************************
   * monitor_load_by_port [internal]
   *
   * load a printmonitor for a given port
   *
   * On failure, NULL is returned
   */
  
  static monitor_t * monitor_load_by_port(LPCWSTR portname)
  {
      HKEY    hroot;
      HKEY    hport;
      LPWSTR  buffer;
      monitor_t * pm = NULL;
      DWORD   registered = 0;
      DWORD   id = 0;
      DWORD   len;
  
      TRACE("(%s)\n", debugstr_w(portname));
  
      /* Try the Local Monitor first */
      if (RegOpenKeyW(HKEY_LOCAL_MACHINE, winnt_cv_portsW, &hroot) == ERROR_SUCCESS) {
          if (RegQueryValueExW(hroot, portname, NULL, NULL, NULL, &len) == ERROR_SUCCESS) {
              /* found the portname */
              RegCloseKey(hroot);
              return monitor_load(localportW, NULL);
          }
          RegCloseKey(hroot);
      }
  
      len = MAX_PATH + lstrlenW(bs_ports_bsW) + lstrlenW(portname) + 1;
      buffer = heap_alloc(len * sizeof(WCHAR));
      if (buffer == NULL) return NULL;
  
      if (RegOpenKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) == ERROR_SUCCESS) {
          EnterCriticalSection(&monitor_handles_cs);
          RegQueryInfoKeyW(hroot, NULL, NULL, NULL, &registered, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
  
          while ((pm == NULL) && (id < registered)) {
              buffer[0] = '\0';
              RegEnumKeyW(hroot, id, buffer, MAX_PATH);
              TRACE("testing %s\n", debugstr_w(buffer));
              len = lstrlenW(buffer);
              lstrcatW(buffer, bs_ports_bsW);
              lstrcatW(buffer, portname);
              if (RegOpenKeyW(hroot, buffer, &hport) == ERROR_SUCCESS) {
                  RegCloseKey(hport);
                  buffer[len] = '\0';             /* use only the Monitor-Name */
                  pm = monitor_load(buffer, NULL);
              }
              id++;
          }
          LeaveCriticalSection(&monitor_handles_cs);
          RegCloseKey(hroot);
      }
      heap_free(buffer);
      return pm;
  }
  
  /******************************************************************
   * Return the number of bytes for an multi_sz string.
   * The result includes all \0s
   * (specifically the extra \0, that is needed as multi_sz terminator).
   */
  static int multi_sz_lenW(const WCHAR *str)
  {
      const WCHAR *ptr = str;
      if (!str) return 0;
      do
      {
          ptr += lstrlenW(ptr) + 1;
      } while (*ptr);
  
      return (ptr - str + 1) * sizeof(WCHAR);
  }
  
  /******************************************************************
   * validate_envW [internal]
   *
   * validate the user-supplied printing-environment
   *
   * PARAMS
   *  env  [I] PTR to Environment-String or NULL
   *
   * RETURNS
   *  Success:  PTR to printenv_t
   *  Failure:  NULL and ERROR_INVALID_ENVIRONMENT
   *
   * NOTES
   *  An empty string is handled the same way as NULL.
   *
   */
  
  static const  printenv_t * validate_envW(LPCWSTR env)
  {
      const printenv_t *result = NULL;
      unsigned int i;
  
      TRACE("(%s)\n", debugstr_w(env));
      if (env && env[0])
      {
          for (i = 0; i < sizeof(all_printenv)/sizeof(all_printenv[0]); i++)
          {
              if (lstrcmpiW(env, all_printenv[i]->envname) == 0)
              {
                  result = all_printenv[i];
                  break;
              }
          }
          if (result == NULL) {
              FIXME("unsupported Environment: %s\n", debugstr_w(env));
              SetLastError(ERROR_INVALID_ENVIRONMENT);
          }
          /* on win9x, only "Windows 4.0" is allowed, but we ignore this */
      }
      else
      {
          result = (GetVersion() & 0x80000000) ? &env_win40 : &env_x86;
      }
  
      TRACE("=> using %p: %s\n", result, debugstr_w(result ? result->envname : NULL));
      return result;
  }
  
  /*****************************************************************************
   * enumerate the local monitors (INTERNAL)
   *
   * returns the needed size (in bytes) for pMonitors
   * and  *lpreturned is set to number of entries returned in pMonitors
   *
   * Language-Monitors are also installed in the same Registry-Location but
   * they are filtered in Windows (not returned by EnumMonitors).
   * We do no filtering to simplify our Code.
   *
   */
  static DWORD get_local_monitors(DWORD level, LPBYTE pMonitors, DWORD cbBuf, LPDWORD lpreturned)
  {
      HKEY    hroot = NULL;
      HKEY    hentry = NULL;
      LPWSTR  ptr;
      LPMONITOR_INFO_2W mi;
      WCHAR   buffer[MAX_PATH];
      WCHAR   dllname[MAX_PATH];
      DWORD   dllsize;
      DWORD   len;
      DWORD   index = 0;
      DWORD   needed = 0;
      DWORD   numentries;
      DWORD   entrysize;
  
      entrysize = (level == 1) ? sizeof(MONITOR_INFO_1W) : sizeof(MONITOR_INFO_2W);
  
      numentries = *lpreturned;       /* this is 0, when we scan the registry */
      len = entrysize * numentries;
      ptr = (LPWSTR) &pMonitors[len];
  
      numentries = 0;
      len = sizeof(buffer)/sizeof(buffer[0]);
      buffer[0] = '\0';
  
      /* Windows creates the "Monitors"-Key on reboot / start "spooler" */
      if (RegCreateKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) == ERROR_SUCCESS) {
          /* Scan all Monitor-Registry-Keys */
          while (RegEnumKeyExW(hroot, index, buffer, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
              TRACE("Monitor_%d: %s\n", numentries, debugstr_w(buffer));
              dllsize = sizeof(dllname);
              dllname[0] = '\0';
  
              /* The Monitor must have a Driver-DLL */
              if (RegOpenKeyExW(hroot, buffer, 0, KEY_READ, &hentry) == ERROR_SUCCESS) {
                  if (RegQueryValueExW(hentry, driverW, NULL, NULL, (LPBYTE) dllname, &dllsize) == ERROR_SUCCESS) {
                      /* We found a valid DLL for this Monitor. */
                      TRACE("using Driver: %s\n", debugstr_w(dllname));
                  }
                  RegCloseKey(hentry);
              }
  
              /* Windows returns only Port-Monitors here, but to simplify our code,
                 we do no filtering for Language-Monitors */
              if (dllname[0]) {
                  numentries++;
                  needed += entrysize;
                  needed += (len+1) * sizeof(WCHAR);  /* len is lstrlenW(monitorname) */
                  if (level > 1) {
                      /* we install and return only monitors for "Windows NT x86" */
                      needed += (lstrlenW(x86_envnameW) +1) * sizeof(WCHAR);
                      needed += dllsize;
                  }
  
                  /* required size is calculated. Now fill the user-buffer */
                  if (pMonitors && (cbBuf >= needed)){
                      mi = (LPMONITOR_INFO_2W) pMonitors;
                      pMonitors += entrysize;
  
                      TRACE("%p: writing MONITOR_INFO_%dW #%d\n", mi, level, numentries);
                      mi->pName = ptr;
                      lstrcpyW(ptr, buffer);      /* Name of the Monitor */
                      ptr += (len+1);               /* len is lstrlenW(monitorname) */
                      if (level > 1) {
                          mi->pEnvironment = ptr;
                          lstrcpyW(ptr, x86_envnameW); /* fixed to "Windows NT x86" */
                          ptr += (lstrlenW(x86_envnameW)+1);
  
                          mi->pDLLName = ptr;
                          lstrcpyW(ptr, dllname);         /* Name of the Driver-DLL */
                          ptr += (dllsize / sizeof(WCHAR));
                      }
                  }
              }
              index++;
              len = sizeof(buffer)/sizeof(buffer[0]);
              buffer[0] = '\0';
          }
          RegCloseKey(hroot);
      }
      *lpreturned = numentries;
      TRACE("need %d byte for %d entries\n", needed, numentries);
      return needed;
  }
  
  /*****************************************************************************
   * enumerate the local print processors (INTERNAL)
   *
   * returns the needed size (in bytes) for pPPInfo
   * and  *lpreturned is set to number of entries returned in pPPInfo
   *
   */
  static DWORD get_local_printprocessors(LPWSTR regpathW, LPBYTE pPPInfo, DWORD cbBuf, LPDWORD lpreturned)
  {
      HKEY    hroot = NULL;
      HKEY    hentry = NULL;
      LPWSTR  ptr;
      PPRINTPROCESSOR_INFO_1W ppi;
      WCHAR   buffer[MAX_PATH];
      WCHAR   dllname[MAX_PATH];
      DWORD   dllsize;
      DWORD   len;
      DWORD   index = 0;
      DWORD   needed = 0;
      DWORD   numentries;
  
      numentries = *lpreturned;       /* this is 0, when we scan the registry */
      len = numentries * sizeof(PRINTPROCESSOR_INFO_1W);
      ptr = (LPWSTR) &pPPInfo[len];
  
      numentries = 0;
      len = sizeof(buffer)/sizeof(buffer[0]);
      buffer[0] = '\0';
  
      if (RegCreateKeyW(HKEY_LOCAL_MACHINE, regpathW, &hroot) == ERROR_SUCCESS) {
          /* add "winprint" first */
          numentries++;
          needed = sizeof(PRINTPROCESSOR_INFO_1W) + sizeof(winprintW);
          if (pPPInfo && (cbBuf >= needed)){
              ppi = (PPRINTPROCESSOR_INFO_1W) pPPInfo;
              pPPInfo += sizeof(PRINTPROCESSOR_INFO_1W);
  
              TRACE("%p: writing PRINTPROCESSOR_INFO_1W #%d\n", ppi, numentries);
              ppi->pName = ptr;
              lstrcpyW(ptr, winprintW);      /* Name of the Print Processor */
              ptr += sizeof(winprintW) / sizeof(WCHAR);
          }
  
          /* Scan all Printprocessor Keys */
          while ((RegEnumKeyExW(hroot, index, buffer, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) &&
              (lstrcmpiW(buffer, winprintW) != 0)) {
              TRACE("PrintProcessor_%d: %s\n", numentries, debugstr_w(buffer));
              dllsize = sizeof(dllname);
              dllname[0] = '\0';
  
              /* The Print Processor must have a Driver-DLL */
              if (RegOpenKeyExW(hroot, buffer, 0, KEY_READ, &hentry) == ERROR_SUCCESS) {
                  if (RegQueryValueExW(hentry, driverW, NULL, NULL, (LPBYTE) dllname, &dllsize) == ERROR_SUCCESS) {
                      /* We found a valid DLL for this Print Processor */
                      TRACE("using Driver: %s\n", debugstr_w(dllname));
                  }
                  RegCloseKey(hentry);
              }
  
              if (dllname[0]) {
                  numentries++;
                  needed += sizeof(PRINTPROCESSOR_INFO_1W);
                  needed += (len+1) * sizeof(WCHAR);  /* len is lstrlenW(printprocessor name) */
  
                  /* required size is calculated. Now fill the user-buffer */
                  if (pPPInfo && (cbBuf >= needed)){
                      ppi = (PPRINTPROCESSOR_INFO_1W) pPPInfo;
                      pPPInfo += sizeof(PRINTPROCESSOR_INFO_1W);
  
                      TRACE("%p: writing PRINTPROCESSOR_INFO_1W #%d\n", ppi, numentries);
                      ppi->pName = ptr;
                      lstrcpyW(ptr, buffer);      /* Name of the Print Processor */
                      ptr += (len+1);             /* len is lstrlenW(printprosessor name) */
                  }
              }
              index++;
              len = sizeof(buffer)/sizeof(buffer[0]);
              buffer[0] = '\0';
          }
          RegCloseKey(hroot);
      }
      *lpreturned = numentries;
      TRACE("need %d byte for %d entries\n", needed, numentries);
      return needed;
  }
  
  /******************************************************************
   * enumerate the local Ports from all loaded monitors (internal)
   *
   * returns the needed size (in bytes) for pPorts
   * and  *lpreturned is set to number of entries returned in pPorts
   *
   */
  static DWORD get_ports_from_all_monitors(DWORD level, LPBYTE pPorts, DWORD cbBuf, LPDWORD lpreturned)
  {
      monitor_t * pm;
      LPWSTR      ptr;
      LPPORT_INFO_2W cache;
      LPPORT_INFO_2W out;
      LPBYTE  pi_buffer = NULL;
      DWORD   pi_allocated = 0;
      DWORD   pi_needed;
      DWORD   pi_index;
      DWORD   pi_returned;
      DWORD   res;
      DWORD   outindex = 0;
      DWORD   needed;
      DWORD   numentries;
      DWORD   entrysize;
  
  
      TRACE("(%d, %p, %d, %p)\n", level, pPorts, cbBuf, lpreturned);
      entrysize = (level == 1) ? sizeof(PORT_INFO_1W) : sizeof(PORT_INFO_2W);
  
      numentries = *lpreturned;       /* this is 0, when we scan the registry */
      needed = entrysize * numentries;
      ptr = (LPWSTR) &pPorts[needed];
  
      numentries = 0;
      needed = 0;
  
      LIST_FOR_EACH_ENTRY(pm, &monitor_handles, monitor_t, entry)
      {
          if ((pm->monitor) && (pm->monitor->pfnEnumPorts)) {
              pi_needed = 0;
              pi_returned = 0;
              res = pm->monitor->pfnEnumPorts(NULL, level, pi_buffer, pi_allocated, &pi_needed, &pi_returned);
              if (!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
                  /* Do not use heap_realloc (we do not need the old data in the buffer) */
                  heap_free(pi_buffer);
                  pi_buffer = heap_alloc(pi_needed);
                  pi_allocated = (pi_buffer) ? pi_needed : 0;
                  res = pm->monitor->pfnEnumPorts(NULL, level, pi_buffer, pi_allocated, &pi_needed, &pi_returned);
              }
              TRACE("(%s) got %d with %d (need %d byte for %d entries)\n",
                    debugstr_w(pm->name), res, GetLastError(), pi_needed, pi_returned);
  
              numentries += pi_returned;
              needed += pi_needed;
  
              /* fill the output-buffer (pPorts), if we have one */
              if (pPorts && (cbBuf >= needed ) && pi_buffer) {
                  pi_index = 0;
                  while (pi_returned > pi_index) {
                      cache = (LPPORT_INFO_2W) &pi_buffer[pi_index * entrysize];
                      out = (LPPORT_INFO_2W) &pPorts[outindex * entrysize];
                      out->pPortName = ptr;
                      lstrcpyW(ptr, cache->pPortName);
                      ptr += (lstrlenW(ptr)+1);
                      if (level > 1) {
                          out->pMonitorName = ptr;
                          lstrcpyW(ptr,  cache->pMonitorName);
                          ptr += (lstrlenW(ptr)+1);
  
                          out->pDescription = ptr;
                          lstrcpyW(ptr,  cache->pDescription);
                          ptr += (lstrlenW(ptr)+1);
                          out->fPortType = cache->fPortType;
                          out->Reserved = cache->Reserved;
                      }
                      pi_index++;
                      outindex++;
                  }
              }
          }
      }
      /* the temporary portinfo-buffer is no longer needed */
      heap_free(pi_buffer);
  
      *lpreturned = numentries;
      TRACE("need %d byte for %d entries\n", needed, numentries);
      return needed;
  }
  
  
  /*****************************************************************************
   * open_driver_reg [internal]
   *
   * opens the registry for the printer drivers depending on the given input
   * variable pEnvironment
   *
   * RETURNS:
   *    Success: the opened hkey
   *    Failure: NULL
   */
  static HKEY open_driver_reg(LPCWSTR pEnvironment)
  {
      HKEY  retval = NULL;
      LPWSTR buffer;
      const printenv_t * env;
  
      TRACE("(%s)\n", debugstr_w(pEnvironment));
  
      env = validate_envW(pEnvironment);
      if (!env) return NULL;
  
      buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(fmt_driversW) +
                  (lstrlenW(env->envname) + lstrlenW(env->versionregpath)) * sizeof(WCHAR));
  
      if (buffer) {
          wsprintfW(buffer, fmt_driversW, env->envname, env->versionregpath);
          RegCreateKeyW(HKEY_LOCAL_MACHINE, buffer, &retval);
          HeapFree(GetProcessHeap(), 0, buffer);
      }
      return retval;
  }
  
  /*****************************************************************************
   * fpGetPrinterDriverDirectory [exported through PRINTPROVIDOR]
   *
   * Return the PATH for the Printer-Drivers
   *
   * PARAMS
   *   pName            [I] Servername (NT only) or NULL (local Computer)
   *   pEnvironment     [I] Printing-Environment (see below) or NULL (Default)
   *   Level            [I] Structure-Level (must be 1)
   *   pDriverDirectory [O] PTR to Buffer that receives the Result
   *   cbBuf            [I] Size of Buffer at pDriverDirectory
   *   pcbNeeded        [O] PTR to DWORD that receives the size in Bytes used /
   *                        required for pDriverDirectory
   *
   * RETURNS
   *   Success: TRUE  and in pcbNeeded the Bytes used in pDriverDirectory
   *   Failure: FALSE and in pcbNeeded the Bytes required for pDriverDirectory,
   *            if cbBuf is too small
   *
   *   Native Values returned in pDriverDirectory on Success:
   *|  NT(Windows NT x86):  "%winsysdir%\\spool\\DRIVERS\\w32x86"
   *|  NT(Windows 4.0):     "%winsysdir%\\spool\\DRIVERS\\win40"
   *|  win9x(Windows 4.0):  "%winsysdir%"
   *
   *   "%winsysdir%" is the Value from GetSystemDirectoryW()
   *
   */
  static BOOL WINAPI fpGetPrinterDriverDirectory(LPWSTR pName, LPWSTR pEnvironment,
              DWORD Level, LPBYTE pDriverDirectory, DWORD cbBuf, LPDWORD pcbNeeded)
  {
      DWORD needed;
      const printenv_t * env;
      WCHAR * const dir = (WCHAR *)pDriverDirectory;
  
      TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName),
            debugstr_w(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
  
      if (pName != NULL && pName[0]) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_INVALID_PARAMETER);
          return FALSE;
      }
  
      env = validate_envW(pEnvironment);
      if (!env) return FALSE;  /* pEnvironment invalid or unsupported */
  
  
      /* GetSystemDirectoryW returns number of WCHAR including the '\0' */
      needed = GetSystemDirectoryW(NULL, 0);
      /* add the Size for the Subdirectories */
      needed += lstrlenW(spoolW);
      needed += lstrlenW(driversW);
      needed += lstrlenW(env->subdir);
      needed *= sizeof(WCHAR);  /* return-value is size in Bytes */
  
      *pcbNeeded = needed;
  
      if (needed > cbBuf) {
          SetLastError(ERROR_INSUFFICIENT_BUFFER);
          return FALSE;
      }
  
      if (dir == NULL) {
          /* ERROR_INVALID_USER_BUFFER is NT, ERROR_INVALID_PARAMETER is win9x */
          SetLastError(ERROR_INVALID_USER_BUFFER);
          return FALSE;
      }
  
      GetSystemDirectoryW( dir, cbBuf / sizeof(WCHAR) );
      /* add the Subdirectories */
      lstrcatW( dir, spoolW );
      CreateDirectoryW( dir, NULL );
      lstrcatW( dir, driversW );
      CreateDirectoryW( dir, NULL );
      lstrcatW( dir, env->subdir );
      CreateDirectoryW( dir, NULL );
  
      TRACE( "=> %s\n", debugstr_w( dir ) );
      return TRUE;
  }
  
  /******************************************************************
   * driver_load [internal]
   *
   * load a driver user interface dll
   *
   * On failure, NULL is returned
   *
   */
  
  static HMODULE driver_load(const printenv_t * env, LPWSTR dllname)
  {
      WCHAR fullname[MAX_PATH];
      HMODULE hui;
      DWORD len;
  
      TRACE("(%p, %s)\n", env, debugstr_w(dllname));
  
      /* build the driverdir */
      len = sizeof(fullname) -
            (lstrlenW(env->versionsubdir) + 1 + lstrlenW(dllname) + 1) * sizeof(WCHAR);
  
      if (!fpGetPrinterDriverDirectory(NULL, (LPWSTR) env->envname, 1,
                                       (LPBYTE) fullname, len, &len)) {
          /* Should never fail */
          SetLastError(ERROR_BUFFER_OVERFLOW);
          return NULL;
      }
  
      lstrcatW(fullname, env->versionsubdir);
      lstrcatW(fullname, backslashW);
      lstrcatW(fullname, dllname);
  
      hui = LoadLibraryW(fullname);
      TRACE("%p: LoadLibrary(%s) %d\n", hui, debugstr_w(fullname), GetLastError());
  
      return hui;
  }
  
  /******************************************************************
   *  printer_free
   *  free the data pointer of an opened printer
   */
  static VOID printer_free(printer_t * printer)
  {
      if (printer->hXcv)
          printer->pm->monitor->pfnXcvClosePort(printer->hXcv);
  
      monitor_unload(printer->pm);
  
      heap_free(printer->printername);
      heap_free(printer->name);
      heap_free(printer);
  }
  
  /******************************************************************
   *  printer_alloc_handle
   *  alloc a printer handle and remember the data pointer in the printer handle table
   *
   */
  static HANDLE printer_alloc_handle(LPCWSTR name, LPPRINTER_DEFAULTSW pDefault)
  {
      WCHAR servername[MAX_COMPUTERNAME_LENGTH + 1];
      printer_t *printer = NULL;
      LPCWSTR printername;
      HKEY    hkeyPrinters;
      HKEY    hkeyPrinter;
      DWORD   len;
  
      if (copy_servername_from_name(name, servername)) {
          FIXME("server %s not supported\n", debugstr_w(servername));
          SetLastError(ERROR_INVALID_PRINTER_NAME);
          return NULL;
      }
  
      printername = get_basename_from_name(name);
      if (name != printername) TRACE("converted %s to %s\n", debugstr_w(name), debugstr_w(printername));
  
      /* an empty printername is invalid */
      if (printername && (!printername[0])) {
          SetLastError(ERROR_INVALID_PARAMETER);
          return NULL;
      }
  
      printer = heap_alloc_zero(sizeof(printer_t));
      if (!printer) goto end;
  
      /* clone the base name. This is NULL for the printserver */
      printer->printername = strdupW(printername);
  
      /* clone the full name */
      printer->name = strdupW(name);
      if (name && (!printer->name)) {
          printer_free(printer);
          printer = NULL;
      }
      if (printername) {
          len = sizeof(XcvMonitorW)/sizeof(WCHAR) - 1;
          if (strncmpW(printername, XcvMonitorW, len) == 0) {
              /* OpenPrinter(",XcvMonitor ", ...) detected */
              TRACE(",XcvMonitor: %s\n", debugstr_w(&printername[len]));
              printer->pm = monitor_load(&printername[len], NULL);
              if (printer->pm == NULL) {
                  printer_free(printer);
                  SetLastError(ERROR_UNKNOWN_PORT);
                  printer = NULL;
                  goto end;
              }
          }
          else
          {
              len = sizeof(XcvPortW)/sizeof(WCHAR) - 1;
              if (strncmpW( printername, XcvPortW, len) == 0) {
                  /* OpenPrinter(",XcvPort ", ...) detected */
                  TRACE(",XcvPort: %s\n", debugstr_w(&printername[len]));
                  printer->pm = monitor_load_by_port(&printername[len]);
                  if (printer->pm == NULL) {
                      printer_free(printer);
                      SetLastError(ERROR_UNKNOWN_PORT);
                      printer = NULL;
                      goto end;
                  }
              }
          }
  
          if (printer->pm) {
              if ((printer->pm->monitor) && (printer->pm->monitor->pfnXcvOpenPort)) {
                  printer->pm->monitor->pfnXcvOpenPort(&printername[len],
                                                      pDefault ? pDefault->DesiredAccess : 0,
                                                      &printer->hXcv);
              }
              if (printer->hXcv == NULL) {
                  printer_free(printer);
                  SetLastError(ERROR_INVALID_PARAMETER);
                  printer = NULL;
                  goto end;
              }
          }
          else
          {
              /* Does the Printer exist? */
              if (RegCreateKeyW(HKEY_LOCAL_MACHINE, printersW, &hkeyPrinters) != ERROR_SUCCESS) {
                  ERR("Can't create Printers key\n");
                  printer_free(printer);
                  SetLastError(ERROR_INVALID_PRINTER_NAME);
                  printer = NULL;
                  goto end;
              }
              if (RegOpenKeyW(hkeyPrinters, printername, &hkeyPrinter) != ERROR_SUCCESS) {
                  WARN("Printer not found in Registry: %s\n", debugstr_w(printername));
                  RegCloseKey(hkeyPrinters);
                  printer_free(printer);
                  SetLastError(ERROR_INVALID_PRINTER_NAME);
                  printer = NULL;
                  goto end;
              }
              RegCloseKey(hkeyPrinter);
              RegCloseKey(hkeyPrinters);
          }
      }
      else
      {
          TRACE("using the local printserver\n");
      }
  
  end:
  
      TRACE("==> %p\n", printer);
      return (HANDLE)printer;
  }
  
  static inline WCHAR *get_file_part( WCHAR *name )
  {
      WCHAR *ptr = strrchrW( name, '\\' );
      if (ptr) return ptr + 1;
      return name;
  }
  
  /******************************************************************************
   *  myAddPrinterDriverEx [internal]
   *
   * Install a Printer Driver with the Option to upgrade / downgrade the Files
   * and a special mode with lazy error checking.
   *
   */
  static BOOL myAddPrinterDriverEx(DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags, BOOL lazy)
  {
      const printenv_t *env;
      apd_data_t apd;
      DRIVER_INFO_8W di;
      BOOL    (WINAPI *pDrvDriverEvent)(DWORD, DWORD, LPBYTE, LPARAM);
      HMODULE hui;
      WCHAR *file;
      HKEY    hroot;
      HKEY    hdrv;
      DWORD   disposition;
      DWORD   len;
      LONG    lres;
      BOOL    res;
  
      /* we need to set all entries in the Registry, independent from the Level of
         DRIVER_INFO, that the caller supplied */
  
      ZeroMemory(&di, sizeof(di));
      if (pDriverInfo && (level < (sizeof(di_sizeof) / sizeof(di_sizeof[0])))) {
          memcpy(&di, pDriverInfo, di_sizeof[level]);
      }
  
      /* dump the most used infos */
      TRACE("%p: .cVersion    : 0x%x/%d\n", pDriverInfo, di.cVersion, di.cVersion);
      TRACE("%p: .pName       : %s\n", di.pName, debugstr_w(di.pName));
      TRACE("%p: .pEnvironment: %s\n", di.pEnvironment, debugstr_w(di.pEnvironment));
      TRACE("%p: .pDriverPath : %s\n", di.pDriverPath, debugstr_w(di.pDriverPath));
      TRACE("%p: .pDataFile   : %s\n", di.pDataFile, debugstr_w(di.pDataFile));
      TRACE("%p: .pConfigFile : %s\n", di.pConfigFile, debugstr_w(di.pConfigFile));
      TRACE("%p: .pHelpFile   : %s\n", di.pHelpFile, debugstr_w(di.pHelpFile));
      /* dump only the first of the additional Files */
      TRACE("%p: .pDependentFiles: %s\n", di.pDependentFiles, debugstr_w(di.pDependentFiles));
  
  
      /* check environment */
      env = validate_envW(di.pEnvironment);
      if (env == NULL) return FALSE;        /* ERROR_INVALID_ENVIRONMENT */
  
      /* fill the copy-data / get the driverdir */
      len = sizeof(apd.src) - sizeof(version3_subdirW) - sizeof(WCHAR);
      if (!fpGetPrinterDriverDirectory(NULL, (LPWSTR) env->envname, 1,
                                      (LPBYTE) apd.src, len, &len)) {
          /* Should never fail */
          return FALSE;
      }
      memcpy(apd.dst, apd.src, len);
      lstrcatW(apd.src, backslashW);
      apd.srclen = lstrlenW(apd.src);
      lstrcatW(apd.dst, env->versionsubdir);
      lstrcatW(apd.dst, backslashW);
      apd.dstlen = lstrlenW(apd.dst);
      apd.copyflags = dwFileCopyFlags;
      apd.lazy = lazy;
      CreateDirectoryW(apd.src, NULL);
      CreateDirectoryW(apd.dst, NULL);
  
      hroot = open_driver_reg(env->envname);
      if (!hroot) {
          ERR("Can't create Drivers key\n");
          return FALSE;
      }
  
      /* Fill the Registry for the Driver */
      if ((lres = RegCreateKeyExW(hroot, di.pName, 0, NULL, REG_OPTION_NON_VOLATILE,
                                  KEY_WRITE | KEY_QUERY_VALUE, NULL,
                                  &hdrv, &disposition)) != ERROR_SUCCESS) {
  
          ERR("can't create driver %s: %u\n", debugstr_w(di.pName), lres);
          RegCloseKey(hroot);
          SetLastError(lres);
          return FALSE;
      }
      RegCloseKey(hroot);
  
      /* Verified with the Adobe PS Driver, that w2k does not use di.Version */
      RegSetValueExW(hdrv, versionW, 0, REG_DWORD, (const BYTE*) &env->driverversion,
                     sizeof(DWORD));
  
      file = get_file_part( di.pDriverPath );
      RegSetValueExW( hdrv, driverW, 0, REG_SZ, (LPBYTE)file, (strlenW( file ) + 1) * sizeof(WCHAR) );
      apd_copyfile( di.pDriverPath, file, &apd );
  
      file = get_file_part( di.pDataFile );
      RegSetValueExW( hdrv, data_fileW, 0, REG_SZ, (LPBYTE)file, (strlenW( file ) + 1) * sizeof(WCHAR) );
      apd_copyfile( di.pDataFile, file, &apd );
  
      file = get_file_part( di.pConfigFile );
      RegSetValueExW( hdrv, configuration_fileW, 0, REG_SZ, (LPBYTE)file, (strlenW( file ) + 1) * sizeof(WCHAR) );
      apd_copyfile( di.pConfigFile, file, &apd );
  
      /* settings for level 3 */
      if (di.pHelpFile)
      {
          file = get_file_part( di.pHelpFile );
          RegSetValueExW( hdrv, help_fileW, 0, REG_SZ, (LPBYTE)file, (strlenW( file ) + 1) * sizeof(WCHAR) );
          apd_copyfile( di.pHelpFile, file, &apd );
      }
      else
          RegSetValueExW( hdrv, help_fileW, 0, REG_SZ, (const BYTE*)emptyW, sizeof(emptyW) );
  
      if (di.pDependentFiles && *di.pDependentFiles)
      {
          WCHAR *reg, *reg_ptr, *in_ptr;
          reg = reg_ptr = HeapAlloc( GetProcessHeap(), 0, multi_sz_lenW( di.pDependentFiles ) );
  
          for (in_ptr = di.pDependentFiles; *in_ptr; in_ptr += strlenW( in_ptr ) + 1)
          {
              file = get_file_part( in_ptr );
              len = strlenW( file ) + 1;
              memcpy( reg_ptr, file, len * sizeof(WCHAR) );
              reg_ptr += len;
              apd_copyfile( in_ptr, file, &apd );
          }
          *reg_ptr = 0;
  
          RegSetValueExW( hdrv, dependent_filesW, 0, REG_MULTI_SZ, (LPBYTE)reg, (reg_ptr - reg + 1) * sizeof(WCHAR) );
          HeapFree( GetProcessHeap(), 0, reg );
      }
      else
          RegSetValueExW(hdrv, dependent_filesW, 0, REG_MULTI_SZ, (const BYTE*)emptyW, sizeof(emptyW));
  
      /* The language-Monitor was already copied by the caller to "%SystemRoot%\system32" */
      if (di.pMonitorName)
          RegSetValueExW(hdrv, monitorW, 0, REG_SZ, (LPBYTE) di.pMonitorName,
                         (lstrlenW(di.pMonitorName)+1)* sizeof(WCHAR));
      else
          RegSetValueExW(hdrv, monitorW, 0, REG_SZ, (const BYTE*)emptyW, sizeof(emptyW));
  
      if (di.pDefaultDataType)
          RegSetValueExW(hdrv, datatypeW, 0, REG_SZ, (LPBYTE) di.pDefaultDataType,
                         (lstrlenW(di.pDefaultDataType)+1)* sizeof(WCHAR));
      else
          RegSetValueExW(hdrv, datatypeW, 0, REG_SZ, (const BYTE*)emptyW, sizeof(emptyW));
  
      /* settings for level 4 */
      if (di.pszzPreviousNames)
          RegSetValueExW(hdrv, previous_namesW, 0, REG_MULTI_SZ, (LPBYTE) di.pszzPreviousNames,
                         multi_sz_lenW(di.pszzPreviousNames));
      else
          RegSetValueExW(hdrv, previous_namesW, 0, REG_MULTI_SZ, (const BYTE*)emptyW, sizeof(emptyW));
  
      if (level > 5) TRACE("level %u for Driver %s is incomplete\n", level, debugstr_w(di.pName));
  
      RegCloseKey(hdrv);
      hui = driver_load(env, di.pConfigFile);
      pDrvDriverEvent = (void *)GetProcAddress(hui, "DrvDriverEvent");
      if (hui && pDrvDriverEvent) {
  
          /* Support for DrvDriverEvent is optional */
          TRACE("DRIVER_EVENT_INITIALIZE for %s (%s)\n", debugstr_w(di.pName), debugstr_w(di.pConfigFile));
          /* MSDN: level for DRIVER_INFO is 1 to 3 */
          res = pDrvDriverEvent(DRIVER_EVENT_INITIALIZE, 3, (LPBYTE) &di, 0);
          TRACE("got %d from DRIVER_EVENT_INITIALIZE\n", res);
      }
      FreeLibrary(hui);
  
      TRACE("=> TRUE with %u\n", GetLastError());
      return TRUE;
  
  }
  
  /******************************************************************************
   * fpAddMonitor [exported through PRINTPROVIDOR]
   *
   * Install a Printmonitor
   *
   * PARAMS
   *  pName       [I] Servername or NULL (local Computer)
   *  Level       [I] Structure-Level (Must be 2)
   *  pMonitors   [I] PTR to MONITOR_INFO_2
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE
   *
   * NOTES
   *  All Files for the Monitor must already be copied to %winsysdir% ("%SystemRoot%\system32")
   *
   */
  static BOOL WINAPI fpAddMonitor(LPWSTR pName, DWORD Level, LPBYTE pMonitors)
  {
      const printenv_t * env;
      monitor_t * pm = NULL;
      LPMONITOR_INFO_2W mi2w;
      HKEY    hroot = NULL;
      HKEY    hentry = NULL;
      DWORD   disposition;
      BOOL    res = FALSE;
  
      mi2w = (LPMONITOR_INFO_2W) pMonitors;
      TRACE("(%s, %d, %p): %s %s %s\n", debugstr_w(pName), Level, pMonitors,
              debugstr_w(mi2w ? mi2w->pName : NULL),
              debugstr_w(mi2w ? mi2w->pEnvironment : NULL),
              debugstr_w(mi2w ? mi2w->pDLLName : NULL));
  
      if (copy_servername_from_name(pName, NULL)) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_ACCESS_DENIED);
          return FALSE;
      }
  
      if (!mi2w->pName || (! mi2w->pName[0])) {
          WARN("pName not valid : %s\n", debugstr_w(mi2w->pName));
          SetLastError(ERROR_INVALID_PARAMETER);
          return FALSE;
      }
  
      env = validate_envW(mi2w->pEnvironment);
      if (!env)
          return FALSE;   /* ERROR_INVALID_ENVIRONMENT */
  
      if (!mi2w->pDLLName || (! mi2w->pDLLName[0])) {
          WARN("pDLLName not valid : %s\n", debugstr_w(mi2w->pDLLName));
          SetLastError(ERROR_INVALID_PARAMETER);
          return FALSE;
      }
  
      /* Load and initialize the monitor. SetLastError() is called on failure */
      if ((pm = monitor_load(mi2w->pName, mi2w->pDLLName)) == NULL) {
          return FALSE;
      }
      monitor_unload(pm);
  
      SetLastError(ERROR_SUCCESS); /* Monitor installer depends on this */
  
      if (RegCreateKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) != ERROR_SUCCESS) {
          ERR("unable to create key %s\n", debugstr_w(monitorsW));
          return FALSE;
      }
  
      if (RegCreateKeyExW(hroot, mi2w->pName, 0, NULL, REG_OPTION_NON_VOLATILE,
                          KEY_WRITE | KEY_QUERY_VALUE, NULL, &hentry,
                          &disposition) == ERROR_SUCCESS) {
  
          /* Some installers set options for the port before calling AddMonitor.
             We query the "Driver" entry to verify that the monitor is installed,
             before we return an error.
             When a user installs two print monitors at the same time with the
             same name, a race condition is possible but silently ignored. */
  
          DWORD   namesize = 0;
  
          if ((disposition == REG_OPENED_EXISTING_KEY) &&
              (RegQueryValueExW(hentry, driverW, NULL, NULL, NULL,
                                &namesize) == ERROR_SUCCESS)) {
              TRACE("monitor %s already exists\n", debugstr_w(mi2w->pName));
              /* 9x use ERROR_ALREADY_EXISTS */
              SetLastError(ERROR_PRINT_MONITOR_ALREADY_INSTALLED);
          }
          else
          {
              INT len;
              len = (lstrlenW(mi2w->pDLLName) +1) * sizeof(WCHAR);
              res = (RegSetValueExW(hentry, driverW, 0, REG_SZ,
                      (LPBYTE) mi2w->pDLLName, len) == ERROR_SUCCESS);
          }
          RegCloseKey(hentry);
      }
  
      RegCloseKey(hroot);
      return (res);
  }
  
  /******************************************************************************
   * fpAddPort [exported through PRINTPROVIDOR]
   *
   * Add a Port for a specific Monitor
   *
   * PARAMS
   *  pName        [I] Servername or NULL (local Computer)
   *  hWnd         [I] Handle to parent Window for the Dialog-Box
   *  pMonitorName [I] Name of the Monitor that manage the Port
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE
   *
   */
  static BOOL WINAPI fpAddPort(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)
  {
      monitor_t * pm;
      monitor_t * pui;
      LONG        lres;
      DWORD       res;
  
      TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pMonitorName));
  
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_INVALID_PARAMETER);
          return FALSE;
      }
  
      /* an empty Monitorname is Invalid */
      if (!pMonitorName[0]) {
          SetLastError(ERROR_NOT_SUPPORTED);
          return FALSE;
      }
  
      pm = monitor_load(pMonitorName, NULL);
      if (pm && pm->monitor && pm->monitor->pfnAddPort) {
          res = pm->monitor->pfnAddPort(pName, hWnd, pMonitorName);
          TRACE("got %d with %u (%s)\n", res, GetLastError(), debugstr_w(pm->dllname));
      }
      else
      {
          pui = monitor_loadui(pm);
          if (pui && pui->monitorUI && pui->monitorUI->pfnAddPortUI) {
              res = pui->monitorUI->pfnAddPortUI(pName, hWnd, pMonitorName, NULL);
              TRACE("got %d with %u (%s)\n", res, GetLastError(), debugstr_w(pui->dllname));
          }
          else
          {
              FIXME("not implemented for %s (monitor %p: %s / monitorui %p: %s)\n",
                      debugstr_w(pMonitorName), pm, debugstr_w(pm ? pm->dllname : NULL),
                      pui, debugstr_w(pui ? pui->dllname : NULL));
  
              SetLastError(ERROR_NOT_SUPPORTED);
              res = FALSE;
          }
          monitor_unload(pui);
      }
      monitor_unload(pm);
  
      TRACE("returning %d with %u\n", res, GetLastError());
      return res;
  }
  
  /******************************************************************************
   * fpAddPortEx [exported through PRINTPROVIDOR]
   *
   * Add a Port for a specific Monitor, without presenting a user interface
   *
   * PARAMS
   *  pName         [I] Servername or NULL (local Computer)
   *  level         [I] Structure-Level (1 or 2) for pBuffer
   *  pBuffer       [I] PTR to: PORT_INFO_1 or PORT_INFO_2
   *  pMonitorName  [I] Name of the Monitor that manage the Port
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE
   *
   */
  static BOOL WINAPI fpAddPortEx(LPWSTR pName, DWORD level, LPBYTE pBuffer, LPWSTR pMonitorName)
  {
      PORT_INFO_2W * pi2;
      monitor_t * pm;
      DWORD lres;
      DWORD res;
  
      pi2 = (PORT_INFO_2W *) pBuffer;
  
      TRACE("(%s, %d, %p, %s): %s %s %s\n", debugstr_w(pName), level, pBuffer,
              debugstr_w(pMonitorName), debugstr_w(pi2 ? pi2->pPortName : NULL),
              debugstr_w(((level > 1) && pi2) ? pi2->pMonitorName : NULL),
              debugstr_w(((level > 1) && pi2) ? pi2->pDescription : NULL));
  
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_INVALID_PARAMETER);
          return FALSE;
      }
  
      if ((level < 1) || (level > 2)) {
          SetLastError(ERROR_INVALID_LEVEL);
          return FALSE;
      }
  
      if ((!pi2) || (!pMonitorName) || (!pMonitorName[0])) {
          SetLastError(ERROR_INVALID_PARAMETER);
          return FALSE;
      }
  
      /* load the Monitor */
      pm = monitor_load(pMonitorName, NULL);
      if (pm && pm->monitor && pm->monitor->pfnAddPortEx) {
          res = pm->monitor->pfnAddPortEx(pName, level, pBuffer, pMonitorName);
          TRACE("got %d with %u (%s)\n", res, GetLastError(), debugstr_w(pm->dllname));
      }
      else
      {
          FIXME("not implemented for %s (monitor %p: %s)\n",
              debugstr_w(pMonitorName), pm, pm ? debugstr_w(pm->dllname) : "(null)");
              SetLastError(ERROR_INVALID_PARAMETER);
              res = FALSE;
      }
      monitor_unload(pm);
      return res;
  }
  
  /******************************************************************************
   * fpAddPrinterDriverEx [exported through PRINTPROVIDOR]
   *
   * Install a Printer Driver with the Option to upgrade / downgrade the Files
   *
   * PARAMS
   *  pName           [I] Servername or NULL (local Computer)
   *  level           [I] Level for the supplied DRIVER_INFO_*W struct
   *  pDriverInfo     [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
   *  dwFileCopyFlags [I] How to Copy / Upgrade / Downgrade the needed Files
   *
   * RESULTS
   *  Success: TRUE
   *  Failure: FALSE
   *
   */
  static BOOL WINAPI fpAddPrinterDriverEx(LPWSTR pName, DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
  {
      LONG lres;
  
      TRACE("(%s, %d, %p, 0x%x)\n", debugstr_w(pName), level, pDriverInfo, dwFileCopyFlags);
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_ACCESS_DENIED);
          return FALSE;
      }
  
      if ((dwFileCopyFlags & ~APD_COPY_FROM_DIRECTORY) != APD_COPY_ALL_FILES) {
          TRACE("Flags 0x%x ignored (using APD_COPY_ALL_FILES)\n", dwFileCopyFlags & ~APD_COPY_FROM_DIRECTORY);
      }
  
      return myAddPrinterDriverEx(level, pDriverInfo, dwFileCopyFlags, TRUE);
  }
  
  /******************************************************************************
   * fpClosePrinter [exported through PRINTPROVIDOR]
   *
   * Close a printer handle and free associated resources
   *
   * PARAMS
   *  hPrinter [I] Printerhandle to close
   *
   * RESULTS
   *  Success: TRUE
   *  Failure: FALSE
   *
   */
  static BOOL WINAPI fpClosePrinter(HANDLE hPrinter)
  {
      printer_t *printer = (printer_t *) hPrinter;
  
      TRACE("(%p)\n", hPrinter);
  
      if (printer) {
          printer_free(printer);
          return TRUE;
      }
      return FALSE;
  }
  
  /******************************************************************************
   * fpConfigurePort [exported through PRINTPROVIDOR]
   *
   * Display the Configuration-Dialog for a specific Port
   *
   * PARAMS
   *  pName     [I] Servername or NULL (local Computer)
   *  hWnd      [I] Handle to parent Window for the Dialog-Box
   *  pPortName [I] Name of the Port, that should be configured
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE
   *
   */
  static BOOL WINAPI fpConfigurePort(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
  {
      monitor_t * pm;
      monitor_t * pui;
      LONG        lres;
      DWORD       res;
  
      TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
  
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_INVALID_NAME);
          return FALSE;
      }
  
      /* an empty Portname is Invalid, but can popup a Dialog */
      if (!pPortName[0]) {
          SetLastError(ERROR_NOT_SUPPORTED);
          return FALSE;
      }
  
      pm = monitor_load_by_port(pPortName);
      if (pm && pm->monitor && pm->monitor->pfnConfigurePort) {
          TRACE("use %s for %s (monitor %p: %s)\n", debugstr_w(pm->name),
                  debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
          res = pm->monitor->pfnConfigurePort(pName, hWnd, pPortName);
          TRACE("got %d with %u\n", res, GetLastError());
      }
      else
      {
          pui = monitor_loadui(pm);
          if (pui && pui->monitorUI && pui->monitorUI->pfnConfigurePortUI) {
              TRACE("use %s for %s (monitorui %p: %s)\n", debugstr_w(pui->name),
                          debugstr_w(pPortName), pui, debugstr_w(pui->dllname));
              res = pui->monitorUI->pfnConfigurePortUI(pName, hWnd, pPortName);
              TRACE("got %d with %u\n", res, GetLastError());
          }
          else
          {
              FIXME("not implemented for %s (monitor %p: %s / monitorui %p: %s)\n",
                      debugstr_w(pPortName), pm, debugstr_w(pm ? pm->dllname : NULL),
                      pui, debugstr_w(pui ? pui->dllname : NULL));
  
              SetLastError(ERROR_NOT_SUPPORTED);
              res = FALSE;
          }
          monitor_unload(pui);
      }
      monitor_unload(pm);
  
      TRACE("returning %d with %u\n", res, GetLastError());
      return res;
  }
  
  /******************************************************************
   * fpDeleteMonitor [exported through PRINTPROVIDOR]
   *
   * Delete a specific Printmonitor from a Printing-Environment
   *
   * PARAMS
   *  pName        [I] Servername or NULL (local Computer)
   *  pEnvironment [I] Printing-Environment of the Monitor or NULL (Default)
   *  pMonitorName [I] Name of the Monitor, that should be deleted
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE
   *
   * NOTES
   *  pEnvironment is ignored in Windows for the local Computer.
   *
   */
  
  static BOOL WINAPI fpDeleteMonitor(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pMonitorName)
  {
      HKEY    hroot = NULL;
      LONG    lres;
  
      TRACE("(%s, %s, %s)\n",debugstr_w(pName),debugstr_w(pEnvironment),
             debugstr_w(pMonitorName));
  
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_INVALID_NAME);
          return FALSE;
      }
  
      /*  pEnvironment is ignored in Windows for the local Computer */
      if (!pMonitorName || !pMonitorName[0]) {
          TRACE("pMonitorName %s is invalid\n", debugstr_w(pMonitorName));
          SetLastError(ERROR_INVALID_PARAMETER);
          return FALSE;
      }
  
      if(RegCreateKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) != ERROR_SUCCESS) {
          ERR("unable to create key %s\n", debugstr_w(monitorsW));
          return FALSE;
      }
  
      if(RegDeleteTreeW(hroot, pMonitorName) == ERROR_SUCCESS) {
          TRACE("%s deleted\n", debugstr_w(pMonitorName));
          RegCloseKey(hroot);
          return TRUE;
      }
  
      TRACE("%s does not exist\n", debugstr_w(pMonitorName));
      RegCloseKey(hroot);
  
      /* NT: ERROR_UNKNOWN_PRINT_MONITOR (3000), 9x: ERROR_INVALID_PARAMETER (87) */
      SetLastError(ERROR_UNKNOWN_PRINT_MONITOR);
      return FALSE;
  }
  
  /*****************************************************************************
   * fpDeletePort [exported through PRINTPROVIDOR]
   *
   * Delete a specific Port
   *
   * PARAMS
   *  pName     [I] Servername or NULL (local Computer)
   *  hWnd      [I] Handle to parent Window for the Dialog-Box
   *  pPortName [I] Name of the Port, that should be deleted
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE
   *
   */
  static BOOL WINAPI fpDeletePort(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
  {
      monitor_t * pm;
      monitor_t * pui;
      LONG        lres;
      DWORD       res;
  
      TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
  
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_INVALID_NAME);
          return FALSE;
      }
  
      /* an empty Portname is Invalid */
      if (!pPortName[0]) {
          SetLastError(ERROR_NOT_SUPPORTED);
          return FALSE;
      }
  
      pm = monitor_load_by_port(pPortName);
      if (pm && pm->monitor && pm->monitor->pfnDeletePort) {
          TRACE("use %s for %s (monitor %p: %s)\n", debugstr_w(pm->name),
                  debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
          res = pm->monitor->pfnDeletePort(pName, hWnd, pPortName);
          TRACE("got %d with %u\n", res, GetLastError());
      }
      else
      {
          pui = monitor_loadui(pm);
          if (pui && pui->monitorUI && pui->monitorUI->pfnDeletePortUI) {
              TRACE("use %s for %s (monitorui %p: %s)\n", debugstr_w(pui->name),
                          debugstr_w(pPortName), pui, debugstr_w(pui->dllname));
              res = pui->monitorUI->pfnDeletePortUI(pName, hWnd, pPortName);
              TRACE("got %d with %u\n", res, GetLastError());
          }
          else
          {
              FIXME("not implemented for %s (monitor %p: %s / monitorui %p: %s)\n",
                      debugstr_w(pPortName), pm, debugstr_w(pm ? pm->dllname : NULL),
                      pui, debugstr_w(pui ? pui->dllname : NULL));
  
              SetLastError(ERROR_NOT_SUPPORTED);
              res = FALSE;
          }
          monitor_unload(pui);
      }
      monitor_unload(pm);
  
      TRACE("returning %d with %u\n", res, GetLastError());
      return res;
  }
  
  /*****************************************************************************
   * fpEnumMonitors [exported through PRINTPROVIDOR]
   *
   * Enumerate available Port-Monitors
   *
   * PARAMS
   *  pName      [I] Servername or NULL (local Computer)
   *  Level      [I] Structure-Level (1:Win9x+NT or 2:NT only)
   *  pMonitors  [O] PTR to Buffer that receives the Result
   *  cbBuf      [I] Size of Buffer at pMonitors
   *  pcbNeeded  [O] PTR to DWORD that receives the size in Bytes used / required for pMonitors
   *  pcReturned [O] PTR to DWORD that receives the number of Monitors in pMonitors
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE and in pcbNeeded the Bytes required for pMonitors, if cbBuf is too small
   *
   * NOTES
   *  Windows reads the Registry once and cache the Results.
   *
   */
  static BOOL WINAPI fpEnumMonitors(LPWSTR pName, DWORD Level, LPBYTE pMonitors, DWORD cbBuf,
                                    LPDWORD pcbNeeded, LPDWORD pcReturned)
  {
      DWORD   numentries = 0;
      DWORD   needed = 0;
      LONG    lres;
      BOOL    res = FALSE;
  
      TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pMonitors,
            cbBuf, pcbNeeded, pcReturned);
  
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_INVALID_NAME);
          goto em_cleanup;
      }
  
      if (!Level || (Level > 2)) {
          WARN("level (%d) is ignored in win9x\n", Level);
          SetLastError(ERROR_INVALID_LEVEL);
          return FALSE;
      }
  
      /* Scan all Monitor-Keys */
      numentries = 0;
      needed = get_local_monitors(Level, NULL, 0, &numentries);
  
      /* we calculated the needed buffersize. now do more error-checks */
      if (cbBuf < needed) {
          SetLastError(ERROR_INSUFFICIENT_BUFFER);
          goto em_cleanup;
      }
  
      /* fill the Buffer with the Monitor-Keys */
      needed = get_local_monitors(Level, pMonitors, cbBuf, &numentries);
      res = TRUE;
  
  em_cleanup:
      if (pcbNeeded)  *pcbNeeded = needed;
      if (pcReturned) *pcReturned = numentries;
  
      TRACE("returning %d with %d (%d byte for %d entries)\n",
              res, GetLastError(), needed, numentries);
  
      return (res);
  }
  
  /******************************************************************************
   * fpEnumPorts [exported through PRINTPROVIDOR]
   *
   * Enumerate available Ports
   *
   * PARAMS
   *  pName      [I] Servername or NULL (local Computer)
   *  Level      [I] Structure-Level (1 or 2)
   *  pPorts     [O] PTR to Buffer that receives the Result
   *  cbBuf      [I] Size of Buffer at pPorts
   *  pcbNeeded  [O] PTR to DWORD that receives the size in Bytes used / required for pPorts
   *  pcReturned [O] PTR to DWORD that receives the number of Ports in pPorts
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE and in pcbNeeded the Bytes required for pPorts, if cbBuf is too small
   *
   */
  static BOOL WINAPI fpEnumPorts(LPWSTR pName, DWORD Level, LPBYTE pPorts, DWORD cbBuf,
                                 LPDWORD pcbNeeded, LPDWORD pcReturned)
  {
      DWORD   needed = 0;
      DWORD   numentries = 0;
      LONG    lres;
      BOOL    res = FALSE;
  
      TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pPorts,
            cbBuf, pcbNeeded, pcReturned);
  
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_INVALID_NAME);
          goto emP_cleanup;
      }
  
      if (!Level || (Level > 2)) {
          SetLastError(ERROR_INVALID_LEVEL);
          goto emP_cleanup;
      }
  
      if (!pcbNeeded || (!pPorts && (cbBuf > 0))) {
          SetLastError(RPC_X_NULL_REF_POINTER);
          goto emP_cleanup;
      }
  
      EnterCriticalSection(&monitor_handles_cs);
      monitor_loadall();
  
      /* Scan all local Ports */
      numentries = 0;
      needed = get_ports_from_all_monitors(Level, NULL, 0, &numentries);
  
      /* we calculated the needed buffersize. now do the error-checks */
      if (cbBuf < needed) {
          monitor_unloadall();
          SetLastError(ERROR_INSUFFICIENT_BUFFER);
          goto emP_cleanup_cs;
      }
      else if (!pPorts || !pcReturned) {
          monitor_unloadall();
          SetLastError(RPC_X_NULL_REF_POINTER);
          goto emP_cleanup_cs;
      }
  
      /* Fill the Buffer */
      needed = get_ports_from_all_monitors(Level, pPorts, cbBuf, &numentries);
      res = TRUE;
      monitor_unloadall();
  
  emP_cleanup_cs:
      LeaveCriticalSection(&monitor_handles_cs);
  
  emP_cleanup:
      if (pcbNeeded)  *pcbNeeded = needed;
      if (pcReturned) *pcReturned = (res) ? numentries : 0;
  
      TRACE("returning %d with %d (%d byte for %d of %d entries)\n",
            (res), GetLastError(), needed, (res) ? numentries : 0, numentries);
  
      return (res);
  }
  
  /*****************************************************************************
   * fpEnumPrintProcessors [exported through PRINTPROVIDOR]
   *
   * Enumerate available Print Processors
   *
   * PARAMS
   *  pName        [I] Servername or NULL (local Computer)
   *  pEnvironment [I] Printing-Environment or NULL (Default)
   *  Level        [I] Structure-Level (Only 1 is allowed)
   *  pPPInfo      [O] PTR to Buffer that receives the Result
   *  cbBuf        [I] Size of Buffer at pMonitors
   *  pcbNeeded    [O] PTR to DWORD that receives the size in Bytes used / required for pPPInfo
   *  pcReturned   [O] PTR to DWORD that receives the number of Print Processors in pPPInfo
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE and in pcbNeeded the Bytes required for pPPInfo, if cbBuf is too small
   *
   */
  static BOOL WINAPI fpEnumPrintProcessors(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
                              LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
  {
      const printenv_t * env;
      LPWSTR  regpathW = NULL;
      DWORD   numentries = 0;
      DWORD   needed = 0;
      LONG    lres;
      BOOL    res = FALSE;
  
      TRACE("(%s, %s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), debugstr_w(pEnvironment),
                                  Level, pPPInfo, cbBuf, pcbNeeded, pcReturned);
  
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(ERROR_INVALID_NAME);
          goto epp_cleanup;
      }
  
      if (Level != 1) {
          SetLastError(ERROR_INVALID_LEVEL);
          goto epp_cleanup;
      }
  
      env = validate_envW(pEnvironment);
      if (!env)
          goto epp_cleanup;   /* ERROR_INVALID_ENVIRONMENT */
  
      regpathW = heap_alloc(sizeof(fmt_printprocessorsW) +
                              (lstrlenW(env->envname) * sizeof(WCHAR)));
  
      if (!regpathW)
          goto epp_cleanup;
  
      wsprintfW(regpathW, fmt_printprocessorsW, env->envname);
  
      /* Scan all Printprocessor-Keys */
      numentries = 0;
      needed = get_local_printprocessors(regpathW, NULL, 0, &numentries);
  
      /* we calculated the needed buffersize. now do more error-checks */
      if (cbBuf < needed) {
          SetLastError(ERROR_INSUFFICIENT_BUFFER);
          goto epp_cleanup;
      }
  
      /* fill the Buffer with the Printprocessor Infos */
      needed = get_local_printprocessors(regpathW, pPPInfo, cbBuf, &numentries);
      res = TRUE;
  
  epp_cleanup:
      heap_free(regpathW);
      if (pcbNeeded)  *pcbNeeded = needed;
      if (pcReturned) *pcReturned = numentries;
  
      TRACE("returning %d with %d (%d byte for %d entries)\n",
              res, GetLastError(), needed, numentries);
  
      return (res);
  }
  
  /******************************************************************************
   * fpGetPrintProcessorDirectory [exported through PRINTPROVIDOR]
   *
   * Return the PATH for the Print-Processors
   *
   * PARAMS
   *  pName        [I] Servername or NULL (this computer)
   *  pEnvironment [I] Printing-Environment or NULL (Default)
   *  level        [I] Structure-Level (must be 1)
   *  pPPInfo      [O] PTR to Buffer that receives the Result
   *  cbBuf        [I] Size of Buffer at pPPInfo
   *  pcbNeeded    [O] PTR to DWORD that receives the size in Bytes used / required for pPPInfo
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE and in pcbNeeded the Bytes required for pPPInfo, if cbBuf is too small
   *
   *  Native Values returned in pPPInfo on Success for this computer:
   *| NT(Windows x64):    "%winsysdir%\\spool\\PRTPROCS\\x64"
   *| NT(Windows NT x86): "%winsysdir%\\spool\\PRTPROCS\\w32x86"
   *| NT(Windows 4.0):    "%winsysdir%\\spool\\PRTPROCS\\win40"
   *
   *  "%winsysdir%" is the Value from GetSystemDirectoryW()
   *
   */
  static BOOL WINAPI fpGetPrintProcessorDirectory(LPWSTR pName, LPWSTR pEnvironment, DWORD level,
                                                  LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded)
  {
      const printenv_t * env;
      DWORD needed;
      LONG  lres;
  
      TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName), debugstr_w(pEnvironment),
                                          level, pPPInfo, cbBuf, pcbNeeded);
  
      *pcbNeeded = 0;
      lres = copy_servername_from_name(pName, NULL);
      if (lres) {
          FIXME("server %s not supported\n", debugstr_w(pName));
          SetLastError(RPC_S_SERVER_UNAVAILABLE);
          return FALSE;
      }
  
      env = validate_envW(pEnvironment);
      if (!env)
          return FALSE;   /* ERROR_INVALID_ENVIRONMENT */
  
      /* GetSystemDirectoryW returns number of WCHAR including the '\0' */
      needed = GetSystemDirectoryW(NULL, 0);
      /* add the Size for the Subdirectories */
      needed += lstrlenW(spoolprtprocsW);
      needed += lstrlenW(env->subdir);
      needed *= sizeof(WCHAR);  /* return-value is size in Bytes */
  
      *pcbNeeded = needed;
  
      if (needed > cbBuf) {
          SetLastError(ERROR_INSUFFICIENT_BUFFER);
          return FALSE;
      }
  
      GetSystemDirectoryW((LPWSTR) pPPInfo, cbBuf/sizeof(WCHAR));
      /* add the Subdirectories */
      lstrcatW((LPWSTR) pPPInfo, spoolprtprocsW);
      lstrcatW((LPWSTR) pPPInfo, env->subdir);
      TRACE("==> %s\n", debugstr_w((LPWSTR) pPPInfo));
      return TRUE;
  }
  
  /******************************************************************************
   * fpOpenPrinter [exported through PRINTPROVIDOR]
   *
   * Open a Printer / Printserver or a Printer-Object
   *
   * PARAMS
   *  lpPrinterName [I] Name of Printserver, Printer, or Printer-Object
   *  pPrinter      [O] The resulting Handle is stored here
   *  pDefaults     [I] PTR to Default Printer Settings or NULL
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE
   *
   * NOTES
   *  lpPrinterName is one of:
   *|  Printserver (NT only): "Servername" or NULL for the local Printserver
   *|  Printer: "PrinterName"
   *|  Printer-Object: "PrinterName,Job xxx"
   *|  XcvMonitor: "Servername,XcvMonitor MonitorName"
   *|  XcvPort: "Servername,XcvPort PortName"
   *
   *
   */
  static BOOL WINAPI fpOpenPrinter(LPWSTR lpPrinterName, HANDLE *pPrinter,
                                   LPPRINTER_DEFAULTSW pDefaults)
  {
  
      TRACE("(%s, %p, %p)\n", debugstr_w(lpPrinterName), pPrinter, pDefaults);
  
      *pPrinter = printer_alloc_handle(lpPrinterName, pDefaults);
  
      return (*pPrinter != 0);
  }
  
  /******************************************************************************
   * fpXcvData [exported through PRINTPROVIDOR]
   *
   * Execute commands in the Printmonitor DLL
   *
   * PARAMS
   *  hXcv            [i] Handle from fpOpenPrinter (with XcvMonitor or XcvPort)
   *  pszDataName     [i] Name of the command to execute
   *  pInputData      [i] Buffer for extra Input Data (needed only for some commands)
   *  cbInputData     [i] Size in Bytes of Buffer at pInputData
   *  pOutputData     [o] Buffer to receive additional Data (needed only for some commands)
   *  cbOutputData    [i] Size in Bytes of Buffer at pOutputData
   *  pcbOutputNeeded [o] PTR to receive the minimal Size in Bytes of the Buffer at pOutputData
   *  pdwStatus       [o] PTR to receive the win32 error code from the Printmonitor DLL
   *
   * RETURNS
   *  Success: TRUE
   *  Failure: FALSE
   *
   * NOTES
   *  Returning "TRUE" does mean, that the Printmonitor DLL was called successful.
   *  The execution of the command can still fail (check pdwStatus for ERROR_SUCCESS).
   *
   *  Minimal List of commands, that a Printmonitor DLL should support:
   *
   *| "MonitorUI" : Return the Name of the Userinterface-DLL as WSTR in pOutputData
   *| "AddPort"   : Add a Port
   *| "DeletePort": Delete a Port
   *
   *  Many Printmonitors support additional commands. Examples for localspl.dll:
   *  "GetDefaultCommConfig", "SetDefaultCommConfig",
   *  "GetTransmissionRetryTimeout", "ConfigureLPTPortCommandOK"
   *
   */
  static BOOL WINAPI fpXcvData(HANDLE hXcv, LPCWSTR pszDataName, PBYTE pInputData,
                      DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData,
                      PDWORD pcbOutputNeeded, PDWORD pdwStatus)
  {
      printer_t *printer = (printer_t * ) hXcv;
  
      TRACE("(%p, %s, %p, %d, %p, %d, %p, %p)\n", hXcv, debugstr_w(pszDataName),
            pInputData, cbInputData, pOutputData,
            cbOutputData, pcbOutputNeeded, pdwStatus);
  
      if (!printer || (!printer->hXcv)) {
          SetLastError(ERROR_INVALID_HANDLE);
          return FALSE;
      }
  
      if (!pcbOutputNeeded) {
          SetLastError(ERROR_INVALID_PARAMETER);
          return FALSE;
      }
  
      if (!pszDataName || !pdwStatus || (!pOutputData && (cbOutputData > 0))) {
          SetLastError(RPC_X_NULL_REF_POINTER);
          return FALSE;
      }
  
      *pcbOutputNeeded = 0;
  
      *pdwStatus = printer->pm->monitor->pfnXcvDataPort(printer->hXcv, pszDataName,
              pInputData, cbInputData, pOutputData, cbOutputData, pcbOutputNeeded);
  
      return TRUE;
  }
  
  /*****************************************************
   *  setup_provider [internal]
   */
  void setup_provider(void)
  {
      static const PRINTPROVIDOR backend = {
          fpOpenPrinter,
          NULL,   /* fpSetJob */
          NULL,   /* fpGetJob */
          NULL,   /* fpEnumJobs */
          NULL,   /* fpAddPrinter */
          NULL,   /* fpDeletePrinter */
          NULL,   /* fpSetPrinter */
          NULL,   /* fpGetPrinter */
          NULL,   /* fpEnumPrinters */
          NULL,   /* fpAddPrinterDriver */
          NULL,   /* fpEnumPrinterDrivers */
          NULL,   /* fpGetPrinterDriver */
          fpGetPrinterDriverDirectory,
          NULL,   /* fpDeletePrinterDriver */
          NULL,   /* fpAddPrintProcessor */
          fpEnumPrintProcessors,
          fpGetPrintProcessorDirectory,
          NULL,   /* fpDeletePrintProcessor */
          NULL,   /* fpEnumPrintProcessorDatatypes */
          NULL,   /* fpStartDocPrinter */
          NULL,   /* fpStartPagePrinter */
          NULL,   /* fpWritePrinter */
          NULL,   /* fpEndPagePrinter */
          NULL,   /* fpAbortPrinter */
          NULL,   /* fpReadPrinter */
          NULL,   /* fpEndDocPrinter */
          NULL,   /* fpAddJob */
          NULL,   /* fpScheduleJob */
          NULL,   /* fpGetPrinterData */
          NULL,   /* fpSetPrinterData */
          NULL,   /* fpWaitForPrinterChange */
          fpClosePrinter,
          NULL,   /* fpAddForm */
          NULL,   /* fpDeleteForm */
          NULL,   /* fpGetForm */
          NULL,   /* fpSetForm */
          NULL,   /* fpEnumForms */
          fpEnumMonitors,
          fpEnumPorts,
          fpAddPort,
          fpConfigurePort,
          fpDeletePort,
          NULL,   /* fpCreatePrinterIC */
          NULL,   /* fpPlayGdiScriptOnPrinterIC */
          NULL,   /* fpDeletePrinterIC */
          NULL,   /* fpAddPrinterConnection */
          NULL,   /* fpDeletePrinterConnection */
          NULL,   /* fpPrinterMessageBox */
          fpAddMonitor,
          fpDeleteMonitor,
          NULL,   /* fpResetPrinter */
          NULL,   /* fpGetPrinterDriverEx */
          NULL,   /* fpFindFirstPrinterChangeNotification */
          NULL,   /* fpFindClosePrinterChangeNotification */
          fpAddPortEx,
          NULL,   /* fpShutDown */
          NULL,   /* fpRefreshPrinterChangeNotification */
          NULL,   /* fpOpenPrinterEx */
          NULL,   /* fpAddPrinterEx */
          NULL,   /* fpSetPort */
          NULL,   /* fpEnumPrinterData */
          NULL,   /* fpDeletePrinterData */
          NULL,   /* fpClusterSplOpen */
          NULL,   /* fpClusterSplClose */
          NULL,   /* fpClusterSplIsAlive */
          NULL,   /* fpSetPrinterDataEx */
          NULL,   /* fpGetPrinterDataEx */
          NULL,   /* fpEnumPrinterDataEx */
          NULL,   /* fpEnumPrinterKey */
          NULL,   /* fpDeletePrinterDataEx */
          NULL,   /* fpDeletePrinterKey */
          NULL,   /* fpSeekPrinter */
          NULL,   /* fpDeletePrinterDriverEx */
          NULL,   /* fpAddPerMachineConnection */
          NULL,   /* fpDeletePerMachineConnection */
          NULL,   /* fpEnumPerMachineConnections */
          fpXcvData,
          fpAddPrinterDriverEx,
          NULL,   /* fpSplReadPrinter */
          NULL,   /* fpDriverUnloadComplete */
          NULL,   /* fpGetSpoolFileInfo */
          NULL,   /* fpCommitSpoolData */
          NULL,   /* fpCloseSpoolFileHandle */
          NULL,   /* fpFlushPrinter */
          NULL,   /* fpSendRecvBidiData */
          NULL    /* fpAddDriverCatalog */
      };
      pprovider = &backend;
  
  }
  
  /*****************************************************
   * InitializePrintProvidor     (localspl.@)
   *
   * Initialize the Printprovider
   *
   * PARAMS
   *  pPrintProvidor    [I] Buffer to fill with a struct PRINTPROVIDOR
   *  cbPrintProvidor   [I] Size of Buffer in Bytes
   *  pFullRegistryPath [I] Registry-Path for the Printprovidor
   *
   * RETURNS
   *  Success: TRUE and pPrintProvidor filled
   *  Failure: FALSE
   *
   * NOTES
   *  The RegistryPath should be:
   *  "System\CurrentControlSet\Control\Print\Providers\<providername>",
   *  but this Parameter is ignored in "localspl.dll".
   *
   */
  
  BOOL WINAPI InitializePrintProvidor(LPPRINTPROVIDOR pPrintProvidor,
                                      DWORD cbPrintProvidor, LPWSTR pFullRegistryPath)
  {
  
      TRACE("(%p, %u, %s)\n", pPrintProvidor, cbPrintProvidor, debugstr_w(pFullRegistryPath));
      memcpy(pPrintProvidor, pprovider,
            (cbPrintProvidor < sizeof(PRINTPROVIDOR)) ? cbPrintProvidor : sizeof(PRINTPROVIDOR));
  
      return TRUE;
  }
  