git.oblomov.eu Git - wine/blob - dlls/localspl/provider.c

   1 /*
   2  * Implementation of the Local Printprovider
   3  *
   4  * Copyright 2006-2009 Detlef Riekenberg
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winreg.h"
  30 #include "winspool.h"
  31 #include "winuser.h"
  32 #include "ddk/winddiui.h"
  33 #include "ddk/winsplp.h"
  34
  35 #include "wine/list.h"
  36 #include "wine/debug.h"
  37 #include "wine/unicode.h"
  38 #include "localspl_private.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(localspl);
  41
  42 /* ############################### */
  43
  44 static CRITICAL_SECTION monitor_handles_cs;
  45 static CRITICAL_SECTION_DEBUG monitor_handles_cs_debug =
  46 {
  47     0, 0, &monitor_handles_cs,
  48     { &monitor_handles_cs_debug.ProcessLocksList, &monitor_handles_cs_debug.ProcessLocksList },
  49       0, 0, { (DWORD_PTR)(__FILE__ ": monitor_handles_cs") }
  50 };
  51 static CRITICAL_SECTION monitor_handles_cs = { &monitor_handles_cs_debug, -1, 0, 0, 0, 0 };
  52
  53 /* ############################### */
  54
  55 typedef struct {
  56     WCHAR   src[MAX_PATH+MAX_PATH];
  57     WCHAR   dst[MAX_PATH+MAX_PATH];
  58     DWORD   srclen;
  59     DWORD   dstlen;
  60     DWORD   copyflags;
  61     BOOL    lazy;
  62 } apd_data_t;
  63
  64 typedef struct {
  65     struct list     entry;
  66     LPWSTR          name;
  67     LPWSTR          dllname;
  68     PMONITORUI      monitorUI;
  69     LPMONITOR       monitor;
  70     HMODULE         hdll;
  71     DWORD           refcount;
  72     DWORD           dwMonitorSize;
  73 } monitor_t;
  74
  75 typedef struct {
  76     LPCWSTR  envname;
  77     LPCWSTR  subdir;
  78     DWORD    driverversion;
  79     LPCWSTR  versionregpath;
  80     LPCWSTR  versionsubdir;
  81 } printenv_t;
  82
  83 typedef struct {
  84     LPWSTR name;
  85     LPWSTR printername;
  86     monitor_t * pm;
  87     HANDLE hXcv;
  88 } printer_t;
  89
  90 /* ############################### */
  91
  92 static struct list monitor_handles = LIST_INIT( monitor_handles );
  93 static monitor_t * pm_localport;
  94
  95 static const PRINTPROVIDOR * pprovider = NULL;
  96
  97 static const WCHAR backslashW[] = {'\\',0};
  98 static const WCHAR bs_ports_bsW[] = {'\\','P','o','r','t','s','\\',0};
  99 static const WCHAR configuration_fileW[] = {'C','o','n','f','i','g','u','r','a','t','i','o','n',' ','F','i','l','e',0};
 100 static const WCHAR datatypeW[] = {'D','a','t','a','t','y','p','e',0};
 101 static const WCHAR data_fileW[] = {'D','a','t','a',' ','F','i','l','e',0};
 102 static const WCHAR default_devmodeW[] = {'D','e','f','a','u','l','t',' ','D','e','v','M','o','d','e',0};
 103 static const WCHAR dependent_filesW[] = {'D','e','p','e','n','d','e','n','t',' ','F','i','l','e','s',0};
 104 static const WCHAR descriptionW[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
 105 static const WCHAR driverW[] = {'D','r','i','v','e','r',0};
 106 static const WCHAR emptyW[] = {0};
 107 static const WCHAR fmt_driversW[] = { 'S','y','s','t','e','m','\\',
 108                                   'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 109                                   'c','o','n','t','r','o','l','\\',
 110                                   'P','r','i','n','t','\\',
 111                                   'E','n','v','i','r','o','n','m','e','n','t','s','\\',
 112                                   '%','s','\\','D','r','i','v','e','r','s','%','s',0 };
 113 static const WCHAR fmt_printprocessorsW[] = { 'S','y','s','t','e','m','\\',
 114                                   'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 115                                   'C','o','n','t','r','o','l','\\',
 116                                   'P','r','i','n','t','\\',
 117                                   'E','n','v','i','r','o','n','m','e','n','t','s','\\','%','s','\\',
 118                                   'P','r','i','n','t',' ','P','r','o','c','e','s','s','o','r','s',0 };
 119 static const WCHAR hardwareidW[] = {'H','a','r','d','w','a','r','e','I','D',0};
 120 static const WCHAR help_fileW[] = {'H','e','l','p',' ','F','i','l','e',0};
 121 static const WCHAR ia64_envnameW[] = {'W','i','n','d','o','w','s',' ','I','A','6','4',0};
 122 static const WCHAR ia64_subdirW[] = {'i','a','6','4',0};
 123 static const WCHAR localportW[] = {'L','o','c','a','l',' ','P','o','r','t',0};
 124 static const WCHAR locationW[] = {'L','o','c','a','t','i','o','n',0};
 125 static const WCHAR manufacturerW[] = {'M','a','n','u','f','a','c','t','u','r','e','r',0};
 126 static const WCHAR monitorW[] = {'M','o','n','i','t','o','r',0};
 127 static const WCHAR monitorsW[] = {'S','y','s','t','e','m','\\',
 128                                 'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 129                                 'C','o','n','t','r','o','l','\\',
 130                                 'P','r','i','n','t','\\',
 131                                 'M','o','n','i','t','o','r','s','\\',0};
 132 static const WCHAR monitorUIW[] = {'M','o','n','i','t','o','r','U','I',0};
 133 static const WCHAR nameW[] = {'N','a','m','e',0};
 134 static const WCHAR oem_urlW[] = {'O','E','M',' ','U','r','l',0};
 135 static const WCHAR parametersW[] = {'P','a','r','a','m','e','t','e','r','s',0};
 136 static const WCHAR portW[] = {'P','o','r','t',0};
 137 static const WCHAR previous_namesW[] = {'P','r','e','v','i','o','u','s',' ','N','a','m','e','s',0};
 138 static const WCHAR printersW[] = {'S','y','s','t','e','m','\\',
 139                                   'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 140                                   'C','o','n','t','r','o','l','\\',
 141                                   'P','r','i','n','t','\\',
 142                                   'P','r','i','n','t','e','r','s',0};
 143 static const WCHAR spooldriversW[] = {'\\','s','p','o','o','l','\\','d','r','i','v','e','r','s','\\',0};
 144 static const WCHAR spoolprtprocsW[] = {'\\','s','p','o','o','l','\\','p','r','t','p','r','o','c','s','\\',0};
 145 static const WCHAR version0_regpathW[] = {'\\','V','e','r','s','i','o','n','-','0',0};
 146 static const WCHAR version0_subdirW[] = {'\\','0',0};
 147 static const WCHAR version3_regpathW[] = {'\\','V','e','r','s','i','o','n','-','3',0};
 148 static const WCHAR version3_subdirW[] = {'\\','3',0};
 149 static const WCHAR versionW[] = {'V','e','r','s','i','o','n',0};
 150 static const WCHAR win40_envnameW[] = {'W','i','n','d','o','w','s',' ','4','.','0',0};
 151 static const WCHAR win40_subdirW[] = {'w','i','n','4','0',0};
 152 static const WCHAR winnt_cv_portsW[] = {'S','o','f','t','w','a','r','e','\\',
 153                                         'M','i','c','r','o','s','o','f','t','\\',
 154                                         'W','i','n','d','o','w','s',' ','N','T','\\',
 155                                         'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 156                                         'P','o','r','t','s',0};
 157 static const WCHAR winprintW[] = {'w','i','n','p','r','i','n','t',0};
 158 static const WCHAR x64_envnameW[] = {'W','i','n','d','o','w','s',' ','x','6','4',0};
 159 static const WCHAR x64_subdirW[] = {'x','6','4',0};
 160 static const WCHAR x86_envnameW[] = {'W','i','n','d','o','w','s',' ','N','T',' ','x','8','6',0};
 161 static const WCHAR x86_subdirW[] = {'w','3','2','x','8','6',0};
 162 static const WCHAR XcvMonitorW[] = {',','X','c','v','M','o','n','i','t','o','r',' ',0};
 163 static const WCHAR XcvPortW[] = {',','X','c','v','P','o','r','t',' ',0};
 164
 165
 166 static const printenv_t env_ia64 =  {ia64_envnameW, ia64_subdirW, 3,
 167                                      version3_regpathW, version3_subdirW};
 168
 169 static const printenv_t env_x86 =   {x86_envnameW, x86_subdirW, 3,
 170                                      version3_regpathW, version3_subdirW};
 171
 172 static const printenv_t env_x64 =   {x64_envnameW, x64_subdirW, 3,
 173                                      version3_regpathW, version3_subdirW};
 174
 175 static const printenv_t env_win40 = {win40_envnameW, win40_subdirW, 0,
 176                                      version0_regpathW, version0_subdirW};
 177
 178 static const printenv_t * const all_printenv[] = {&env_x86, &env_x64, &env_ia64, &env_win40};
 179
 180
 181 static const DWORD di_sizeof[] = {0, sizeof(DRIVER_INFO_1W), sizeof(DRIVER_INFO_2W),
 182                                      sizeof(DRIVER_INFO_3W), sizeof(DRIVER_INFO_4W),
 183                                      sizeof(DRIVER_INFO_5W), sizeof(DRIVER_INFO_6W),
 184                                   0, sizeof(DRIVER_INFO_8W)};
 185
 186
 187 /******************************************************************
 188  * strdupW [internal]
 189  *
 190  * create a copy of a unicode-string
 191  *
 192  */
 193 static LPWSTR strdupW(LPCWSTR p)
 194 {
 195     LPWSTR ret;
 196     DWORD len;
 197
 198     if(!p) return NULL;
 199     len = (lstrlenW(p) + 1) * sizeof(WCHAR);
 200     ret = heap_alloc(len);
 201     if (ret) memcpy(ret, p, len);
 202     return ret;
 203 }
 204
 205 /******************************************************************
 206  *  apd_copyfile [internal]
 207  *
 208  * Copy a file from the driverdirectory to the versioned directory
 209  *
 210  * RETURNS
 211  *  Success: TRUE
 212  *  Failure: FALSE
 213  *
 214  */
 215 static BOOL apd_copyfile(LPWSTR filename, apd_data_t *apd)
 216 {
 217     LPWSTR  ptr;
 218     LPWSTR  srcname;
 219     DWORD   res;
 220
 221     apd->src[apd->srclen] = '\0';
 222     apd->dst[apd->dstlen] = '\0';
 223
 224     if (!filename || !filename[0]) {
 225         /* nothing to copy */
 226         return TRUE;
 227     }
 228
 229     ptr = strrchrW(filename, '\\');
 230     if (ptr) {
 231         ptr++;
 232     }
 233     else
 234     {
 235         ptr = filename;
 236     }
 237
 238     if (apd->copyflags & APD_COPY_FROM_DIRECTORY) {
 239         /* we have an absolute Path */
 240         srcname = filename;
 241     }
 242     else
 243     {
 244         srcname = apd->src;
 245         lstrcatW(srcname, ptr);
 246     }
 247     lstrcatW(apd->dst, ptr);
 248
 249     TRACE("%s => %s\n", debugstr_w(filename), debugstr_w(apd->dst));
 250
 251     /* FIXME: handle APD_COPY_NEW_FILES */
 252     res = CopyFileW(srcname, apd->dst, FALSE);
 253     TRACE("got %u with %u\n", res, GetLastError());
 254
 255     return (apd->lazy) ? TRUE : res;
 256 }
 257
 258 /******************************************************************
 259  * copy_servername_from_name  (internal)
 260  *
 261  * for an external server, the serverpart from the name is copied.
 262  *
 263  * RETURNS
 264  *  the length (in WCHAR) of the serverpart (0 for the local computer)
 265  *  (-length), when the name is to long
 266  *
 267  */
 268 static LONG copy_servername_from_name(LPCWSTR name, LPWSTR target)
 269 {
 270     LPCWSTR server;
 271     LPWSTR  ptr;
 272     WCHAR   buffer[MAX_COMPUTERNAME_LENGTH +1];
 273     DWORD   len;
 274     DWORD   serverlen;
 275
 276     if (target) *target = '\0';
 277
 278     if (name == NULL) return 0;
 279     if ((name[0] != '\\') || (name[1] != '\\')) return 0;
 280
 281     server = &name[2];
 282     /* skip over both backslash, find separator '\' */
 283     ptr = strchrW(server, '\\');
 284     serverlen = (ptr) ? ptr - server : lstrlenW(server);
 285
 286     /* servername is empty */
 287     if (serverlen == 0) return 0;
 288
 289     TRACE("found %s\n", debugstr_wn(server, serverlen));
 290
 291     if (serverlen > MAX_COMPUTERNAME_LENGTH) return -serverlen;
 292
 293     if (target) {
 294         memcpy(target, server, serverlen * sizeof(WCHAR));
 295         target[serverlen] = '\0';
 296     }
 297
 298     len = sizeof(buffer) / sizeof(buffer[0]);
 299     if (GetComputerNameW(buffer, &len)) {
 300         if ((serverlen == len) && (strncmpiW(server, buffer, len) == 0)) {
 301             /* The requested Servername is our computername */
 302             return 0;
 303         }
 304     }
 305     return serverlen;
 306 }
 307
 308 /******************************************************************
 309  * get_basename_from_name  (internal)
 310  *
 311  * skip over the serverpart from the full name
 312  *
 313  */
 314 static LPCWSTR get_basename_from_name(LPCWSTR name)
 315 {
 316     if (name == NULL)  return NULL;
 317     if ((name[0] == '\\') && (name[1] == '\\')) {
 318         /* skip over the servername and search for the following '\'  */
 319         name = strchrW(&name[2], '\\');
 320         if ((name) && (name[1])) {
 321             /* found a separator ('\') followed by a name:
 322                skip over the separator and return the rest */
 323             name++;
 324         }
 325         else
 326         {
 327             /* no basename present (we found only a servername) */
 328             return NULL;
 329         }
 330     }
 331     return name;
 332 }
 333
 334 /******************************************************************
 335  * monitor_unload [internal]
 336  *
 337  * release a printmonitor and unload it from memory, when needed
 338  *
 339  */
 340 static void monitor_unload(monitor_t * pm)
 341 {
 342     if (pm == NULL) return;
 343     TRACE("%p (refcount: %d) %s\n", pm, pm->refcount, debugstr_w(pm->name));
 344
 345     EnterCriticalSection(&monitor_handles_cs);
 346
 347     if (pm->refcount) pm->refcount--;
 348
 349     if (pm->refcount == 0) {
 350         list_remove(&pm->entry);
 351         FreeLibrary(pm->hdll);
 352         heap_free(pm->name);
 353         heap_free(pm->dllname);
 354         heap_free(pm);
 355     }
 356     LeaveCriticalSection(&monitor_handles_cs);
 357 }
 358
 359 /******************************************************************
 360  * monitor_unloadall [internal]
 361  *
 362  * release all registered printmonitors and unload them from memory, when needed
 363  *
 364  */
 365
 366 static void monitor_unloadall(void)
 367 {
 368     monitor_t * pm;
 369     monitor_t * next;
 370
 371     EnterCriticalSection(&monitor_handles_cs);
 372     /* iterate through the list, with safety against removal */
 373     LIST_FOR_EACH_ENTRY_SAFE(pm, next, &monitor_handles, monitor_t, entry)
 374     {
 375         /* skip monitorui dlls */
 376         if (pm->monitor) monitor_unload(pm);
 377     }
 378     LeaveCriticalSection(&monitor_handles_cs);
 379 }
 380
 381 /******************************************************************
 382  * monitor_load [internal]
 383  *
 384  * load a printmonitor, get the dllname from the registry, when needed
 385  * initialize the monitor and dump found function-pointers
 386  *
 387  * On failure, SetLastError() is called and NULL is returned
 388  */
 389
 390 static monitor_t * monitor_load(LPCWSTR name, LPWSTR dllname)
 391 {
 392     LPMONITOR2  (WINAPI *pInitializePrintMonitor2) (PMONITORINIT, LPHANDLE);
 393     PMONITORUI  (WINAPI *pInitializePrintMonitorUI)(VOID);
 394     LPMONITOREX (WINAPI *pInitializePrintMonitor)  (LPWSTR);
 395     DWORD (WINAPI *pInitializeMonitorEx)(LPWSTR, LPMONITOR);
 396     DWORD (WINAPI *pInitializeMonitor)  (LPWSTR);
 397
 398     monitor_t * pm = NULL;
 399     monitor_t * cursor;
 400     LPWSTR  regroot = NULL;
 401     LPWSTR  driver = dllname;
 402
 403     TRACE("(%s, %s)\n", debugstr_w(name), debugstr_w(dllname));
 404     /* Is the Monitor already loaded? */
 405     EnterCriticalSection(&monitor_handles_cs);
 406
 407     if (name) {
 408         LIST_FOR_EACH_ENTRY(cursor, &monitor_handles, monitor_t, entry)
 409         {
 410             if (cursor->name && (lstrcmpW(name, cursor->name) == 0)) {
 411                 pm = cursor;
 412                 break;
 413             }
 414         }
 415     }
 416
 417     if (pm == NULL) {
 418         pm = heap_alloc_zero(sizeof(monitor_t));
 419         if (pm == NULL) goto cleanup;
 420         list_add_tail(&monitor_handles, &pm->entry);
 421     }
 422     pm->refcount++;
 423
 424     if (pm->name == NULL) {
 425         /* Load the monitor */
 426         LPMONITOREX pmonitorEx;
 427         DWORD   len;
 428
 429         if (name) {
 430             len = lstrlenW(monitorsW) + lstrlenW(name) + 2;
 431             regroot = heap_alloc(len * sizeof(WCHAR));
 432         }
 433
 434         if (regroot) {
 435             lstrcpyW(regroot, monitorsW);
 436             lstrcatW(regroot, name);
 437             /* Get the Driver from the Registry */
 438             if (driver == NULL) {
 439                 HKEY    hroot;
 440                 DWORD   namesize;
 441                 if (RegOpenKeyW(HKEY_LOCAL_MACHINE, regroot, &hroot) == ERROR_SUCCESS) {
 442                     if (RegQueryValueExW(hroot, driverW, NULL, NULL, NULL,
 443                                         &namesize) == ERROR_SUCCESS) {
 444                         driver = heap_alloc(namesize);
 445                         RegQueryValueExW(hroot, driverW, NULL, NULL, (LPBYTE) driver, &namesize) ;
 446                     }
 447                     RegCloseKey(hroot);
 448                 }
 449             }
 450         }
 451
 452         pm->name = strdupW(name);
 453         pm->dllname = strdupW(driver);
 454
 455         if ((name && (!regroot || !pm->name)) || !pm->dllname) {
 456             monitor_unload(pm);
 457             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 458             pm = NULL;
 459             goto cleanup;
 460         }
 461
 462         pm->hdll = LoadLibraryW(driver);
 463         TRACE("%p: LoadLibrary(%s) => %d\n", pm->hdll, debugstr_w(driver), GetLastError());
 464
 465         if (pm->hdll == NULL) {
 466             monitor_unload(pm);
 467             SetLastError(ERROR_MOD_NOT_FOUND);
 468             pm = NULL;
 469             goto cleanup;
 470         }
 471
 472         pInitializePrintMonitor2  = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitor2");
 473         pInitializePrintMonitorUI = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitorUI");
 474         pInitializePrintMonitor   = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitor");
 475         pInitializeMonitorEx = (void *)GetProcAddress(pm->hdll, "InitializeMonitorEx");
 476         pInitializeMonitor   = (void *)GetProcAddress(pm->hdll, "InitializeMonitor");
 477
 478
 479         TRACE("%p: %s,pInitializePrintMonitor2\n", pInitializePrintMonitor2, debugstr_w(driver));
 480         TRACE("%p: %s,pInitializePrintMonitorUI\n", pInitializePrintMonitorUI, debugstr_w(driver));
 481         TRACE("%p: %s,pInitializePrintMonitor\n", pInitializePrintMonitor, debugstr_w(driver));
 482         TRACE("%p: %s,pInitializeMonitorEx\n", pInitializeMonitorEx, debugstr_w(driver));
 483         TRACE("%p: %s,pInitializeMonitor\n", pInitializeMonitor, debugstr_w(driver));
 484
 485         if (pInitializePrintMonitorUI  != NULL) {
 486             pm->monitorUI = pInitializePrintMonitorUI();
 487             TRACE("%p: MONITORUI from %s,InitializePrintMonitorUI()\n", pm->monitorUI, debugstr_w(driver));
 488             if (pm->monitorUI) {
 489                 TRACE("0x%08x: dwMonitorSize (%d)\n",
 490                         pm->monitorUI->dwMonitorUISize, pm->monitorUI->dwMonitorUISize);
 491
 492             }
 493         }
 494
 495         if (pInitializePrintMonitor && regroot) {
 496             pmonitorEx = pInitializePrintMonitor(regroot);
 497             TRACE("%p: LPMONITOREX from %s,InitializePrintMonitor(%s)\n",
 498                     pmonitorEx, debugstr_w(driver), debugstr_w(regroot));
 499
 500             if (pmonitorEx) {
 501                 pm->dwMonitorSize = pmonitorEx->dwMonitorSize;
 502                 pm->monitor = &(pmonitorEx->Monitor);
 503             }
 504         }
 505
 506         if (pm->monitor) {
 507             TRACE("0x%08x: dwMonitorSize (%d)\n", pm->dwMonitorSize, pm->dwMonitorSize);
 508
 509         }
 510
 511         if (!pm->monitor && regroot) {
 512             if (pInitializePrintMonitor2 != NULL) {
 513                 FIXME("%s,InitializePrintMonitor2 not implemented\n", debugstr_w(driver));
 514             }
 515             if (pInitializeMonitorEx != NULL) {
 516                 FIXME("%s,InitializeMonitorEx not implemented\n", debugstr_w(driver));
 517             }
 518             if (pInitializeMonitor != NULL) {
 519                 FIXME("%s,InitializeMonitor not implemented\n", debugstr_w(driver));
 520             }
 521         }
 522         if (!pm->monitor && !pm->monitorUI) {
 523             monitor_unload(pm);
 524             SetLastError(ERROR_PROC_NOT_FOUND);
 525             pm = NULL;
 526         }
 527     }
 528 cleanup:
 529     if ((pm_localport ==  NULL) && (pm != NULL) && (lstrcmpW(pm->name, localportW) == 0)) {
 530         pm->refcount++;
 531         pm_localport = pm;
 532     }
 533     LeaveCriticalSection(&monitor_handles_cs);
 534     if (driver != dllname) heap_free(driver);
 535     heap_free(regroot);
 536     TRACE("=> %p\n", pm);
 537     return pm;
 538 }
 539
 540 /******************************************************************
 541  * monitor_loadall [internal]
 542  *
 543  * Load all registered monitors
 544  *
 545  */
 546 static DWORD monitor_loadall(void)
 547 {
 548     monitor_t * pm;
 549     DWORD   registered = 0;
 550     DWORD   loaded = 0;
 551     HKEY    hmonitors;
 552     WCHAR   buffer[MAX_PATH];
 553     DWORD   id = 0;
 554
 555     if (RegOpenKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hmonitors) == ERROR_SUCCESS) {
 556         RegQueryInfoKeyW(hmonitors, NULL, NULL, NULL, &registered, NULL, NULL,
 557                         NULL, NULL, NULL, NULL, NULL);
 558
 559         TRACE("%d monitors registered\n", registered);
 560
 561         while (id < registered) {
 562             buffer[0] = '\0';
 563             RegEnumKeyW(hmonitors, id, buffer, MAX_PATH);
 564             pm = monitor_load(buffer, NULL);
 565             if (pm) loaded++;
 566             id++;
 567         }
 568         RegCloseKey(hmonitors);
 569     }
 570     TRACE("%d monitors loaded\n", loaded);
 571     return loaded;
 572 }
 573
 574 /******************************************************************
 575  * monitor_loadui [internal]
 576  *
 577  * load the userinterface-dll for a given portmonitor
 578  *
 579  * On failure, NULL is returned
 580  */
 581 static monitor_t * monitor_loadui(monitor_t * pm)
 582 {
 583     monitor_t * pui = NULL;
 584     WCHAR   buffer[MAX_PATH];
 585     HANDLE  hXcv;
 586     DWORD   len;
 587     DWORD   res;
 588
 589     if (pm == NULL) return NULL;
 590     TRACE("(%p) => dllname: %s\n", pm, debugstr_w(pm->dllname));
 591
 592     /* Try the Portmonitor first; works for many monitors */
 593     if (pm->monitorUI) {
 594         EnterCriticalSection(&monitor_handles_cs);
 595         pm->refcount++;
 596         LeaveCriticalSection(&monitor_handles_cs);
 597         return pm;
 598     }
 599
 600     /* query the userinterface-dllname from the Portmonitor */
 601     if ((pm->monitor) && (pm->monitor->pfnXcvDataPort)) {
 602         /* building (",XcvMonitor %s",pm->name) not needed yet */
 603         res = pm->monitor->pfnXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
 604         TRACE("got %u with %p\n", res, hXcv);
 605         if (res) {
 606             res = pm->monitor->pfnXcvDataPort(hXcv, monitorUIW, NULL, 0, (BYTE *) buffer, sizeof(buffer), &len);
 607             TRACE("got %u with %s\n", res, debugstr_w(buffer));
 608             if (res == ERROR_SUCCESS) pui = monitor_load(NULL, buffer);
 609             pm->monitor->pfnXcvClosePort(hXcv);
 610         }
 611     }
 612     return pui;
 613 }
 614
 615 /******************************************************************
 616  * monitor_load_by_port [internal]
 617  *
 618  * load a printmonitor for a given port
 619  *
 620  * On failure, NULL is returned
 621  */
 622
 623 static monitor_t * monitor_load_by_port(LPCWSTR portname)
 624 {
 625     HKEY    hroot;
 626     HKEY    hport;
 627     LPWSTR  buffer;
 628     monitor_t * pm = NULL;
 629     DWORD   registered = 0;
 630     DWORD   id = 0;
 631     DWORD   len;
 632
 633     TRACE("(%s)\n", debugstr_w(portname));
 634
 635     /* Try the Local Monitor first */
 636     if (RegOpenKeyW(HKEY_LOCAL_MACHINE, winnt_cv_portsW, &hroot) == ERROR_SUCCESS) {
 637         if (RegQueryValueExW(hroot, portname, NULL, NULL, NULL, &len) == ERROR_SUCCESS) {
 638             /* found the portname */
 639             RegCloseKey(hroot);
 640             return monitor_load(localportW, NULL);
 641         }
 642         RegCloseKey(hroot);
 643     }
 644
 645     len = MAX_PATH + lstrlenW(bs_ports_bsW) + lstrlenW(portname) + 1;
 646     buffer = heap_alloc(len * sizeof(WCHAR));
 647     if (buffer == NULL) return NULL;
 648
 649     if (RegOpenKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) == ERROR_SUCCESS) {
 650         EnterCriticalSection(&monitor_handles_cs);
 651         RegQueryInfoKeyW(hroot, NULL, NULL, NULL, &registered, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 652
 653         while ((pm == NULL) && (id < registered)) {
 654             buffer[0] = '\0';
 655             RegEnumKeyW(hroot, id, buffer, MAX_PATH);
 656             TRACE("testing %s\n", debugstr_w(buffer));
 657             len = lstrlenW(buffer);
 658             lstrcatW(buffer, bs_ports_bsW);
 659             lstrcatW(buffer, portname);
 660             if (RegOpenKeyW(hroot, buffer, &hport) == ERROR_SUCCESS) {
 661                 RegCloseKey(hport);
 662                 buffer[len] = '\0';             /* use only the Monitor-Name */
 663                 pm = monitor_load(buffer, NULL);
 664             }
 665             id++;
 666         }
 667         LeaveCriticalSection(&monitor_handles_cs);
 668         RegCloseKey(hroot);
 669     }
 670     heap_free(buffer);
 671     return pm;
 672 }
 673
 674 /******************************************************************
 675  * Return the number of bytes for an multi_sz string.
 676  * The result includes all \0s
 677  * (specifically the extra \0, that is needed as multi_sz terminator).
 678  */
 679 static int multi_sz_lenW(const WCHAR *str)
 680 {
 681     const WCHAR *ptr = str;
 682     if (!str) return 0;
 683     do
 684     {
 685         ptr += lstrlenW(ptr) + 1;
 686     } while (*ptr);
 687
 688     return (ptr - str + 1) * sizeof(WCHAR);
 689 }
 690
 691 /******************************************************************
 692  * validate_envW [internal]
 693  *
 694  * validate the user-supplied printing-environment
 695  *
 696  * PARAMS
 697  *  env  [I] PTR to Environment-String or NULL
 698  *
 699  * RETURNS
 700  *  Success:  PTR to printenv_t
 701  *  Failure:  NULL and ERROR_INVALID_ENVIRONMENT
 702  *
 703  * NOTES
 704  *  An empty string is handled the same way as NULL.
 705  *
 706  */
 707
 708 static const  printenv_t * validate_envW(LPCWSTR env)
 709 {
 710     const printenv_t *result = NULL;
 711     unsigned int i;
 712
 713     TRACE("(%s)\n", debugstr_w(env));
 714     if (env && env[0])
 715     {
 716         for (i = 0; i < sizeof(all_printenv)/sizeof(all_printenv[0]); i++)
 717         {
 718             if (lstrcmpiW(env, all_printenv[i]->envname) == 0)
 719             {
 720                 result = all_printenv[i];
 721                 break;
 722             }
 723         }
 724         if (result == NULL) {
 725             FIXME("unsupported Environment: %s\n", debugstr_w(env));
 726             SetLastError(ERROR_INVALID_ENVIRONMENT);
 727         }
 728         /* on win9x, only "Windows 4.0" is allowed, but we ignore this */
 729     }
 730     else
 731     {
 732         result = (GetVersion() & 0x80000000) ? &env_win40 : &env_x86;
 733     }
 734
 735     TRACE("=> using %p: %s\n", result, debugstr_w(result ? result->envname : NULL));
 736     return result;
 737 }
 738
 739 /*****************************************************************************
 740  * enumerate the local monitors (INTERNAL)
 741  *
 742  * returns the needed size (in bytes) for pMonitors
 743  * and  *lpreturned is set to number of entries returned in pMonitors
 744  *
 745  * Language-Monitors are also installed in the same Registry-Location but
 746  * they are filtered in Windows (not returned by EnumMonitors).
 747  * We do no filtering to simplify our Code.
 748  *
 749  */
 750 static DWORD get_local_monitors(DWORD level, LPBYTE pMonitors, DWORD cbBuf, LPDWORD lpreturned)
 751 {
 752     HKEY    hroot = NULL;
 753     HKEY    hentry = NULL;
 754     LPWSTR  ptr;
 755     LPMONITOR_INFO_2W mi;
 756     WCHAR   buffer[MAX_PATH];
 757     WCHAR   dllname[MAX_PATH];
 758     DWORD   dllsize;
 759     DWORD   len;
 760     DWORD   index = 0;
 761     DWORD   needed = 0;
 762     DWORD   numentries;
 763     DWORD   entrysize;
 764
 765     entrysize = (level == 1) ? sizeof(MONITOR_INFO_1W) : sizeof(MONITOR_INFO_2W);
 766
 767     numentries = *lpreturned;       /* this is 0, when we scan the registry */
 768     len = entrysize * numentries;
 769     ptr = (LPWSTR) &pMonitors[len];
 770
 771     numentries = 0;
 772     len = sizeof(buffer)/sizeof(buffer[0]);
 773     buffer[0] = '\0';
 774
 775     /* Windows creates the "Monitors"-Key on reboot / start "spooler" */
 776     if (RegCreateKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) == ERROR_SUCCESS) {
 777         /* Scan all Monitor-Registry-Keys */
 778         while (RegEnumKeyExW(hroot, index, buffer, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
 779             TRACE("Monitor_%d: %s\n", numentries, debugstr_w(buffer));
 780             dllsize = sizeof(dllname);
 781             dllname[0] = '\0';
 782
 783             /* The Monitor must have a Driver-DLL */
 784             if (RegOpenKeyExW(hroot, buffer, 0, KEY_READ, &hentry) == ERROR_SUCCESS) {
 785                 if (RegQueryValueExW(hentry, driverW, NULL, NULL, (LPBYTE) dllname, &dllsize) == ERROR_SUCCESS) {
 786                     /* We found a valid DLL for this Monitor. */
 787                     TRACE("using Driver: %s\n", debugstr_w(dllname));
 788                 }
 789                 RegCloseKey(hentry);
 790             }
 791
 792             /* Windows returns only Port-Monitors here, but to simplify our code,
 793                we do no filtering for Language-Monitors */
 794             if (dllname[0]) {
 795                 numentries++;
 796                 needed += entrysize;
 797                 needed += (len+1) * sizeof(WCHAR);  /* len is lstrlenW(monitorname) */
 798                 if (level > 1) {
 799                     /* we install and return only monitors for "Windows NT x86" */
 800                     needed += (lstrlenW(x86_envnameW) +1) * sizeof(WCHAR);
 801                     needed += dllsize;
 802                 }
 803
 804                 /* required size is calculated. Now fill the user-buffer */
 805                 if (pMonitors && (cbBuf >= needed)){
 806                     mi = (LPMONITOR_INFO_2W) pMonitors;
 807                     pMonitors += entrysize;
 808
 809                     TRACE("%p: writing MONITOR_INFO_%dW #%d\n", mi, level, numentries);
 810                     mi->pName = ptr;
 811                     lstrcpyW(ptr, buffer);      /* Name of the Monitor */
 812                     ptr += (len+1);               /* len is lstrlenW(monitorname) */
 813                     if (level > 1) {
 814                         mi->pEnvironment = ptr;
 815                         lstrcpyW(ptr, x86_envnameW); /* fixed to "Windows NT x86" */
 816                         ptr += (lstrlenW(x86_envnameW)+1);
 817
 818                         mi->pDLLName = ptr;
 819                         lstrcpyW(ptr, dllname);         /* Name of the Driver-DLL */
 820                         ptr += (dllsize / sizeof(WCHAR));
 821                     }
 822                 }
 823             }
 824             index++;
 825             len = sizeof(buffer)/sizeof(buffer[0]);
 826             buffer[0] = '\0';
 827         }
 828         RegCloseKey(hroot);
 829     }
 830     *lpreturned = numentries;
 831     TRACE("need %d byte for %d entries\n", needed, numentries);
 832     return needed;
 833 }
 834
 835 /*****************************************************************************
 836  * enumerate the local print processors (INTERNAL)
 837  *
 838  * returns the needed size (in bytes) for pPPInfo
 839  * and  *lpreturned is set to number of entries returned in pPPInfo
 840  *
 841  */
 842 static DWORD get_local_printprocessors(LPWSTR regpathW, LPBYTE pPPInfo, DWORD cbBuf, LPDWORD lpreturned)
 843 {
 844     HKEY    hroot = NULL;
 845     HKEY    hentry = NULL;
 846     LPWSTR  ptr;
 847     PPRINTPROCESSOR_INFO_1W ppi;
 848     WCHAR   buffer[MAX_PATH];
 849     WCHAR   dllname[MAX_PATH];
 850     DWORD   dllsize;
 851     DWORD   len;
 852     DWORD   index = 0;
 853     DWORD   needed = 0;
 854     DWORD   numentries;
 855
 856     numentries = *lpreturned;       /* this is 0, when we scan the registry */
 857     len = numentries * sizeof(PRINTPROCESSOR_INFO_1W);
 858     ptr = (LPWSTR) &pPPInfo[len];
 859
 860     numentries = 0;
 861     len = sizeof(buffer)/sizeof(buffer[0]);
 862     buffer[0] = '\0';
 863
 864     if (RegCreateKeyW(HKEY_LOCAL_MACHINE, regpathW, &hroot) == ERROR_SUCCESS) {
 865         /* add "winprint" first */
 866         numentries++;
 867         needed = sizeof(PRINTPROCESSOR_INFO_1W) + sizeof(winprintW);
 868         if (pPPInfo && (cbBuf >= needed)){
 869             ppi = (PPRINTPROCESSOR_INFO_1W) pPPInfo;
 870             pPPInfo += sizeof(PRINTPROCESSOR_INFO_1W);
 871
 872             TRACE("%p: writing PRINTPROCESSOR_INFO_1W #%d\n", ppi, numentries);
 873             ppi->pName = ptr;
 874             lstrcpyW(ptr, winprintW);      /* Name of the Print Processor */
 875             ptr += sizeof(winprintW) / sizeof(WCHAR);
 876         }
 877
 878         /* Scan all Printprocessor Keys */
 879         while ((RegEnumKeyExW(hroot, index, buffer, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) &&
 880             (lstrcmpiW(buffer, winprintW) != 0)) {
 881             TRACE("PrintProcessor_%d: %s\n", numentries, debugstr_w(buffer));
 882             dllsize = sizeof(dllname);
 883             dllname[0] = '\0';
 884
 885             /* The Print Processor must have a Driver-DLL */
 886             if (RegOpenKeyExW(hroot, buffer, 0, KEY_READ, &hentry) == ERROR_SUCCESS) {
 887                 if (RegQueryValueExW(hentry, driverW, NULL, NULL, (LPBYTE) dllname, &dllsize) == ERROR_SUCCESS) {
 888                     /* We found a valid DLL for this Print Processor */
 889                     TRACE("using Driver: %s\n", debugstr_w(dllname));
 890                 }
 891                 RegCloseKey(hentry);
 892             }
 893
 894             if (dllname[0]) {
 895                 numentries++;
 896                 needed += sizeof(PRINTPROCESSOR_INFO_1W);
 897                 needed += (len+1) * sizeof(WCHAR);  /* len is lstrlenW(printprocessor name) */
 898
 899                 /* required size is calculated. Now fill the user-buffer */
 900                 if (pPPInfo && (cbBuf >= needed)){
 901                     ppi = (PPRINTPROCESSOR_INFO_1W) pPPInfo;
 902                     pPPInfo += sizeof(PRINTPROCESSOR_INFO_1W);
 903
 904                     TRACE("%p: writing PRINTPROCESSOR_INFO_1W #%d\n", ppi, numentries);
 905                     ppi->pName = ptr;
 906                     lstrcpyW(ptr, buffer);      /* Name of the Print Processor */
 907                     ptr += (len+1);             /* len is lstrlenW(printprosessor name) */
 908                 }
 909             }
 910             index++;
 911             len = sizeof(buffer)/sizeof(buffer[0]);
 912             buffer[0] = '\0';
 913         }
 914         RegCloseKey(hroot);
 915     }
 916     *lpreturned = numentries;
 917     TRACE("need %d byte for %d entries\n", needed, numentries);
 918     return needed;
 919 }
 920
 921 /******************************************************************
 922  * enumerate the local Ports from all loaded monitors (internal)
 923  *
 924  * returns the needed size (in bytes) for pPorts
 925  * and  *lpreturned is set to number of entries returned in pPorts
 926  *
 927  */
 928 static DWORD get_ports_from_all_monitors(DWORD level, LPBYTE pPorts, DWORD cbBuf, LPDWORD lpreturned)
 929 {
 930     monitor_t * pm;
 931     LPWSTR      ptr;
 932     LPPORT_INFO_2W cache;
 933     LPPORT_INFO_2W out;
 934     LPBYTE  pi_buffer = NULL;
 935     DWORD   pi_allocated = 0;
 936     DWORD   pi_needed;
 937     DWORD   pi_index;
 938     DWORD   pi_returned;
 939     DWORD   res;
 940     DWORD   outindex = 0;
 941     DWORD   needed;
 942     DWORD   numentries;
 943     DWORD   entrysize;
 944
 945
 946     TRACE("(%d, %p, %d, %p)\n", level, pPorts, cbBuf, lpreturned);
 947     entrysize = (level == 1) ? sizeof(PORT_INFO_1W) : sizeof(PORT_INFO_2W);
 948
 949     numentries = *lpreturned;       /* this is 0, when we scan the registry */
 950     needed = entrysize * numentries;
 951     ptr = (LPWSTR) &pPorts[needed];
 952
 953     numentries = 0;
 954     needed = 0;
 955
 956     LIST_FOR_EACH_ENTRY(pm, &monitor_handles, monitor_t, entry)
 957     {
 958         if ((pm->monitor) && (pm->monitor->pfnEnumPorts)) {
 959             pi_needed = 0;
 960             pi_returned = 0;
 961             res = pm->monitor->pfnEnumPorts(NULL, level, pi_buffer, pi_allocated, &pi_needed, &pi_returned);
 962             if (!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
 963                 /* Do not use heap_realloc (we do not need the old data in the buffer) */
 964                 heap_free(pi_buffer);
 965                 pi_buffer = heap_alloc(pi_needed);
 966                 pi_allocated = (pi_buffer) ? pi_needed : 0;
 967                 res = pm->monitor->pfnEnumPorts(NULL, level, pi_buffer, pi_allocated, &pi_needed, &pi_returned);
 968             }
 969             TRACE("(%s) got %d with %d (need %d byte for %d entries)\n",
 970                   debugstr_w(pm->name), res, GetLastError(), pi_needed, pi_returned);
 971
 972             numentries += pi_returned;
 973             needed += pi_needed;
 974
 975             /* fill the output-buffer (pPorts), if we have one */
 976             if (pPorts && (cbBuf >= needed ) && pi_buffer) {
 977                 pi_index = 0;
 978                 while (pi_returned > pi_index) {
 979                     cache = (LPPORT_INFO_2W) &pi_buffer[pi_index * entrysize];
 980                     out = (LPPORT_INFO_2W) &pPorts[outindex * entrysize];
 981                     out->pPortName = ptr;
 982                     lstrcpyW(ptr, cache->pPortName);
 983                     ptr += (lstrlenW(ptr)+1);
 984                     if (level > 1) {
 985                         out->pMonitorName = ptr;
 986                         lstrcpyW(ptr,  cache->pMonitorName);
 987                         ptr += (lstrlenW(ptr)+1);
 988
 989                         out->pDescription = ptr;
 990                         lstrcpyW(ptr,  cache->pDescription);
 991                         ptr += (lstrlenW(ptr)+1);
 992                         out->fPortType = cache->fPortType;
 993                         out->Reserved = cache->Reserved;
 994                     }
 995                     pi_index++;
 996                     outindex++;
 997                 }
 998             }
 999         }
1000     }
1001     /* the temporary portinfo-buffer is no longer needed */
1002     heap_free(pi_buffer);
1003
1004     *lpreturned = numentries;
1005     TRACE("need %d byte for %d entries\n", needed, numentries);
1006     return needed;
1007 }
1008
1009
1010 /*****************************************************************************
1011  * open_driver_reg [internal]
1012  *
1013  * opens the registry for the printer drivers depending on the given input
1014  * variable pEnvironment
1015  *
1016  * RETURNS:
1017  *    Success: the opened hkey
1018  *    Failure: NULL
1019  */
1020 static HKEY open_driver_reg(LPCWSTR pEnvironment)
1021 {
1022     HKEY  retval = NULL;
1023     LPWSTR buffer;
1024     const printenv_t * env;
1025
1026     TRACE("(%s)\n", debugstr_w(pEnvironment));
1027
1028     env = validate_envW(pEnvironment);
1029     if (!env) return NULL;
1030
1031     buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(fmt_driversW) +
1032                 (lstrlenW(env->envname) + lstrlenW(env->versionregpath)) * sizeof(WCHAR));
1033
1034     if (buffer) {
1035         wsprintfW(buffer, fmt_driversW, env->envname, env->versionregpath);
1036         RegCreateKeyW(HKEY_LOCAL_MACHINE, buffer, &retval);
1037         HeapFree(GetProcessHeap(), 0, buffer);
1038     }
1039     return retval;
1040 }
1041
1042 /*****************************************************************************
1043  * fpGetPrinterDriverDirectory [exported through PRINTPROVIDOR]
1044  *
1045  * Return the PATH for the Printer-Drivers
1046  *
1047  * PARAMS
1048  *   pName            [I] Servername (NT only) or NULL (local Computer)
1049  *   pEnvironment     [I] Printing-Environment (see below) or NULL (Default)
1050  *   Level            [I] Structure-Level (must be 1)
1051  *   pDriverDirectory [O] PTR to Buffer that receives the Result
1052  *   cbBuf            [I] Size of Buffer at pDriverDirectory
1053  *   pcbNeeded        [O] PTR to DWORD that receives the size in Bytes used /
1054  *                        required for pDriverDirectory
1055  *
1056  * RETURNS
1057  *   Success: TRUE  and in pcbNeeded the Bytes used in pDriverDirectory
1058  *   Failure: FALSE and in pcbNeeded the Bytes required for pDriverDirectory,
1059  *            if cbBuf is too small
1060  *
1061  *   Native Values returned in pDriverDirectory on Success:
1062  *|  NT(Windows NT x86):  "%winsysdir%\\spool\\DRIVERS\\w32x86"
1063  *|  NT(Windows 4.0):     "%winsysdir%\\spool\\DRIVERS\\win40"
1064  *|  win9x(Windows 4.0):  "%winsysdir%"
1065  *
1066  *   "%winsysdir%" is the Value from GetSystemDirectoryW()
1067  *
1068  */
1069 static BOOL WINAPI fpGetPrinterDriverDirectory(LPWSTR pName, LPWSTR pEnvironment,
1070             DWORD Level, LPBYTE pDriverDirectory, DWORD cbBuf, LPDWORD pcbNeeded)
1071 {
1072     DWORD needed;
1073     const printenv_t * env;
1074
1075     TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName),
1076           debugstr_w(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
1077
1078     if (pName != NULL && pName[0]) {
1079         FIXME("server %s not supported\n", debugstr_w(pName));
1080         SetLastError(ERROR_INVALID_PARAMETER);
1081         return FALSE;
1082     }
1083
1084     env = validate_envW(pEnvironment);
1085     if (!env) return FALSE;  /* pEnvironment invalid or unsupported */
1086
1087
1088     /* GetSystemDirectoryW returns number of WCHAR including the '\0' */
1089     needed = GetSystemDirectoryW(NULL, 0);
1090     /* add the Size for the Subdirectories */
1091     needed += lstrlenW(spooldriversW);
1092     needed += lstrlenW(env->subdir);
1093     needed *= sizeof(WCHAR);  /* return-value is size in Bytes */
1094
1095     *pcbNeeded = needed;
1096
1097     if (needed > cbBuf) {
1098         SetLastError(ERROR_INSUFFICIENT_BUFFER);
1099         return FALSE;
1100     }
1101
1102     if (pDriverDirectory == NULL) {
1103         /* ERROR_INVALID_USER_BUFFER is NT, ERROR_INVALID_PARAMETER is win9x */
1104         SetLastError(ERROR_INVALID_USER_BUFFER);
1105         return FALSE;
1106     }
1107
1108     GetSystemDirectoryW((LPWSTR) pDriverDirectory, cbBuf/sizeof(WCHAR));
1109     /* add the Subdirectories */
1110     lstrcatW((LPWSTR) pDriverDirectory, spooldriversW);
1111     lstrcatW((LPWSTR) pDriverDirectory, env->subdir);
1112
1113     TRACE("=> %s\n", debugstr_w((LPWSTR) pDriverDirectory));
1114     return TRUE;
1115 }
1116
1117 /******************************************************************
1118  * driver_load [internal]
1119  *
1120  * load a driver user interface dll
1121  *
1122  * On failure, NULL is returned
1123  *
1124  */
1125
1126 static HMODULE driver_load(const printenv_t * env, LPWSTR dllname)
1127 {
1128     WCHAR fullname[MAX_PATH];
1129     HMODULE hui;
1130     DWORD len;
1131
1132     TRACE("(%p, %s)\n", env, debugstr_w(dllname));
1133
1134     /* build the driverdir */
1135     len = sizeof(fullname) -
1136           (lstrlenW(env->versionsubdir) + 1 + lstrlenW(dllname) + 1) * sizeof(WCHAR);
1137
1138     if (!fpGetPrinterDriverDirectory(NULL, (LPWSTR) env->envname, 1,
1139                                      (LPBYTE) fullname, len, &len)) {
1140         /* Should never Fail */
1141         SetLastError(ERROR_BUFFER_OVERFLOW);
1142         return NULL;
1143     }
1144
1145     lstrcatW(fullname, env->versionsubdir);
1146     lstrcatW(fullname, backslashW);
1147     lstrcatW(fullname, dllname);
1148
1149     hui = LoadLibraryW(fullname);
1150     TRACE("%p: LoadLibrary(%s) %d\n", hui, debugstr_w(fullname), GetLastError());
1151
1152     return hui;
1153 }
1154
1155 /******************************************************************
1156  *  printer_free
1157  *  free the data pointer of an opened printer
1158  */
1159 static VOID printer_free(printer_t * printer)
1160 {
1161     if (printer->hXcv)
1162         printer->pm->monitor->pfnXcvClosePort(printer->hXcv);
1163
1164     monitor_unload(printer->pm);
1165
1166     heap_free(printer->printername);
1167     heap_free(printer->name);
1168     heap_free(printer);
1169 }
1170
1171 /******************************************************************
1172  *  printer_alloc_handle
1173  *  alloc a printer handle and remember the data pointer in the printer handle table
1174  *
1175  */
1176 static HANDLE printer_alloc_handle(LPCWSTR name, LPPRINTER_DEFAULTSW pDefault)
1177 {
1178     WCHAR servername[MAX_COMPUTERNAME_LENGTH + 1];
1179     printer_t *printer = NULL;
1180     LPCWSTR printername;
1181     HKEY    hkeyPrinters;
1182     HKEY    hkeyPrinter;
1183     DWORD   len;
1184
1185     if (copy_servername_from_name(name, servername)) {
1186         FIXME("server %s not supported\n", debugstr_w(servername));
1187         SetLastError(ERROR_INVALID_PRINTER_NAME);
1188         return NULL;
1189     }
1190
1191     printername = get_basename_from_name(name);
1192     if (name != printername) TRACE("converted %s to %s\n", debugstr_w(name), debugstr_w(printername));
1193
1194     /* an empty printername is invalid */
1195     if (printername && (!printername[0])) {
1196         SetLastError(ERROR_INVALID_PARAMETER);
1197         return NULL;
1198     }
1199
1200     printer = heap_alloc_zero(sizeof(printer_t));
1201     if (!printer) goto end;
1202
1203     /* clone the base name. This is NULL for the printserver */
1204     printer->printername = strdupW(printername);
1205
1206     /* clone the full name */
1207     printer->name = strdupW(name);
1208     if (name && (!printer->name)) {
1209         printer_free(printer);
1210         printer = NULL;
1211     }
1212     if (printername) {
1213         len = sizeof(XcvMonitorW)/sizeof(WCHAR) - 1;
1214         if (strncmpW(printername, XcvMonitorW, len) == 0) {
1215             /* OpenPrinter(",XcvMonitor ", ...) detected */
1216             TRACE(",XcvMonitor: %s\n", debugstr_w(&printername[len]));
1217             printer->pm = monitor_load(&printername[len], NULL);
1218             if (printer->pm == NULL) {
1219                 printer_free(printer);
1220                 SetLastError(ERROR_UNKNOWN_PORT);
1221                 printer = NULL;
1222                 goto end;
1223             }
1224         }
1225         else
1226         {
1227             len = sizeof(XcvPortW)/sizeof(WCHAR) - 1;
1228             if (strncmpW( printername, XcvPortW, len) == 0) {
1229                 /* OpenPrinter(",XcvPort ", ...) detected */
1230                 TRACE(",XcvPort: %s\n", debugstr_w(&printername[len]));
1231                 printer->pm = monitor_load_by_port(&printername[len]);
1232                 if (printer->pm == NULL) {
1233                     printer_free(printer);
1234                     SetLastError(ERROR_UNKNOWN_PORT);
1235                     printer = NULL;
1236                     goto end;
1237                 }
1238             }
1239         }
1240
1241         if (printer->pm) {
1242             if ((printer->pm->monitor) && (printer->pm->monitor->pfnXcvOpenPort)) {
1243                 printer->pm->monitor->pfnXcvOpenPort(&printername[len],
1244                                                     pDefault ? pDefault->DesiredAccess : 0,
1245                                                     &printer->hXcv);
1246             }
1247             if (printer->hXcv == NULL) {
1248                 printer_free(printer);
1249                 SetLastError(ERROR_INVALID_PARAMETER);
1250                 printer = NULL;
1251                 goto end;
1252             }
1253         }
1254         else
1255         {
1256             /* Does the Printer exist? */
1257             if (RegCreateKeyW(HKEY_LOCAL_MACHINE, printersW, &hkeyPrinters) != ERROR_SUCCESS) {
1258                 ERR("Can't create Printers key\n");
1259                 printer_free(printer);
1260                 SetLastError(ERROR_INVALID_PRINTER_NAME);
1261                 printer = NULL;
1262                 goto end;
1263             }
1264             if (RegOpenKeyW(hkeyPrinters, printername, &hkeyPrinter) != ERROR_SUCCESS) {
1265                 WARN("Printer not found in Registry: %s\n", debugstr_w(printername));
1266                 RegCloseKey(hkeyPrinters);
1267                 printer_free(printer);
1268                 SetLastError(ERROR_INVALID_PRINTER_NAME);
1269                 printer = NULL;
1270                 goto end;
1271             }
1272             RegCloseKey(hkeyPrinter);
1273             RegCloseKey(hkeyPrinters);
1274         }
1275     }
1276     else
1277     {
1278         TRACE("using the local printserver\n");
1279     }
1280
1281 end:
1282
1283     TRACE("==> %p\n", printer);
1284     return (HANDLE)printer;
1285 }
1286
1287
1288 /******************************************************************************
1289  *  myAddPrinterDriverEx [internal]
1290  *
1291  * Install a Printer Driver with the Option to upgrade / downgrade the Files
1292  * and a special mode with lazy error checking.
1293  *
1294  */
1295 static BOOL myAddPrinterDriverEx(DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags, BOOL lazy)
1296 {
1297     const printenv_t *env;
1298     apd_data_t apd;
1299     DRIVER_INFO_8W di;
1300     BOOL    (WINAPI *pDrvDriverEvent)(DWORD, DWORD, LPBYTE, LPARAM);
1301     HMODULE hui;
1302     LPWSTR  ptr;
1303     HKEY    hroot;
1304     HKEY    hdrv;
1305     DWORD   disposition;
1306     DWORD   len;
1307     LONG    lres;
1308     BOOL    res;
1309
1310     /* we need to set all entries in the Registry, independent from the Level of
1311        DRIVER_INFO, that the caller supplied */
1312
1313     ZeroMemory(&di, sizeof(di));
1314     if (pDriverInfo && (level < (sizeof(di_sizeof) / sizeof(di_sizeof[0])))) {
1315         memcpy(&di, pDriverInfo, di_sizeof[level]);
1316     }
1317
1318     /* dump the most used infos */
1319     TRACE("%p: .cVersion    : 0x%x/%d\n", pDriverInfo, di.cVersion, di.cVersion);
1320     TRACE("%p: .pName       : %s\n", di.pName, debugstr_w(di.pName));
1321     TRACE("%p: .pEnvironment: %s\n", di.pEnvironment, debugstr_w(di.pEnvironment));
1322     TRACE("%p: .pDriverPath : %s\n", di.pDriverPath, debugstr_w(di.pDriverPath));
1323     TRACE("%p: .pDataFile   : %s\n", di.pDataFile, debugstr_w(di.pDataFile));
1324     TRACE("%p: .pConfigFile : %s\n", di.pConfigFile, debugstr_w(di.pConfigFile));
1325     TRACE("%p: .pHelpFile   : %s\n", di.pHelpFile, debugstr_w(di.pHelpFile));
1326     /* dump only the first of the additional Files */
1327     TRACE("%p: .pDependentFiles: %s\n", di.pDependentFiles, debugstr_w(di.pDependentFiles));
1328
1329
1330     /* check environment */
1331     env = validate_envW(di.pEnvironment);
1332     if (env == NULL) return FALSE;        /* ERROR_INVALID_ENVIRONMENT */
1333
1334     /* fill the copy-data / get the driverdir */
1335     len = sizeof(apd.src) - sizeof(version3_subdirW) - sizeof(WCHAR);
1336     if (!fpGetPrinterDriverDirectory(NULL, (LPWSTR) env->envname, 1,
1337                                     (LPBYTE) apd.src, len, &len)) {
1338         /* Should never Fail */
1339         return FALSE;
1340     }
1341     memcpy(apd.dst, apd.src, len);
1342     lstrcatW(apd.src, backslashW);
1343     apd.srclen = lstrlenW(apd.src);
1344     lstrcatW(apd.dst, env->versionsubdir);
1345     lstrcatW(apd.dst, backslashW);
1346     apd.dstlen = lstrlenW(apd.dst);
1347     apd.copyflags = dwFileCopyFlags;
1348     apd.lazy = lazy;
1349     CreateDirectoryW(apd.src, NULL);
1350     CreateDirectoryW(apd.dst, NULL);
1351
1352     hroot = open_driver_reg(env->envname);
1353     if (!hroot) {
1354         ERR("Can't create Drivers key\n");
1355         return FALSE;
1356     }
1357
1358     /* Fill the Registry for the Driver */
1359     if ((lres = RegCreateKeyExW(hroot, di.pName, 0, NULL, REG_OPTION_NON_VOLATILE,
1360                                 KEY_WRITE | KEY_QUERY_VALUE, NULL,
1361                                 &hdrv, &disposition)) != ERROR_SUCCESS) {
1362
1363         ERR("can't create driver %s: %u\n", debugstr_w(di.pName), lres);
1364         RegCloseKey(hroot);
1365         SetLastError(lres);
1366         return FALSE;
1367     }
1368     RegCloseKey(hroot);
1369
1370     if (disposition == REG_OPENED_EXISTING_KEY) {
1371         TRACE("driver %s already installed\n", debugstr_w(di.pName));
1372         RegCloseKey(hdrv);
1373         SetLastError(ERROR_PRINTER_DRIVER_ALREADY_INSTALLED);
1374         return FALSE;
1375     }
1376
1377     /* Verified with the Adobe PS Driver, that w2k does not use di.Version */
1378     RegSetValueExW(hdrv, versionW, 0, REG_DWORD, (LPBYTE) &env->driverversion,
1379                    sizeof(DWORD));
1380
1381     RegSetValueExW(hdrv, driverW, 0, REG_SZ, (LPBYTE) di.pDriverPath,
1382                    (lstrlenW(di.pDriverPath)+1)* sizeof(WCHAR));
1383     apd_copyfile(di.pDriverPath, &apd);
1384
1385     RegSetValueExW(hdrv, data_fileW, 0, REG_SZ, (LPBYTE) di.pDataFile,
1386                    (lstrlenW(di.pDataFile)+1)* sizeof(WCHAR));
1387     apd_copyfile(di.pDataFile, &apd);
1388
1389     RegSetValueExW(hdrv, configuration_fileW, 0, REG_SZ, (LPBYTE) di.pConfigFile,
1390                    (lstrlenW(di.pConfigFile)+1)* sizeof(WCHAR));
1391     apd_copyfile(di.pConfigFile, &apd);
1392
1393     /* settings for level 3 */
1394     if (di.pHelpFile)
1395         RegSetValueExW(hdrv, help_fileW, 0, REG_SZ, (LPBYTE) di.pHelpFile,
1396                        (lstrlenW(di.pHelpFile)+1)* sizeof(WCHAR));
1397     else
1398         RegSetValueExW(hdrv, help_fileW, 0, REG_SZ, (LPBYTE)emptyW, sizeof(emptyW));
1399     apd_copyfile(di.pHelpFile, &apd);
1400
1401
1402     ptr = di.pDependentFiles;
1403     if (ptr)
1404         RegSetValueExW(hdrv, dependent_filesW, 0, REG_MULTI_SZ, (LPBYTE) di.pDependentFiles,
1405                        multi_sz_lenW(di.pDependentFiles));
1406     else
1407         RegSetValueExW(hdrv, dependent_filesW, 0, REG_MULTI_SZ, (LPBYTE)emptyW, sizeof(emptyW));
1408     while ((ptr != NULL) && (ptr[0])) {
1409         if (apd_copyfile(ptr, &apd)) {
1410             ptr += lstrlenW(ptr) + 1;
1411         }
1412         else
1413         {
1414             WARN("Failed to copy %s\n", debugstr_w(ptr));
1415             ptr = NULL;
1416         }
1417     }
1418     /* The language-Monitor was already copied by the caller to "%SystemRoot%\system32" */
1419     if (di.pMonitorName)
1420         RegSetValueExW(hdrv, monitorW, 0, REG_SZ, (LPBYTE) di.pMonitorName,
1421                        (lstrlenW(di.pMonitorName)+1)* sizeof(WCHAR));
1422     else
1423         RegSetValueExW(hdrv, monitorW, 0, REG_SZ, (LPBYTE)emptyW, sizeof(emptyW));
1424
1425     if (di.pDefaultDataType)
1426         RegSetValueExW(hdrv, datatypeW, 0, REG_SZ, (LPBYTE) di.pDefaultDataType,
1427                        (lstrlenW(di.pDefaultDataType)+1)* sizeof(WCHAR));
1428     else
1429         RegSetValueExW(hdrv, datatypeW, 0, REG_SZ, (LPBYTE)emptyW, sizeof(emptyW));
1430
1431     /* settings for level 4 */
1432     if (di.pszzPreviousNames)
1433         RegSetValueExW(hdrv, previous_namesW, 0, REG_MULTI_SZ, (LPBYTE) di.pszzPreviousNames,
1434                        multi_sz_lenW(di.pszzPreviousNames));
1435     else
1436         RegSetValueExW(hdrv, previous_namesW, 0, REG_MULTI_SZ, (LPBYTE)emptyW, sizeof(emptyW));
1437
1438     if (level > 5) TRACE("level %u for Driver %s is incomplete\n", level, debugstr_w(di.pName));
1439
1440     RegCloseKey(hdrv);
1441     hui = driver_load(env, di.pConfigFile);
1442     pDrvDriverEvent = (void *)GetProcAddress(hui, "DrvDriverEvent");
1443     if (hui && pDrvDriverEvent) {
1444
1445         /* Support for DrvDriverEvent is optional */
1446         TRACE("DRIVER_EVENT_INITIALIZE for %s (%s)\n", debugstr_w(di.pName), debugstr_w(di.pConfigFile));
1447         /* MSDN: level for DRIVER_INFO is 1 to 3 */
1448         res = pDrvDriverEvent(DRIVER_EVENT_INITIALIZE, 3, (LPBYTE) &di, 0);
1449         TRACE("got %d from DRIVER_EVENT_INITIALIZE\n", res);
1450     }
1451     FreeLibrary(hui);
1452
1453     TRACE("=> TRUE with %u\n", GetLastError());
1454     return TRUE;
1455
1456 }
1457
1458 /******************************************************************************
1459  * fpAddMonitor [exported through PRINTPROVIDOR]
1460  *
1461  * Install a Printmonitor
1462  *
1463  * PARAMS
1464  *  pName       [I] Servername or NULL (local Computer)
1465  *  Level       [I] Structure-Level (Must be 2)
1466  *  pMonitors   [I] PTR to MONITOR_INFO_2
1467  *
1468  * RETURNS
1469  *  Success: TRUE
1470  *  Failure: FALSE
1471  *
1472  * NOTES
1473  *  All Files for the Monitor must already be copied to %winsysdir% ("%SystemRoot%\system32")
1474  *
1475  */
1476 static BOOL WINAPI fpAddMonitor(LPWSTR pName, DWORD Level, LPBYTE pMonitors)
1477 {
1478     monitor_t * pm = NULL;
1479     LPMONITOR_INFO_2W mi2w;
1480     HKEY    hroot = NULL;
1481     HKEY    hentry = NULL;
1482     DWORD   disposition;
1483     BOOL    res = FALSE;
1484
1485     mi2w = (LPMONITOR_INFO_2W) pMonitors;
1486     TRACE("(%s, %d, %p): %s %s %s\n", debugstr_w(pName), Level, pMonitors,
1487             debugstr_w(mi2w ? mi2w->pName : NULL),
1488             debugstr_w(mi2w ? mi2w->pEnvironment : NULL),
1489             debugstr_w(mi2w ? mi2w->pDLLName : NULL));
1490
1491     if (copy_servername_from_name(pName, NULL)) {
1492         FIXME("server %s not supported\n", debugstr_w(pName));
1493         SetLastError(ERROR_ACCESS_DENIED);
1494         return FALSE;
1495     }
1496
1497     if (!mi2w->pName || (! mi2w->pName[0])) {
1498         WARN("pName not valid : %s\n", debugstr_w(mi2w->pName));
1499         SetLastError(ERROR_INVALID_PARAMETER);
1500         return FALSE;
1501     }
1502     if (!mi2w->pEnvironment || lstrcmpW(mi2w->pEnvironment, x86_envnameW)) {
1503         WARN("Environment %s requested (we support only %s)\n",
1504                 debugstr_w(mi2w->pEnvironment), debugstr_w(x86_envnameW));
1505         SetLastError(ERROR_INVALID_ENVIRONMENT);
1506         return FALSE;
1507     }
1508
1509     if (!mi2w->pDLLName || (! mi2w->pDLLName[0])) {
1510         WARN("pDLLName not valid : %s\n", debugstr_w(mi2w->pDLLName));
1511         SetLastError(ERROR_INVALID_PARAMETER);
1512         return FALSE;
1513     }
1514
1515     /* Load and initialize the monitor. SetLastError() is called on failure */
1516     if ((pm = monitor_load(mi2w->pName, mi2w->pDLLName)) == NULL) {
1517         return FALSE;
1518     }
1519     monitor_unload(pm);
1520
1521     if (RegCreateKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) != ERROR_SUCCESS) {
1522         ERR("unable to create key %s\n", debugstr_w(monitorsW));
1523         return FALSE;
1524     }
1525
1526     if (RegCreateKeyExW(hroot, mi2w->pName, 0, NULL, REG_OPTION_NON_VOLATILE,
1527                         KEY_WRITE | KEY_QUERY_VALUE, NULL, &hentry,
1528                         &disposition) == ERROR_SUCCESS) {
1529
1530         /* Some installers set options for the port before calling AddMonitor.
1531            We query the "Driver" entry to verify that the monitor is installed,
1532            before we return an error.
1533            When a user installs two print monitors at the same time with the
1534            same name, a race condition is possible but silently ignored. */
1535
1536         DWORD   namesize = 0;
1537
1538         if ((disposition == REG_OPENED_EXISTING_KEY) &&
1539             (RegQueryValueExW(hentry, driverW, NULL, NULL, NULL,
1540                               &namesize) == ERROR_SUCCESS)) {
1541             TRACE("monitor %s already exists\n", debugstr_w(mi2w->pName));
1542             /* 9x use ERROR_ALREADY_EXISTS */
1543             SetLastError(ERROR_PRINT_MONITOR_ALREADY_INSTALLED);
1544         }
1545         else
1546         {
1547             INT len;
1548             len = (lstrlenW(mi2w->pDLLName) +1) * sizeof(WCHAR);
1549             res = (RegSetValueExW(hentry, driverW, 0, REG_SZ,
1550                     (LPBYTE) mi2w->pDLLName, len) == ERROR_SUCCESS);
1551         }
1552         RegCloseKey(hentry);
1553     }
1554
1555     RegCloseKey(hroot);
1556     return (res);
1557 }
1558
1559 /******************************************************************************
1560  * fpAddPort [exported through PRINTPROVIDOR]
1561  *
1562  * Add a Port for a specific Monitor
1563  *
1564  * PARAMS
1565  *  pName        [I] Servername or NULL (local Computer)
1566  *  hWnd         [I] Handle to parent Window for the Dialog-Box
1567  *  pMonitorName [I] Name of the Monitor that manage the Port
1568  *
1569  * RETURNS
1570  *  Success: TRUE
1571  *  Failure: FALSE
1572  *
1573  */
1574 static BOOL WINAPI fpAddPort(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)
1575 {
1576     monitor_t * pm;
1577     monitor_t * pui;
1578     LONG        lres;
1579     DWORD       res;
1580
1581     TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pMonitorName));
1582
1583     lres = copy_servername_from_name(pName, NULL);
1584     if (lres) {
1585         FIXME("server %s not supported\n", debugstr_w(pName));
1586         SetLastError(ERROR_INVALID_PARAMETER);
1587         return FALSE;
1588     }
1589
1590     /* an empty Monitorname is Invalid */
1591     if (!pMonitorName[0]) {
1592         SetLastError(ERROR_NOT_SUPPORTED);
1593         return FALSE;
1594     }
1595
1596     pm = monitor_load(pMonitorName, NULL);
1597     if (pm && pm->monitor && pm->monitor->pfnAddPort) {
1598         res = pm->monitor->pfnAddPort(pName, hWnd, pMonitorName);
1599         TRACE("got %d with %u (%s)\n", res, GetLastError(), debugstr_w(pm->dllname));
1600     }
1601     else
1602     {
1603         pui = monitor_loadui(pm);
1604         if (pui && pui->monitorUI && pui->monitorUI->pfnAddPortUI) {
1605             res = pui->monitorUI->pfnAddPortUI(pName, hWnd, pMonitorName, NULL);
1606             TRACE("got %d with %u (%s)\n", res, GetLastError(), debugstr_w(pui->dllname));
1607         }
1608         else
1609         {
1610             FIXME("not implemented for %s (monitor %p: %s / monitorui %p: %s)\n",
1611                     debugstr_w(pMonitorName), pm, debugstr_w(pm ? pm->dllname : NULL),
1612                     pui, debugstr_w(pui ? pui->dllname : NULL));
1613
1614             SetLastError(ERROR_NOT_SUPPORTED);
1615             res = FALSE;
1616         }
1617         monitor_unload(pui);
1618     }
1619     monitor_unload(pm);
1620
1621     TRACE("returning %d with %u\n", res, GetLastError());
1622     return res;
1623 }
1624
1625 /******************************************************************************
1626  * fpAddPortEx [exported through PRINTPROVIDOR]
1627  *
1628  * Add a Port for a specific Monitor, without presenting a user interface
1629  *
1630  * PARAMS
1631  *  pName         [I] Servername or NULL (local Computer)
1632  *  level         [I] Structure-Level (1 or 2) for pBuffer
1633  *  pBuffer       [I] PTR to: PORT_INFO_1 or PORT_INFO_2
1634  *  pMonitorName  [I] Name of the Monitor that manage the Port
1635  *
1636  * RETURNS
1637  *  Success: TRUE
1638  *  Failure: FALSE
1639  *
1640  */
1641 static BOOL WINAPI fpAddPortEx(LPWSTR pName, DWORD level, LPBYTE pBuffer, LPWSTR pMonitorName)
1642 {
1643     PORT_INFO_2W * pi2;
1644     monitor_t * pm;
1645     DWORD lres;
1646     DWORD res;
1647
1648     pi2 = (PORT_INFO_2W *) pBuffer;
1649
1650     TRACE("(%s, %d, %p, %s): %s %s %s\n", debugstr_w(pName), level, pBuffer,
1651             debugstr_w(pMonitorName), debugstr_w(pi2 ? pi2->pPortName : NULL),
1652             debugstr_w(((level > 1) && pi2) ? pi2->pMonitorName : NULL),
1653             debugstr_w(((level > 1) && pi2) ? pi2->pDescription : NULL));
1654
1655     lres = copy_servername_from_name(pName, NULL);
1656     if (lres) {
1657         FIXME("server %s not supported\n", debugstr_w(pName));
1658         SetLastError(ERROR_INVALID_PARAMETER);
1659         return FALSE;
1660     }
1661
1662     if ((level < 1) || (level > 2)) {
1663         SetLastError(ERROR_INVALID_LEVEL);
1664         return FALSE;
1665     }
1666
1667     if ((!pi2) || (!pMonitorName) || (!pMonitorName[0])) {
1668         SetLastError(ERROR_INVALID_PARAMETER);
1669         return FALSE;
1670     }
1671
1672     /* load the Monitor */
1673     pm = monitor_load(pMonitorName, NULL);
1674     if (pm && pm->monitor && pm->monitor->pfnAddPortEx) {
1675         res = pm->monitor->pfnAddPortEx(pName, level, pBuffer, pMonitorName);
1676         TRACE("got %d with %u (%s)\n", res, GetLastError(), debugstr_w(pm->dllname));
1677     }
1678     else
1679     {
1680         FIXME("not implemented for %s (monitor %p: %s)\n",
1681             debugstr_w(pMonitorName), pm, pm ? debugstr_w(pm->dllname) : NULL);
1682             SetLastError(ERROR_INVALID_PARAMETER);
1683             res = FALSE;
1684     }
1685     monitor_unload(pm);
1686     return res;
1687 }
1688
1689 /******************************************************************************
1690  * fpAddPrinterDriverEx [exported through PRINTPROVIDOR]
1691  *
1692  * Install a Printer Driver with the Option to upgrade / downgrade the Files
1693  *
1694  * PARAMS
1695  *  pName           [I] Servername or NULL (local Computer)
1696  *  level           [I] Level for the supplied DRIVER_INFO_*W struct
1697  *  pDriverInfo     [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
1698  *  dwFileCopyFlags [I] How to Copy / Upgrade / Downgrade the needed Files
1699  *
1700  * RESULTS
1701  *  Success: TRUE
1702  *  Failure: FALSE
1703  *
1704  */
1705 static BOOL WINAPI fpAddPrinterDriverEx(LPWSTR pName, DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
1706 {
1707     LONG lres;
1708
1709     TRACE("(%s, %d, %p, 0x%x)\n", debugstr_w(pName), level, pDriverInfo, dwFileCopyFlags);
1710     lres = copy_servername_from_name(pName, NULL);
1711     if (lres) {
1712         FIXME("server %s not supported\n", debugstr_w(pName));
1713         SetLastError(ERROR_ACCESS_DENIED);
1714         return FALSE;
1715     }
1716
1717     if ((dwFileCopyFlags & ~APD_COPY_FROM_DIRECTORY) != APD_COPY_ALL_FILES) {
1718         TRACE("Flags 0x%x ignored (using APD_COPY_ALL_FILES)\n", dwFileCopyFlags & ~APD_COPY_FROM_DIRECTORY);
1719     }
1720
1721     return myAddPrinterDriverEx(level, pDriverInfo, dwFileCopyFlags, TRUE);
1722 }
1723
1724 /******************************************************************************
1725  * fpClosePrinter [exported through PRINTPROVIDOR]
1726  *
1727  * Close a printer handle and free associated resources
1728  *
1729  * PARAMS
1730  *  hPrinter [I] Printerhandle to close
1731  *
1732  * RESULTS
1733  *  Success: TRUE
1734  *  Failure: FALSE
1735  *
1736  */
1737 static BOOL WINAPI fpClosePrinter(HANDLE hPrinter)
1738 {
1739     printer_t *printer = (printer_t *) hPrinter;
1740
1741     TRACE("(%p)\n", hPrinter);
1742
1743     if (printer) {
1744         printer_free(printer);
1745         return TRUE;
1746     }
1747     return FALSE;
1748 }
1749
1750 /******************************************************************************
1751  * fpConfigurePort [exported through PRINTPROVIDOR]
1752  *
1753  * Display the Configuration-Dialog for a specific Port
1754  *
1755  * PARAMS
1756  *  pName     [I] Servername or NULL (local Computer)
1757  *  hWnd      [I] Handle to parent Window for the Dialog-Box
1758  *  pPortName [I] Name of the Port, that should be configured
1759  *
1760  * RETURNS
1761  *  Success: TRUE
1762  *  Failure: FALSE
1763  *
1764  */
1765 static BOOL WINAPI fpConfigurePort(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
1766 {
1767     monitor_t * pm;
1768     monitor_t * pui;
1769     LONG        lres;
1770     DWORD       res;
1771
1772     TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
1773
1774     lres = copy_servername_from_name(pName, NULL);
1775     if (lres) {
1776         FIXME("server %s not supported\n", debugstr_w(pName));
1777         SetLastError(ERROR_INVALID_NAME);
1778         return FALSE;
1779     }
1780
1781     /* an empty Portname is Invalid, but can popup a Dialog */
1782     if (!pPortName[0]) {
1783         SetLastError(ERROR_NOT_SUPPORTED);
1784         return FALSE;
1785     }
1786
1787     pm = monitor_load_by_port(pPortName);
1788     if (pm && pm->monitor && pm->monitor->pfnConfigurePort) {
1789         TRACE("use %s for %s (monitor %p: %s)\n", debugstr_w(pm->name),
1790                 debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
1791         res = pm->monitor->pfnConfigurePort(pName, hWnd, pPortName);
1792         TRACE("got %d with %u\n", res, GetLastError());
1793     }
1794     else
1795     {
1796         pui = monitor_loadui(pm);
1797         if (pui && pui->monitorUI && pui->monitorUI->pfnConfigurePortUI) {
1798             TRACE("use %s for %s (monitorui %p: %s)\n", debugstr_w(pui->name),
1799                         debugstr_w(pPortName), pui, debugstr_w(pui->dllname));
1800             res = pui->monitorUI->pfnConfigurePortUI(pName, hWnd, pPortName);
1801             TRACE("got %d with %u\n", res, GetLastError());
1802         }
1803         else
1804         {
1805             FIXME("not implemented for %s (monitor %p: %s / monitorui %p: %s)\n",
1806                     debugstr_w(pPortName), pm, debugstr_w(pm ? pm->dllname : NULL),
1807                     pui, debugstr_w(pui ? pui->dllname : NULL));
1808
1809             SetLastError(ERROR_NOT_SUPPORTED);
1810             res = FALSE;
1811         }
1812         monitor_unload(pui);
1813     }
1814     monitor_unload(pm);
1815
1816     TRACE("returning %d with %u\n", res, GetLastError());
1817     return res;
1818 }
1819
1820 /******************************************************************
1821  * fpDeleteMonitor [exported through PRINTPROVIDOR]
1822  *
1823  * Delete a specific Printmonitor from a Printing-Environment
1824  *
1825  * PARAMS
1826  *  pName        [I] Servername or NULL (local Computer)
1827  *  pEnvironment [I] Printing-Environment of the Monitor or NULL (Default)
1828  *  pMonitorName [I] Name of the Monitor, that should be deleted
1829  *
1830  * RETURNS
1831  *  Success: TRUE
1832  *  Failure: FALSE
1833  *
1834  * NOTES
1835  *  pEnvironment is ignored in Windows for the local Computer.
1836  *
1837  */
1838
1839 static BOOL WINAPI fpDeleteMonitor(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pMonitorName)
1840 {
1841     HKEY    hroot = NULL;
1842     LONG    lres;
1843
1844     TRACE("(%s, %s, %s)\n",debugstr_w(pName),debugstr_w(pEnvironment),
1845            debugstr_w(pMonitorName));
1846
1847     lres = copy_servername_from_name(pName, NULL);
1848     if (lres) {
1849         FIXME("server %s not supported\n", debugstr_w(pName));
1850         SetLastError(ERROR_INVALID_NAME);
1851         return FALSE;
1852     }
1853
1854     /*  pEnvironment is ignored in Windows for the local Computer */
1855     if (!pMonitorName || !pMonitorName[0]) {
1856         TRACE("pMonitorName %s is invalid\n", debugstr_w(pMonitorName));
1857         SetLastError(ERROR_INVALID_PARAMETER);
1858         return FALSE;
1859     }
1860
1861     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) != ERROR_SUCCESS) {
1862         ERR("unable to create key %s\n", debugstr_w(monitorsW));
1863         return FALSE;
1864     }
1865
1866     if(RegDeleteTreeW(hroot, pMonitorName) == ERROR_SUCCESS) {
1867         TRACE("%s deleted\n", debugstr_w(pMonitorName));
1868         RegCloseKey(hroot);
1869         return TRUE;
1870     }
1871
1872     TRACE("%s does not exist\n", debugstr_w(pMonitorName));
1873     RegCloseKey(hroot);
1874
1875     /* NT: ERROR_UNKNOWN_PRINT_MONITOR (3000), 9x: ERROR_INVALID_PARAMETER (87) */
1876     SetLastError(ERROR_UNKNOWN_PRINT_MONITOR);
1877     return FALSE;
1878 }
1879
1880 /*****************************************************************************
1881  * fpDeletePort [exported through PRINTPROVIDOR]
1882  *
1883  * Delete a specific Port
1884  *
1885  * PARAMS
1886  *  pName     [I] Servername or NULL (local Computer)
1887  *  hWnd      [I] Handle to parent Window for the Dialog-Box
1888  *  pPortName [I] Name of the Port, that should be deleted
1889  *
1890  * RETURNS
1891  *  Success: TRUE
1892  *  Failure: FALSE
1893  *
1894  */
1895 static BOOL WINAPI fpDeletePort(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
1896 {
1897     monitor_t * pm;
1898     monitor_t * pui;
1899     LONG        lres;
1900     DWORD       res;
1901
1902     TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
1903
1904     lres = copy_servername_from_name(pName, NULL);
1905     if (lres) {
1906         FIXME("server %s not supported\n", debugstr_w(pName));
1907         SetLastError(ERROR_INVALID_NAME);
1908         return FALSE;
1909     }
1910
1911     /* an empty Portname is Invalid */
1912     if (!pPortName[0]) {
1913         SetLastError(ERROR_NOT_SUPPORTED);
1914         return FALSE;
1915     }
1916
1917     pm = monitor_load_by_port(pPortName);
1918     if (pm && pm->monitor && pm->monitor->pfnDeletePort) {
1919         TRACE("use %s for %s (monitor %p: %s)\n", debugstr_w(pm->name),
1920                 debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
1921         res = pm->monitor->pfnDeletePort(pName, hWnd, pPortName);
1922         TRACE("got %d with %u\n", res, GetLastError());
1923     }
1924     else
1925     {
1926         pui = monitor_loadui(pm);
1927         if (pui && pui->monitorUI && pui->monitorUI->pfnDeletePortUI) {
1928             TRACE("use %s for %s (monitorui %p: %s)\n", debugstr_w(pui->name),
1929                         debugstr_w(pPortName), pui, debugstr_w(pui->dllname));
1930             res = pui->monitorUI->pfnDeletePortUI(pName, hWnd, pPortName);
1931             TRACE("got %d with %u\n", res, GetLastError());
1932         }
1933         else
1934         {
1935             FIXME("not implemented for %s (monitor %p: %s / monitorui %p: %s)\n",
1936                     debugstr_w(pPortName), pm, debugstr_w(pm ? pm->dllname : NULL),
1937                     pui, debugstr_w(pui ? pui->dllname : NULL));
1938
1939             SetLastError(ERROR_NOT_SUPPORTED);
1940             res = FALSE;
1941         }
1942         monitor_unload(pui);
1943     }
1944     monitor_unload(pm);
1945
1946     TRACE("returning %d with %u\n", res, GetLastError());
1947     return res;
1948 }
1949
1950 /*****************************************************************************
1951  * fpEnumMonitors [exported through PRINTPROVIDOR]
1952  *
1953  * Enumerate available Port-Monitors
1954  *
1955  * PARAMS
1956  *  pName      [I] Servername or NULL (local Computer)
1957  *  Level      [I] Structure-Level (1:Win9x+NT or 2:NT only)
1958  *  pMonitors  [O] PTR to Buffer that receives the Result
1959  *  cbBuf      [I] Size of Buffer at pMonitors
1960  *  pcbNeeded  [O] PTR to DWORD that receives the size in Bytes used / required for pMonitors
1961  *  pcReturned [O] PTR to DWORD that receives the number of Monitors in pMonitors
1962  *
1963  * RETURNS
1964  *  Success: TRUE
1965  *  Failure: FALSE and in pcbNeeded the Bytes required for pMonitors, if cbBuf is too small
1966  *
1967  * NOTES
1968  *  Windows reads the Registry once and cache the Results.
1969  *
1970  */
1971 static BOOL WINAPI fpEnumMonitors(LPWSTR pName, DWORD Level, LPBYTE pMonitors, DWORD cbBuf,
1972                                   LPDWORD pcbNeeded, LPDWORD pcReturned)
1973 {
1974     DWORD   numentries = 0;
1975     DWORD   needed = 0;
1976     LONG    lres;
1977     BOOL    res = FALSE;
1978
1979     TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pMonitors,
1980           cbBuf, pcbNeeded, pcReturned);
1981
1982     lres = copy_servername_from_name(pName, NULL);
1983     if (lres) {
1984         FIXME("server %s not supported\n", debugstr_w(pName));
1985         SetLastError(ERROR_INVALID_NAME);
1986         goto em_cleanup;
1987     }
1988
1989     if (!Level || (Level > 2)) {
1990         WARN("level (%d) is ignored in win9x\n", Level);
1991         SetLastError(ERROR_INVALID_LEVEL);
1992         return FALSE;
1993     }
1994
1995     /* Scan all Monitor-Keys */
1996     numentries = 0;
1997     needed = get_local_monitors(Level, NULL, 0, &numentries);
1998
1999     /* we calculated the needed buffersize. now do more error-checks */
2000     if (cbBuf < needed) {
2001         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2002         goto em_cleanup;
2003     }
2004
2005     /* fill the Buffer with the Monitor-Keys */
2006     needed = get_local_monitors(Level, pMonitors, cbBuf, &numentries);
2007     res = TRUE;
2008
2009 em_cleanup:
2010     if (pcbNeeded)  *pcbNeeded = needed;
2011     if (pcReturned) *pcReturned = numentries;
2012
2013     TRACE("returning %d with %d (%d byte for %d entries)\n",
2014             res, GetLastError(), needed, numentries);
2015
2016     return (res);
2017 }
2018
2019 /******************************************************************************
2020  * fpEnumPorts [exported through PRINTPROVIDOR]
2021  *
2022  * Enumerate available Ports
2023  *
2024  * PARAMS
2025  *  pName      [I] Servername or NULL (local Computer)
2026  *  Level      [I] Structure-Level (1 or 2)
2027  *  pPorts     [O] PTR to Buffer that receives the Result
2028  *  cbBuf      [I] Size of Buffer at pPorts
2029  *  pcbNeeded  [O] PTR to DWORD that receives the size in Bytes used / required for pPorts
2030  *  pcReturned [O] PTR to DWORD that receives the number of Ports in pPorts
2031  *
2032  * RETURNS
2033  *  Success: TRUE
2034  *  Failure: FALSE and in pcbNeeded the Bytes required for pPorts, if cbBuf is too small
2035  *
2036  */
2037 static BOOL WINAPI fpEnumPorts(LPWSTR pName, DWORD Level, LPBYTE pPorts, DWORD cbBuf,
2038                                LPDWORD pcbNeeded, LPDWORD pcReturned)
2039 {
2040     DWORD   needed = 0;
2041     DWORD   numentries = 0;
2042     LONG    lres;
2043     BOOL    res = FALSE;
2044
2045     TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pPorts,
2046           cbBuf, pcbNeeded, pcReturned);
2047
2048     lres = copy_servername_from_name(pName, NULL);
2049     if (lres) {
2050         FIXME("server %s not supported\n", debugstr_w(pName));
2051         SetLastError(ERROR_INVALID_NAME);
2052         goto emP_cleanup;
2053     }
2054
2055     if (!Level || (Level > 2)) {
2056         SetLastError(ERROR_INVALID_LEVEL);
2057         goto emP_cleanup;
2058     }
2059
2060     if (!pcbNeeded || (!pPorts && (cbBuf > 0))) {
2061         SetLastError(RPC_X_NULL_REF_POINTER);
2062         goto emP_cleanup;
2063     }
2064
2065     EnterCriticalSection(&monitor_handles_cs);
2066     monitor_loadall();
2067
2068     /* Scan all local Ports */
2069     numentries = 0;
2070     needed = get_ports_from_all_monitors(Level, NULL, 0, &numentries);
2071
2072     /* we calculated the needed buffersize. now do the error-checks */
2073     if (cbBuf < needed) {
2074         monitor_unloadall();
2075         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2076         goto emP_cleanup_cs;
2077     }
2078     else if (!pPorts || !pcReturned) {
2079         monitor_unloadall();
2080         SetLastError(RPC_X_NULL_REF_POINTER);
2081         goto emP_cleanup_cs;
2082     }
2083
2084     /* Fill the Buffer */
2085     needed = get_ports_from_all_monitors(Level, pPorts, cbBuf, &numentries);
2086     res = TRUE;
2087     monitor_unloadall();
2088
2089 emP_cleanup_cs:
2090     LeaveCriticalSection(&monitor_handles_cs);
2091
2092 emP_cleanup:
2093     if (pcbNeeded)  *pcbNeeded = needed;
2094     if (pcReturned) *pcReturned = (res) ? numentries : 0;
2095
2096     TRACE("returning %d with %d (%d byte for %d of %d entries)\n",
2097           (res), GetLastError(), needed, (res) ? numentries : 0, numentries);
2098
2099     return (res);
2100 }
2101
2102 /*****************************************************************************
2103  * fpEnumPrintProcessors [exported through PRINTPROVIDOR]
2104  *
2105  * Enumerate available Print Processors
2106  *
2107  * PARAMS
2108  *  pName        [I] Servername or NULL (local Computer)
2109  *  pEnvironment [I] Printing-Environment or NULL (Default)
2110  *  Level        [I] Structure-Level (Only 1 is allowed)
2111  *  pPPInfo      [O] PTR to Buffer that receives the Result
2112  *  cbBuf        [I] Size of Buffer at pMonitors
2113  *  pcbNeeded    [O] PTR to DWORD that receives the size in Bytes used / required for pPPInfo
2114  *  pcReturned   [O] PTR to DWORD that receives the number of Print Processors in pPPInfo
2115  *
2116  * RETURNS
2117  *  Success: TRUE
2118  *  Failure: FALSE and in pcbNeeded the Bytes required for pPPInfo, if cbBuf is too small
2119  *
2120  */
2121 static BOOL WINAPI fpEnumPrintProcessors(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
2122                             LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
2123 {
2124     const printenv_t * env;
2125     LPWSTR  regpathW = NULL;
2126     DWORD   numentries = 0;
2127     DWORD   needed = 0;
2128     LONG    lres;
2129     BOOL    res = FALSE;
2130
2131     TRACE("(%s, %s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), debugstr_w(pEnvironment),
2132                                 Level, pPPInfo, cbBuf, pcbNeeded, pcReturned);
2133
2134     lres = copy_servername_from_name(pName, NULL);
2135     if (lres) {
2136         FIXME("server %s not supported\n", debugstr_w(pName));
2137         SetLastError(ERROR_INVALID_NAME);
2138         goto epp_cleanup;
2139     }
2140
2141     if (Level != 1) {
2142         SetLastError(ERROR_INVALID_LEVEL);
2143         goto epp_cleanup;
2144     }
2145
2146     env = validate_envW(pEnvironment);
2147     if (!env)
2148         goto epp_cleanup;   /* ERROR_INVALID_ENVIRONMENT */
2149
2150     regpathW = heap_alloc(sizeof(fmt_printprocessorsW) +
2151                             (lstrlenW(env->envname) * sizeof(WCHAR)));
2152
2153     if (!regpathW)
2154         goto epp_cleanup;
2155
2156     wsprintfW(regpathW, fmt_printprocessorsW, env->envname);
2157
2158     /* Scan all Printprocessor-Keys */
2159     numentries = 0;
2160     needed = get_local_printprocessors(regpathW, NULL, 0, &numentries);
2161
2162     /* we calculated the needed buffersize. now do more error-checks */
2163     if (cbBuf < needed) {
2164         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2165         goto epp_cleanup;
2166     }
2167
2168     /* fill the Buffer with the Printprocessor Infos */
2169     needed = get_local_printprocessors(regpathW, pPPInfo, cbBuf, &numentries);
2170     res = TRUE;
2171
2172 epp_cleanup:
2173     heap_free(regpathW);
2174     if (pcbNeeded)  *pcbNeeded = needed;
2175     if (pcReturned) *pcReturned = numentries;
2176
2177     TRACE("returning %d with %d (%d byte for %d entries)\n",
2178             res, GetLastError(), needed, numentries);
2179
2180     return (res);
2181 }
2182
2183 /******************************************************************************
2184  * fpGetPrintProcessorDirectory [exported through PRINTPROVIDOR]
2185  *
2186  * Return the PATH for the Print-Processors
2187  *
2188  * PARAMS
2189  *  pName        [I] Servername or NULL (this computer)
2190  *  pEnvironment [I] Printing-Environment or NULL (Default)
2191  *  level        [I] Structure-Level (must be 1)
2192  *  pPPInfo      [O] PTR to Buffer that receives the Result
2193  *  cbBuf        [I] Size of Buffer at pPPInfo
2194  *  pcbNeeded    [O] PTR to DWORD that receives the size in Bytes used / required for pPPInfo
2195  *
2196  * RETURNS
2197  *  Success: TRUE
2198  *  Failure: FALSE and in pcbNeeded the Bytes required for pPPInfo, if cbBuf is too small
2199  *
2200  *  Native Values returned in pPPInfo on Success for this computer:
2201  *| NT(Windows x64):    "%winsysdir%\\spool\\PRTPROCS\\x64"
2202  *| NT(Windows NT x86): "%winsysdir%\\spool\\PRTPROCS\\w32x86"
2203  *| NT(Windows 4.0):    "%winsysdir%\\spool\\PRTPROCS\\win40"
2204  *
2205  *  "%winsysdir%" is the Value from GetSystemDirectoryW()
2206  *
2207  */
2208 static BOOL WINAPI fpGetPrintProcessorDirectory(LPWSTR pName, LPWSTR pEnvironment, DWORD level,
2209                                                 LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded)
2210 {
2211     const printenv_t * env;
2212     DWORD needed;
2213     LONG  lres;
2214
2215     TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName), debugstr_w(pEnvironment),
2216                                         level, pPPInfo, cbBuf, pcbNeeded);
2217
2218     *pcbNeeded = 0;
2219     lres = copy_servername_from_name(pName, NULL);
2220     if (lres) {
2221         FIXME("server %s not supported\n", debugstr_w(pName));
2222         SetLastError(RPC_S_SERVER_UNAVAILABLE);
2223         return FALSE;
2224     }
2225
2226     env = validate_envW(pEnvironment);
2227     if (!env)
2228         return FALSE;   /* ERROR_INVALID_ENVIRONMENT */
2229
2230     /* GetSystemDirectoryW returns number of WCHAR including the '\0' */
2231     needed = GetSystemDirectoryW(NULL, 0);
2232     /* add the Size for the Subdirectories */
2233     needed += lstrlenW(spoolprtprocsW);
2234     needed += lstrlenW(env->subdir);
2235     needed *= sizeof(WCHAR);  /* return-value is size in Bytes */
2236
2237     *pcbNeeded = needed;
2238
2239     if (needed > cbBuf) {
2240         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2241         return FALSE;
2242     }
2243
2244     GetSystemDirectoryW((LPWSTR) pPPInfo, cbBuf/sizeof(WCHAR));
2245     /* add the Subdirectories */
2246     lstrcatW((LPWSTR) pPPInfo, spoolprtprocsW);
2247     lstrcatW((LPWSTR) pPPInfo, env->subdir);
2248     TRACE("==> %s\n", debugstr_w((LPWSTR) pPPInfo));
2249     return TRUE;
2250 }
2251
2252 /******************************************************************************
2253  * fpOpenPrinter [exported through PRINTPROVIDOR]
2254  *
2255  * Open a Printer / Printserver or a Printer-Object
2256  *
2257  * PARAMS
2258  *  lpPrinterName [I] Name of Printserver, Printer, or Printer-Object
2259  *  pPrinter      [O] The resulting Handle is stored here
2260  *  pDefaults     [I] PTR to Default Printer Settings or NULL
2261  *
2262  * RETURNS
2263  *  Success: TRUE
2264  *  Failure: FALSE
2265  *
2266  * NOTES
2267  *  lpPrinterName is one of:
2268  *|  Printserver (NT only): "Servername" or NULL for the local Printserver
2269  *|  Printer: "PrinterName"
2270  *|  Printer-Object: "PrinterName,Job xxx"
2271  *|  XcvMonitor: "Servername,XcvMonitor MonitorName"
2272  *|  XcvPort: "Servername,XcvPort PortName"
2273  *
2274  *
2275  */
2276 static BOOL WINAPI fpOpenPrinter(LPWSTR lpPrinterName, HANDLE *pPrinter,
2277                                  LPPRINTER_DEFAULTSW pDefaults)
2278 {
2279
2280     TRACE("(%s, %p, %p)\n", debugstr_w(lpPrinterName), pPrinter, pDefaults);
2281
2282     *pPrinter = printer_alloc_handle(lpPrinterName, pDefaults);
2283
2284     return (*pPrinter != 0);
2285 }
2286
2287 /******************************************************************************
2288  * fpXcvData [exported through PRINTPROVIDOR]
2289  *
2290  * Execute commands in the Printmonitor DLL
2291  *
2292  * PARAMS
2293  *  hXcv            [i] Handle from fpOpenPrinter (with XcvMonitor or XcvPort)
2294  *  pszDataName     [i] Name of the command to execute
2295  *  pInputData      [i] Buffer for extra Input Data (needed only for some commands)
2296  *  cbInputData     [i] Size in Bytes of Buffer at pInputData
2297  *  pOutputData     [o] Buffer to receive additional Data (needed only for some commands)
2298  *  cbOutputData    [i] Size in Bytes of Buffer at pOutputData
2299  *  pcbOutputNeeded [o] PTR to receive the minimal Size in Bytes of the Buffer at pOutputData
2300  *  pdwStatus       [o] PTR to receive the win32 error code from the Printmonitor DLL
2301  *
2302  * RETURNS
2303  *  Success: TRUE
2304  *  Failure: FALSE
2305  *
2306  * NOTES
2307  *  Returning "TRUE" does mean, that the Printmonitor DLL was called successful.
2308  *  The execution of the command can still fail (check pdwStatus for ERROR_SUCCESS).
2309  *
2310  *  Minimal List of commands, that a Printmonitor DLL should support:
2311  *
2312  *| "MonitorUI" : Return the Name of the Userinterface-DLL as WSTR in pOutputData
2313  *| "AddPort"   : Add a Port
2314  *| "DeletePort": Delete a Port
2315  *
2316  *  Many Printmonitors support additional commands. Examples for localspl.dll:
2317  *  "GetDefaultCommConfig", "SetDefaultCommConfig",
2318  *  "GetTransmissionRetryTimeout", "ConfigureLPTPortCommandOK"
2319  *
2320  */
2321 static BOOL WINAPI fpXcvData(HANDLE hXcv, LPCWSTR pszDataName, PBYTE pInputData,
2322                     DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData,
2323                     PDWORD pcbOutputNeeded, PDWORD pdwStatus)
2324 {
2325     printer_t *printer = (printer_t * ) hXcv;
2326
2327     TRACE("(%p, %s, %p, %d, %p, %d, %p, %p)\n", hXcv, debugstr_w(pszDataName),
2328           pInputData, cbInputData, pOutputData,
2329           cbOutputData, pcbOutputNeeded, pdwStatus);
2330
2331     if (!printer || (!printer->hXcv)) {
2332         SetLastError(ERROR_INVALID_HANDLE);
2333         return FALSE;
2334     }
2335
2336     if (!pcbOutputNeeded) {
2337         SetLastError(ERROR_INVALID_PARAMETER);
2338         return FALSE;
2339     }
2340
2341     if (!pszDataName || !pdwStatus || (!pOutputData && (cbOutputData > 0))) {
2342         SetLastError(RPC_X_NULL_REF_POINTER);
2343         return FALSE;
2344     }
2345
2346     *pcbOutputNeeded = 0;
2347
2348     *pdwStatus = printer->pm->monitor->pfnXcvDataPort(printer->hXcv, pszDataName,
2349             pInputData, cbInputData, pOutputData, cbOutputData, pcbOutputNeeded);
2350
2351     return TRUE;
2352 }
2353
2354 /*****************************************************
2355  *  setup_provider [internal]
2356  */
2357 void setup_provider(void)
2358 {
2359     static const PRINTPROVIDOR backend = {
2360         fpOpenPrinter,
2361         NULL,   /* fpSetJob */
2362         NULL,   /* fpGetJob */
2363         NULL,   /* fpEnumJobs */
2364         NULL,   /* fpAddPrinter */
2365         NULL,   /* fpDeletePrinter */
2366         NULL,   /* fpSetPrinter */
2367         NULL,   /* fpGetPrinter */
2368         NULL,   /* fpEnumPrinters */
2369         NULL,   /* fpAddPrinterDriver */
2370         NULL,   /* fpEnumPrinterDrivers */
2371         NULL,   /* fpGetPrinterDriver */
2372         fpGetPrinterDriverDirectory,
2373         NULL,   /* fpDeletePrinterDriver */
2374         NULL,   /* fpAddPrintProcessor */
2375         fpEnumPrintProcessors,
2376         fpGetPrintProcessorDirectory,
2377         NULL,   /* fpDeletePrintProcessor */
2378         NULL,   /* fpEnumPrintProcessorDatatypes */
2379         NULL,   /* fpStartDocPrinter */
2380         NULL,   /* fpStartPagePrinter */
2381         NULL,   /* fpWritePrinter */
2382         NULL,   /* fpEndPagePrinter */
2383         NULL,   /* fpAbortPrinter */
2384         NULL,   /* fpReadPrinter */
2385         NULL,   /* fpEndDocPrinter */
2386         NULL,   /* fpAddJob */
2387         NULL,   /* fpScheduleJob */
2388         NULL,   /* fpGetPrinterData */
2389         NULL,   /* fpSetPrinterData */
2390         NULL,   /* fpWaitForPrinterChange */
2391         fpClosePrinter,
2392         NULL,   /* fpAddForm */
2393         NULL,   /* fpDeleteForm */
2394         NULL,   /* fpGetForm */
2395         NULL,   /* fpSetForm */
2396         NULL,   /* fpEnumForms */
2397         fpEnumMonitors,
2398         fpEnumPorts,
2399         fpAddPort,
2400         fpConfigurePort,
2401         fpDeletePort,
2402         NULL,   /* fpCreatePrinterIC */
2403         NULL,   /* fpPlayGdiScriptOnPrinterIC */
2404         NULL,   /* fpDeletePrinterIC */
2405         NULL,   /* fpAddPrinterConnection */
2406         NULL,   /* fpDeletePrinterConnection */
2407         NULL,   /* fpPrinterMessageBox */
2408         fpAddMonitor,
2409         fpDeleteMonitor,
2410         NULL,   /* fpResetPrinter */
2411         NULL,   /* fpGetPrinterDriverEx */
2412         NULL,   /* fpFindFirstPrinterChangeNotification */
2413         NULL,   /* fpFindClosePrinterChangeNotification */
2414         fpAddPortEx,
2415         NULL,   /* fpShutDown */
2416         NULL,   /* fpRefreshPrinterChangeNotification */
2417         NULL,   /* fpOpenPrinterEx */
2418         NULL,   /* fpAddPrinterEx */
2419         NULL,   /* fpSetPort */
2420         NULL,   /* fpEnumPrinterData */
2421         NULL,   /* fpDeletePrinterData */
2422         NULL,   /* fpClusterSplOpen */
2423         NULL,   /* fpClusterSplClose */
2424         NULL,   /* fpClusterSplIsAlive */
2425         NULL,   /* fpSetPrinterDataEx */
2426         NULL,   /* fpGetPrinterDataEx */
2427         NULL,   /* fpEnumPrinterDataEx */
2428         NULL,   /* fpEnumPrinterKey */
2429         NULL,   /* fpDeletePrinterDataEx */
2430         NULL,   /* fpDeletePrinterKey */
2431         NULL,   /* fpSeekPrinter */
2432         NULL,   /* fpDeletePrinterDriverEx */
2433         NULL,   /* fpAddPerMachineConnection */
2434         NULL,   /* fpDeletePerMachineConnection */
2435         NULL,   /* fpEnumPerMachineConnections */
2436         fpXcvData,
2437         fpAddPrinterDriverEx,
2438         NULL,   /* fpSplReadPrinter */
2439         NULL,   /* fpDriverUnloadComplete */
2440         NULL,   /* fpGetSpoolFileInfo */
2441         NULL,   /* fpCommitSpoolData */
2442         NULL,   /* fpCloseSpoolFileHandle */
2443         NULL,   /* fpFlushPrinter */
2444         NULL,   /* fpSendRecvBidiData */
2445         NULL    /* fpAddDriverCatalog */
2446     };
2447     pprovider = &backend;
2448
2449 }
2450
2451 /*****************************************************
2452  * InitializePrintProvidor     (localspl.@)
2453  *
2454  * Initialize the Printprovider
2455  *
2456  * PARAMS
2457  *  pPrintProvidor    [I] Buffer to fill with a struct PRINTPROVIDOR
2458  *  cbPrintProvidor   [I] Size of Buffer in Bytes
2459  *  pFullRegistryPath [I] Registry-Path for the Printprovidor
2460  *
2461  * RETURNS
2462  *  Success: TRUE and pPrintProvidor filled
2463  *  Failure: FALSE
2464  *
2465  * NOTES
2466  *  The RegistryPath should be:
2467  *  "System\CurrentControlSet\Control\Print\Providers\<providername>",
2468  *  but this Parameter is ignored in "localspl.dll".
2469  *
2470  */
2471
2472 BOOL WINAPI InitializePrintProvidor(LPPRINTPROVIDOR pPrintProvidor,
2473                                     DWORD cbPrintProvidor, LPWSTR pFullRegistryPath)
2474 {
2475
2476     TRACE("(%p, %u, %s)\n", pPrintProvidor, cbPrintProvidor, debugstr_w(pFullRegistryPath));
2477     memcpy(pPrintProvidor, pprovider,
2478           (cbPrintProvidor < sizeof(PRINTPROVIDOR)) ? cbPrintProvidor : sizeof(PRINTPROVIDOR));
2479
2480     return TRUE;
2481 }