git.oblomov.eu Git - wine/blob - dlls/winspool.drv/info.c

   1 /*
   2  * WINSPOOL functions
   3  *
   4  * Copyright 1996 John Harvey
   5  * Copyright 1998 Andreas Mohr
   6  * Copyright 1999 Klaas van Gend
   7  * Copyright 1999, 2000 Huw D M Davies
   8  * Copyright 2001 Marcus Meissner
   9  * Copyright 2005-2008 Detlef Riekenberg
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <ctype.h>
  34 #include <stddef.h>
  35 #ifdef HAVE_UNISTD_H
  36 # include <unistd.h>
  37 #endif
  38 #include <signal.h>
  39 #ifdef HAVE_CUPS_CUPS_H
  40 # include <cups/cups.h>
  41 #endif
  42
  43 #define NONAMELESSUNION
  44 #define NONAMELESSSTRUCT
  45 #include "wine/library.h"
  46 #include "windef.h"
  47 #include "winbase.h"
  48 #include "winuser.h"
  49 #include "winerror.h"
  50 #include "winreg.h"
  51 #include "wingdi.h"
  52 #include "winspool.h"
  53 #include "winternl.h"
  54 #include "wine/windef16.h"
  55 #include "wine/unicode.h"
  56 #include "wine/debug.h"
  57 #include "wine/list.h"
  58 #include "winnls.h"
  59
  60 #include "ddk/winsplp.h"
  61 #include "wspool.h"
  62
  63 WINE_DEFAULT_DEBUG_CHANNEL(winspool);
  64
  65 /* ############################### */
  66
  67 static CRITICAL_SECTION monitor_handles_cs;
  68 static CRITICAL_SECTION_DEBUG monitor_handles_cs_debug =
  69 {
  70     0, 0, &monitor_handles_cs,
  71     { &monitor_handles_cs_debug.ProcessLocksList, &monitor_handles_cs_debug.ProcessLocksList },
  72       0, 0, { (DWORD_PTR)(__FILE__ ": monitor_handles_cs") }
  73 };
  74 static CRITICAL_SECTION monitor_handles_cs = { &monitor_handles_cs_debug, -1, 0, 0, 0, 0 };
  75
  76
  77 static CRITICAL_SECTION printer_handles_cs;
  78 static CRITICAL_SECTION_DEBUG printer_handles_cs_debug =
  79 {
  80     0, 0, &printer_handles_cs,
  81     { &printer_handles_cs_debug.ProcessLocksList, &printer_handles_cs_debug.ProcessLocksList },
  82       0, 0, { (DWORD_PTR)(__FILE__ ": printer_handles_cs") }
  83 };
  84 static CRITICAL_SECTION printer_handles_cs = { &printer_handles_cs_debug, -1, 0, 0, 0, 0 };
  85
  86 /* ############################### */
  87
  88 typedef struct {
  89     struct list     entry;
  90     LPWSTR          name;
  91     LPWSTR          dllname;
  92     PMONITORUI      monitorUI;
  93     LPMONITOR       monitor;
  94     HMODULE         hdll;
  95     DWORD           refcount;
  96     DWORD           dwMonitorSize;
  97 } monitor_t;
  98
  99 typedef struct {
 100     DWORD job_id;
 101     HANDLE hf;
 102 } started_doc_t;
 103
 104 typedef struct {
 105     struct list jobs;
 106     LONG ref;
 107 } jobqueue_t;
 108
 109 typedef struct {
 110     LPWSTR name;
 111     LPWSTR printername;
 112     monitor_t *pm;
 113     HANDLE hXcv;
 114     jobqueue_t *queue;
 115     started_doc_t *doc;
 116 } opened_printer_t;
 117
 118 typedef struct {
 119     struct list entry;
 120     DWORD job_id;
 121     WCHAR *filename;
 122     WCHAR *document_title;
 123 } job_t;
 124
 125
 126 typedef struct {
 127     LPCWSTR  envname;
 128     LPCWSTR  subdir;
 129     DWORD    driverversion;
 130     LPCWSTR  versionregpath;
 131     LPCWSTR  versionsubdir;
 132 } printenv_t;
 133
 134 /* ############################### */
 135
 136 static struct list monitor_handles = LIST_INIT( monitor_handles );
 137 static monitor_t * pm_localport;
 138
 139 static opened_printer_t **printer_handles;
 140 static UINT nb_printer_handles;
 141 static LONG next_job_id = 1;
 142
 143 static DWORD (WINAPI *GDI_CallDeviceCapabilities16)( LPCSTR lpszDevice, LPCSTR lpszPort,
 144                                                      WORD fwCapability, LPSTR lpszOutput,
 145                                                      LPDEVMODEA lpdm );
 146 static INT (WINAPI *GDI_CallExtDeviceMode16)( HWND hwnd, LPDEVMODEA lpdmOutput,
 147                                               LPSTR lpszDevice, LPSTR lpszPort,
 148                                               LPDEVMODEA lpdmInput, LPSTR lpszProfile,
 149                                               DWORD fwMode );
 150
 151 static const WCHAR DriversW[] = { 'S','y','s','t','e','m','\\',
 152                                   'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 153                                   'c','o','n','t','r','o','l','\\',
 154                                   'P','r','i','n','t','\\',
 155                                   'E','n','v','i','r','o','n','m','e','n','t','s','\\',
 156                                   '%','s','\\','D','r','i','v','e','r','s','%','s',0 };
 157
 158 static const WCHAR MonitorsW[] =  { 'S','y','s','t','e','m','\\',
 159                                   'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 160                                   'C','o','n','t','r','o','l','\\',
 161                                   'P','r','i','n','t','\\',
 162                                   'M','o','n','i','t','o','r','s','\\',0};
 163
 164 static const WCHAR PrintersW[] = {'S','y','s','t','e','m','\\',
 165                                   'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 166                                   'C','o','n','t','r','o','l','\\',
 167                                   'P','r','i','n','t','\\',
 168                                   'P','r','i','n','t','e','r','s',0};
 169
 170 static const WCHAR LocalPortW[] = {'L','o','c','a','l',' ','P','o','r','t',0};
 171
 172 static const WCHAR user_default_reg_key[] = { 'S','o','f','t','w','a','r','e','\\',
 173                                               'M','i','c','r','o','s','o','f','t','\\',
 174                                               'W','i','n','d','o','w','s',' ','N','T','\\',
 175                                               'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 176                                               'W','i','n','d','o','w','s',0};
 177
 178 static const WCHAR user_printers_reg_key[] = { 'S','o','f','t','w','a','r','e','\\',
 179                                                'M','i','c','r','o','s','o','f','t','\\',
 180                                                'W','i','n','d','o','w','s',' ','N','T','\\',
 181                                                'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 182                                                'D','e','v','i','c','e','s',0};
 183
 184 static const WCHAR WinNT_CV_PortsW[] = {'S','o','f','t','w','a','r','e','\\',
 185                                         'M','i','c','r','o','s','o','f','t','\\',
 186                                         'W','i','n','d','o','w','s',' ','N','T','\\',
 187                                         'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 188                                         'P','o','r','t','s',0};
 189
 190 static const WCHAR DefaultEnvironmentW[] = {'W','i','n','e',0};
 191 static const WCHAR envname_win40W[] = {'W','i','n','d','o','w','s',' ','4','.','0',0};
 192 static const WCHAR envname_x86W[] =   {'W','i','n','d','o','w','s',' ','N','T',' ','x','8','6',0};
 193 static const WCHAR subdir_win40W[] = {'w','i','n','4','0',0};
 194 static const WCHAR subdir_x86W[] =   {'w','3','2','x','8','6',0};
 195 static const WCHAR Version0_RegPathW[] = {'\\','V','e','r','s','i','o','n','-','0',0};
 196 static const WCHAR Version0_SubdirW[] = {'\\','0',0};
 197 static const WCHAR Version3_RegPathW[] = {'\\','V','e','r','s','i','o','n','-','3',0};
 198 static const WCHAR Version3_SubdirW[] = {'\\','3',0};
 199
 200 static const WCHAR spooldriversW[] = {'\\','s','p','o','o','l','\\','d','r','i','v','e','r','s','\\',0};
 201 static const WCHAR spoolprtprocsW[] = {'\\','s','p','o','o','l','\\','p','r','t','p','r','o','c','s','\\',0};
 202
 203 static const WCHAR backslashW[] = {'\\',0};
 204 static const WCHAR Configuration_FileW[] = {'C','o','n','f','i','g','u','r','a','t',
 205                                       'i','o','n',' ','F','i','l','e',0};
 206 static const WCHAR DatatypeW[] = {'D','a','t','a','t','y','p','e',0};
 207 static const WCHAR Data_FileW[] = {'D','a','t','a',' ','F','i','l','e',0};
 208 static const WCHAR Default_DevModeW[] = {'D','e','f','a','u','l','t',' ','D','e','v','M','o','d','e',0};
 209 static const WCHAR Dependent_FilesW[] = {'D','e','p','e','n','d','e','n','t',' ','F','i','l','e','s',0};
 210 static const WCHAR DescriptionW[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
 211 static const WCHAR DriverW[] = {'D','r','i','v','e','r',0};
 212 static const WCHAR HardwareIDW[] = {'H','a','r','d','w','a','r','e','I','D',0};
 213 static const WCHAR Help_FileW[] = {'H','e','l','p',' ','F','i','l','e',0};
 214 static const WCHAR LocationW[] = {'L','o','c','a','t','i','o','n',0};
 215 static const WCHAR ManufacturerW[] = {'M','a','n','u','f','a','c','t','u','r','e','r',0};
 216 static const WCHAR MonitorW[] = {'M','o','n','i','t','o','r',0};
 217 static const WCHAR MonitorUIW[] = {'M','o','n','i','t','o','r','U','I',0};
 218 static const WCHAR NameW[] = {'N','a','m','e',0};
 219 static const WCHAR ObjectGUIDW[] = {'O','b','j','e','c','t','G','U','I','D',0};
 220 static const WCHAR OEM_UrlW[] = {'O','E','M',' ','U','r','l',0};
 221 static const WCHAR ParametersW[] = {'P','a','r','a','m','e','t','e','r','s',0};
 222 static const WCHAR PortW[] = {'P','o','r','t',0};
 223 static const WCHAR bs_Ports_bsW[] = {'\\','P','o','r','t','s','\\',0};
 224 static const WCHAR Previous_NamesW[] = {'P','r','e','v','i','o','u','s',' ','N','a','m','e','s',0};
 225 static const WCHAR Print_ProcessorW[] = {'P','r','i','n','t',' ','P','r','o','c','e','s','s','o','r',0};
 226 static const WCHAR Printer_DriverW[] = {'P','r','i','n','t','e','r',' ','D','r','i','v','e','r',0};
 227 static const WCHAR PrinterDriverDataW[] = {'P','r','i','n','t','e','r','D','r','i','v','e','r','D','a','t','a',0};
 228 static const WCHAR ProviderW[] = {'P','r','o','v','i','d','e','r',0};
 229 static const WCHAR Separator_FileW[] = {'S','e','p','a','r','a','t','o','r',' ','F','i','l','e',0};
 230 static const WCHAR Share_NameW[] = {'S','h','a','r','e',' ','N','a','m','e',0};
 231 static const WCHAR VersionW[] = {'V','e','r','s','i','o','n',0};
 232 static const WCHAR WinPrintW[] = {'W','i','n','P','r','i','n','t',0};
 233 static const WCHAR deviceW[]  = {'d','e','v','i','c','e',0};
 234 static const WCHAR devicesW[] = {'d','e','v','i','c','e','s',0};
 235 static const WCHAR windowsW[] = {'w','i','n','d','o','w','s',0};
 236 static const WCHAR emptyStringW[] = {0};
 237 static const WCHAR XcvMonitorW[] = {',','X','c','v','M','o','n','i','t','o','r',' ',0};
 238 static const WCHAR XcvPortW[] = {',','X','c','v','P','o','r','t',' ',0};
 239
 240 static const WCHAR May_Delete_Value[] = {'W','i','n','e','M','a','y','D','e','l','e','t','e','M','e',0};
 241
 242 static const WCHAR CUPS_Port[] = {'C','U','P','S',':',0};
 243 static const WCHAR FILE_Port[] = {'F','I','L','E',':',0};
 244 static const WCHAR LPR_Port[] = {'L','P','R',':',0};
 245
 246 static const WCHAR default_doc_title[] = {'L','o','c','a','l',' ','D','o','w','n','l','e','v','e','l',' ',
 247                                           'D','o','c','u','m','e','n','t',0};
 248
 249 static const DWORD di_sizeof[] = {0, sizeof(DRIVER_INFO_1W), sizeof(DRIVER_INFO_2W),
 250                                      sizeof(DRIVER_INFO_3W), sizeof(DRIVER_INFO_4W),
 251                                      sizeof(DRIVER_INFO_5W), sizeof(DRIVER_INFO_6W),
 252                                   0, sizeof(DRIVER_INFO_8W)};
 253
 254 /******************************************************************
 255  *  validate the user-supplied printing-environment [internal]
 256  *
 257  * PARAMS
 258  *  env  [I] PTR to Environment-String or NULL
 259  *
 260  * RETURNS
 261  *  Failure:  NULL
 262  *  Success:  PTR to printenv_t
 263  *
 264  * NOTES
 265  *  An empty string is handled the same way as NULL.
 266  *  SetLastEror(ERROR_INVALID_ENVIRONMENT) is called on Failure
 267  *
 268  */
 269
 270 static const  printenv_t * validate_envW(LPCWSTR env)
 271 {
 272     static const printenv_t env_x86 =   {envname_x86W, subdir_x86W,
 273                                          3, Version3_RegPathW, Version3_SubdirW};
 274     static const printenv_t env_win40 = {envname_win40W, subdir_win40W,
 275                                          0, Version0_RegPathW, Version0_SubdirW};
 276
 277     static const printenv_t * const all_printenv[]={&env_x86, &env_win40};
 278
 279     const printenv_t *result = NULL;
 280     unsigned int i;
 281
 282     TRACE("testing %s\n", debugstr_w(env));
 283     if (env && env[0])
 284     {
 285         for (i = 0; i < sizeof(all_printenv)/sizeof(all_printenv[0]); i++)
 286         {
 287             if (lstrcmpiW(env, all_printenv[i]->envname) == 0)
 288             {
 289                 result = all_printenv[i];
 290                 break;
 291             }
 292         }
 293
 294         if (result == NULL) {
 295             FIXME("unsupported Environment: %s\n", debugstr_w(env));
 296             SetLastError(ERROR_INVALID_ENVIRONMENT);
 297         }
 298         /* on win9x, only "Windows 4.0" is allowed, but we ignore this */
 299     }
 300     else
 301     {
 302         result = (GetVersion() & 0x80000000) ? &env_win40 : &env_x86;
 303     }
 304     TRACE("using %p: %s\n", result, debugstr_w(result ? result->envname : NULL));
 305
 306     return result;
 307 }
 308
 309
 310 /* RtlCreateUnicodeStringFromAsciiz will return an empty string in the buffer
 311    if passed a NULL string. This returns NULLs to the result.
 312 */
 313 static inline PWSTR asciitounicode( UNICODE_STRING * usBufferPtr, LPCSTR src )
 314 {
 315     if ( (src) )
 316     {
 317         RtlCreateUnicodeStringFromAsciiz(usBufferPtr, src);
 318         return usBufferPtr->Buffer;
 319     }
 320     usBufferPtr->Buffer = NULL; /* so that RtlFreeUnicodeString won't barf */
 321     return NULL;
 322 }
 323
 324 static LPWSTR strdupW(LPCWSTR p)
 325 {
 326     LPWSTR ret;
 327     DWORD len;
 328
 329     if(!p) return NULL;
 330     len = (strlenW(p) + 1) * sizeof(WCHAR);
 331     ret = HeapAlloc(GetProcessHeap(), 0, len);
 332     memcpy(ret, p, len);
 333     return ret;
 334 }
 335
 336 static LPSTR strdupWtoA( LPCWSTR str )
 337 {
 338     LPSTR ret;
 339     INT len;
 340
 341     if (!str) return NULL;
 342     len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
 343     ret = HeapAlloc( GetProcessHeap(), 0, len );
 344     if(ret) WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
 345     return ret;
 346 }
 347
 348 /******************************************************************
 349  * Return the number of bytes for an multi_sz string.
 350  * The result includes all \0s
 351  * (specifically the extra \0, that is needed as multi_sz terminator).
 352  */
 353 #if 0
 354 static int multi_sz_lenW(const WCHAR *str)
 355 {
 356     const WCHAR *ptr = str;
 357     if(!str) return 0;
 358     do
 359     {
 360         ptr += lstrlenW(ptr) + 1;
 361     } while(*ptr);
 362
 363     return (ptr - str + 1) * sizeof(WCHAR);
 364 }
 365 #endif
 366 /* ################################ */
 367
 368 static int multi_sz_lenA(const char *str)
 369 {
 370     const char *ptr = str;
 371     if(!str) return 0;
 372     do
 373     {
 374         ptr += lstrlenA(ptr) + 1;
 375     } while(*ptr);
 376
 377     return ptr - str + 1;
 378 }
 379
 380 static void
 381 WINSPOOL_SetDefaultPrinter(const char *devname, const char *name, BOOL force) {
 382     char qbuf[200];
 383
 384     /* If forcing, or no profile string entry for device yet, set the entry
 385      *
 386      * The always change entry if not WINEPS yet is discussable.
 387      */
 388     if (force                                                           ||
 389         !GetProfileStringA("windows","device","*",qbuf,sizeof(qbuf))    ||
 390         !strcmp(qbuf,"*")                                               ||
 391         !strstr(qbuf,"WINEPS.DRV")
 392     ) {
 393         char *buf = HeapAlloc(GetProcessHeap(),0,strlen(name)+strlen(devname)+strlen(",WINEPS.DRV,LPR:")+1);
 394         HKEY hkey;
 395
 396         sprintf(buf,"%s,WINEPS.DRV,LPR:%s",devname,name);
 397         WriteProfileStringA("windows","device",buf);
 398         if(RegCreateKeyW(HKEY_CURRENT_USER, user_default_reg_key, &hkey) == ERROR_SUCCESS) {
 399             RegSetValueExA(hkey, "Device", 0, REG_SZ, (LPBYTE)buf, strlen(buf) + 1);
 400             RegCloseKey(hkey);
 401         }
 402         HeapFree(GetProcessHeap(),0,buf);
 403     }
 404 }
 405
 406 static BOOL add_printer_driver(const char *name)
 407 {
 408     DRIVER_INFO_3A di3a;
 409
 410     static char driver_9x[]         = "wineps16.drv",
 411                 driver_nt[]         = "wineps.drv",
 412                 env_9x[]            = "Windows 4.0",
 413                 env_nt[]            = "Windows NT x86",
 414                 data_file[]         = "generic.ppd",
 415                 default_data_type[] = "RAW";
 416
 417     ZeroMemory(&di3a, sizeof(DRIVER_INFO_3A));
 418     di3a.cVersion         = 3;
 419     di3a.pName            = (char *)name;
 420     di3a.pEnvironment     = env_nt;
 421     di3a.pDriverPath      = driver_nt;
 422     di3a.pDataFile        = data_file;
 423     di3a.pConfigFile      = driver_nt;
 424     di3a.pDefaultDataType = default_data_type;
 425
 426     if (AddPrinterDriverA(NULL, 3, (LPBYTE)&di3a) ||
 427         (GetLastError() ==  ERROR_PRINTER_DRIVER_ALREADY_INSTALLED ))
 428     {
 429         di3a.cVersion     = 0;
 430         di3a.pEnvironment = env_9x;
 431         di3a.pDriverPath  = driver_9x;
 432         di3a.pConfigFile  = driver_9x;
 433         if (AddPrinterDriverA(NULL, 3, (LPBYTE)&di3a) ||
 434             (GetLastError() ==  ERROR_PRINTER_DRIVER_ALREADY_INSTALLED ))
 435         {
 436             return TRUE;
 437         }
 438     }
 439     ERR("Failed adding driver %s (%s): %u\n", debugstr_a(di3a.pDriverPath),
 440         debugstr_a(di3a.pEnvironment), GetLastError());
 441     return FALSE;
 442 }
 443
 444 #ifdef SONAME_LIBCUPS
 445 static typeof(cupsGetDests)  *pcupsGetDests;
 446 static typeof(cupsGetPPD)    *pcupsGetPPD;
 447 static typeof(cupsPrintFile) *pcupsPrintFile;
 448 static void *cupshandle;
 449
 450 static BOOL CUPS_LoadPrinters(void)
 451 {
 452     int                   i, nrofdests;
 453     BOOL                  hadprinter = FALSE, haddefault = FALSE;
 454     cups_dest_t          *dests;
 455     PRINTER_INFO_2A       pinfo2a;
 456     char   *port,*devline;
 457     HKEY hkeyPrinter, hkeyPrinters, hkey;
 458     char    loaderror[256];
 459
 460     cupshandle = wine_dlopen(SONAME_LIBCUPS, RTLD_NOW, loaderror, sizeof(loaderror));
 461     if (!cupshandle) {
 462         TRACE("%s\n", loaderror);
 463         return FALSE;
 464     }
 465     TRACE("%p: %s loaded\n", cupshandle, SONAME_LIBCUPS);
 466
 467 #define DYNCUPS(x)                                      \
 468         p##x = wine_dlsym(cupshandle, #x, NULL,0);      \
 469         if (!p##x) return FALSE;
 470
 471     DYNCUPS(cupsGetPPD);
 472     DYNCUPS(cupsGetDests);
 473     DYNCUPS(cupsPrintFile);
 474 #undef DYNCUPS
 475
 476     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
 477        ERROR_SUCCESS) {
 478         ERR("Can't create Printers key\n");
 479         return FALSE;
 480     }
 481
 482     nrofdests = pcupsGetDests(&dests);
 483     TRACE("Found %d CUPS %s:\n", nrofdests, (nrofdests == 1) ? "printer" : "printers");
 484     for (i=0;i<nrofdests;i++) {
 485         port = HeapAlloc(GetProcessHeap(),0,strlen("LPR:")+strlen(dests[i].name)+1);
 486         sprintf(port,"LPR:%s",dests[i].name);
 487         devline=HeapAlloc(GetProcessHeap(),0,sizeof("WINEPS.DRV,")+strlen(port));
 488         sprintf(devline,"WINEPS.DRV,%s",port);
 489         WriteProfileStringA("devices",dests[i].name,devline);
 490         if(RegCreateKeyW(HKEY_CURRENT_USER, user_printers_reg_key, &hkey) == ERROR_SUCCESS) {
 491             RegSetValueExA(hkey, dests[i].name, 0, REG_SZ, (LPBYTE)devline, strlen(devline) + 1);
 492             RegCloseKey(hkey);
 493         }
 494         HeapFree(GetProcessHeap(),0,devline);
 495
 496         TRACE("Printer %d: %s\n", i, dests[i].name);
 497         if(RegOpenKeyA(hkeyPrinters, dests[i].name, &hkeyPrinter) == ERROR_SUCCESS) {
 498             /* Printer already in registry, delete the tag added in WINSPOOL_LoadSystemPrinters
 499                and continue */
 500             TRACE("Printer already exists\n");
 501             RegDeleteValueW(hkeyPrinter, May_Delete_Value);
 502             RegCloseKey(hkeyPrinter);
 503         } else {
 504             static CHAR data_type[] = "RAW",
 505                     print_proc[]    = "WinPrint",
 506                     comment[]       = "WINEPS Printer using CUPS",
 507                     location[]      = "<physical location of printer>",
 508                     params[]        = "<parameters?>",
 509                     share_name[]    = "<share name?>",
 510                     sep_file[]      = "<sep file?>";
 511
 512             add_printer_driver(dests[i].name);
 513
 514             memset(&pinfo2a,0,sizeof(pinfo2a));
 515             pinfo2a.pPrinterName    = dests[i].name;
 516             pinfo2a.pDatatype       = data_type;
 517             pinfo2a.pPrintProcessor = print_proc;
 518             pinfo2a.pDriverName     = dests[i].name;
 519             pinfo2a.pComment        = comment;
 520             pinfo2a.pLocation       = location;
 521             pinfo2a.pPortName       = port;
 522             pinfo2a.pParameters     = params;
 523             pinfo2a.pShareName      = share_name;
 524             pinfo2a.pSepFile        = sep_file;
 525
 526             if (!AddPrinterA(NULL,2,(LPBYTE)&pinfo2a)) {
 527                 if (GetLastError() != ERROR_PRINTER_ALREADY_EXISTS)
 528                     ERR("printer '%s' not added by AddPrinterA (error %d)\n",dests[i].name,GetLastError());
 529             }
 530         }
 531         HeapFree(GetProcessHeap(),0,port);
 532
 533         hadprinter = TRUE;
 534         if (dests[i].is_default) {
 535             WINSPOOL_SetDefaultPrinter(dests[i].name, dests[i].name, TRUE);
 536             haddefault = TRUE;
 537         }
 538     }
 539     if (hadprinter & !haddefault)
 540         WINSPOOL_SetDefaultPrinter(dests[0].name, dests[0].name, TRUE);
 541     RegCloseKey(hkeyPrinters);
 542     return hadprinter;
 543 }
 544 #endif
 545
 546 static BOOL
 547 PRINTCAP_ParseEntry(const char *pent, BOOL isfirst) {
 548     PRINTER_INFO_2A     pinfo2a;
 549     char                *e,*s,*name,*prettyname,*devname;
 550     BOOL                ret = FALSE, set_default = FALSE;
 551     char                *port = NULL, *devline,*env_default;
 552     HKEY                hkeyPrinter, hkeyPrinters, hkey;
 553
 554     while (isspace(*pent)) pent++;
 555     s = strchr(pent,':');
 556     if(s) *s='\0';
 557     name = HeapAlloc(GetProcessHeap(), 0, strlen(pent) + 1);
 558     strcpy(name,pent);
 559     if(s) {
 560         *s=':';
 561         pent = s;
 562     } else
 563         pent = "";
 564
 565     TRACE("name=%s entry=%s\n",name, pent);
 566
 567     if(ispunct(*name)) { /* a tc entry, not a real printer */
 568         TRACE("skipping tc entry\n");
 569         goto end;
 570     }
 571
 572     if(strstr(pent,":server")) { /* server only version so skip */
 573         TRACE("skipping server entry\n");
 574         goto end;
 575     }
 576
 577     /* Determine whether this is a postscript printer. */
 578
 579     ret = TRUE;
 580     env_default = getenv("PRINTER");
 581     prettyname = name;
 582     /* Get longest name, usually the one at the right for later display. */
 583     while((s=strchr(prettyname,'|'))) {
 584         *s = '\0';
 585         e = s;
 586         while(isspace(*--e)) *e = '\0';
 587         TRACE("\t%s\n", debugstr_a(prettyname));
 588         if(env_default && !strcasecmp(prettyname, env_default)) set_default = TRUE;
 589         for(prettyname = s+1; isspace(*prettyname); prettyname++)
 590             ;
 591     }
 592     e = prettyname + strlen(prettyname);
 593     while(isspace(*--e)) *e = '\0';
 594     TRACE("\t%s\n", debugstr_a(prettyname));
 595     if(env_default && !strcasecmp(prettyname, env_default)) set_default = TRUE;
 596
 597     /* prettyname must fit into the dmDeviceName member of DEVMODE struct,
 598      * if it is too long, we use it as comment below. */
 599     devname = prettyname;
 600     if (strlen(devname)>=CCHDEVICENAME-1)
 601          devname = name;
 602     if (strlen(devname)>=CCHDEVICENAME-1) {
 603         ret = FALSE;
 604         goto end;
 605     }
 606
 607     port = HeapAlloc(GetProcessHeap(),0,strlen("LPR:")+strlen(name)+1);
 608     sprintf(port,"LPR:%s",name);
 609
 610     devline=HeapAlloc(GetProcessHeap(),0,sizeof("WINEPS.DRV,")+strlen(port));
 611     sprintf(devline,"WINEPS.DRV,%s",port);
 612     WriteProfileStringA("devices",devname,devline);
 613     if(RegCreateKeyW(HKEY_CURRENT_USER, user_printers_reg_key, &hkey) == ERROR_SUCCESS) {
 614         RegSetValueExA(hkey, devname, 0, REG_SZ, (LPBYTE)devline, strlen(devline) + 1);
 615         RegCloseKey(hkey);
 616     }
 617     HeapFree(GetProcessHeap(),0,devline);
 618
 619     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
 620        ERROR_SUCCESS) {
 621         ERR("Can't create Printers key\n");
 622         ret = FALSE;
 623         goto end;
 624     }
 625     if(RegOpenKeyA(hkeyPrinters, devname, &hkeyPrinter) == ERROR_SUCCESS) {
 626         /* Printer already in registry, delete the tag added in WINSPOOL_LoadSystemPrinters
 627            and continue */
 628         TRACE("Printer already exists\n");
 629         RegDeleteValueW(hkeyPrinter, May_Delete_Value);
 630         RegCloseKey(hkeyPrinter);
 631     } else {
 632         static CHAR data_type[]   = "RAW",
 633                     print_proc[]  = "WinPrint",
 634                     comment[]     = "WINEPS Printer using LPR",
 635                     params[]      = "<parameters?>",
 636                     share_name[]  = "<share name?>",
 637                     sep_file[]    = "<sep file?>";
 638
 639         add_printer_driver(devname);
 640
 641         memset(&pinfo2a,0,sizeof(pinfo2a));
 642         pinfo2a.pPrinterName    = devname;
 643         pinfo2a.pDatatype       = data_type;
 644         pinfo2a.pPrintProcessor = print_proc;
 645         pinfo2a.pDriverName     = devname;
 646         pinfo2a.pComment        = comment;
 647         pinfo2a.pLocation       = prettyname;
 648         pinfo2a.pPortName       = port;
 649         pinfo2a.pParameters     = params;
 650         pinfo2a.pShareName      = share_name;
 651         pinfo2a.pSepFile        = sep_file;
 652
 653         if (!AddPrinterA(NULL,2,(LPBYTE)&pinfo2a)) {
 654             if (GetLastError()!=ERROR_PRINTER_ALREADY_EXISTS)
 655                 ERR("%s not added by AddPrinterA (%d)\n",name,GetLastError());
 656         }
 657     }
 658     RegCloseKey(hkeyPrinters);
 659
 660     if (isfirst || set_default)
 661         WINSPOOL_SetDefaultPrinter(devname,name,TRUE);
 662
 663  end:
 664     HeapFree(GetProcessHeap(), 0, port);
 665     HeapFree(GetProcessHeap(), 0, name);
 666     return ret;
 667 }
 668
 669 static BOOL
 670 PRINTCAP_LoadPrinters(void) {
 671     BOOL                hadprinter = FALSE;
 672     char                buf[200];
 673     FILE                *f;
 674     char *pent = NULL;
 675     BOOL had_bash = FALSE;
 676
 677     f = fopen("/etc/printcap","r");
 678     if (!f)
 679         return FALSE;
 680
 681     while(fgets(buf,sizeof(buf),f)) {
 682         char *start, *end;
 683
 684         end=strchr(buf,'\n');
 685         if (end) *end='\0';
 686
 687         start = buf;
 688         while(isspace(*start)) start++;
 689         if(*start == '#' || *start == '\0')
 690             continue;
 691
 692         if(pent && !had_bash && *start != ':' && *start != '|') { /* start of new entry, parse the previous one */
 693             hadprinter |= PRINTCAP_ParseEntry(pent,!hadprinter);
 694             HeapFree(GetProcessHeap(),0,pent);
 695             pent = NULL;
 696         }
 697
 698         if (end && *--end == '\\') {
 699             *end = '\0';
 700             had_bash = TRUE;
 701         } else
 702             had_bash = FALSE;
 703
 704         if (pent) {
 705             pent=HeapReAlloc(GetProcessHeap(),0,pent,strlen(pent)+strlen(start)+1);
 706             strcat(pent,start);
 707         } else {
 708             pent=HeapAlloc(GetProcessHeap(),0,strlen(start)+1);
 709             strcpy(pent,start);
 710         }
 711
 712     }
 713     if(pent) {
 714         hadprinter |= PRINTCAP_ParseEntry(pent,!hadprinter);
 715         HeapFree(GetProcessHeap(),0,pent);
 716     }
 717     fclose(f);
 718     return hadprinter;
 719 }
 720
 721 static inline DWORD set_reg_szW(HKEY hkey, const WCHAR *keyname, const WCHAR *value)
 722 {
 723     if (value)
 724         return RegSetValueExW(hkey, keyname, 0, REG_SZ, (const BYTE*)value,
 725                               (lstrlenW(value) + 1) * sizeof(WCHAR));
 726     else
 727         return ERROR_FILE_NOT_FOUND;
 728 }
 729
 730 /*****************************************************************************
 731  * enumerate the local monitors (INTERNAL)
 732  *
 733  * returns the needed size (in bytes) for pMonitors
 734  * and  *lpreturned is set to number of entries returned in pMonitors
 735  *
 736  */
 737 static DWORD get_local_monitors(DWORD level, LPBYTE pMonitors, DWORD cbBuf, LPDWORD lpreturned)
 738 {
 739     HKEY    hroot = NULL;
 740     HKEY    hentry = NULL;
 741     LPWSTR  ptr;
 742     LPMONITOR_INFO_2W mi;
 743     WCHAR   buffer[MAX_PATH];
 744     WCHAR   dllname[MAX_PATH];
 745     DWORD   dllsize;
 746     DWORD   len;
 747     DWORD   index = 0;
 748     DWORD   needed = 0;
 749     DWORD   numentries;
 750     DWORD   entrysize;
 751
 752     entrysize = (level == 1) ? sizeof(MONITOR_INFO_1W) : sizeof(MONITOR_INFO_2W);
 753
 754     numentries = *lpreturned;       /* this is 0, when we scan the registry */
 755     len = entrysize * numentries;
 756     ptr = (LPWSTR) &pMonitors[len];
 757
 758     numentries = 0;
 759     len = sizeof(buffer)/sizeof(buffer[0]);
 760     buffer[0] = '\0';
 761
 762     /* Windows creates the "Monitors"-Key on reboot / start "spooler" */
 763     if (RegCreateKeyW(HKEY_LOCAL_MACHINE, MonitorsW, &hroot) == ERROR_SUCCESS) {
 764         /* Scan all Monitor-Registry-Keys */
 765         while (RegEnumKeyExW(hroot, index, buffer, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
 766             TRACE("Monitor_%d: %s\n", numentries, debugstr_w(buffer));
 767             dllsize = sizeof(dllname);
 768             dllname[0] = '\0';
 769
 770             /* The Monitor must have a Driver-DLL */
 771             if (RegOpenKeyExW(hroot, buffer, 0, KEY_READ, &hentry) == ERROR_SUCCESS) {
 772                 if (RegQueryValueExW(hentry, DriverW, NULL, NULL, (LPBYTE) dllname, &dllsize) == ERROR_SUCCESS) {
 773                     /* We found a valid DLL for this Monitor. */
 774                     TRACE("using Driver: %s\n", debugstr_w(dllname));
 775                 }
 776                 RegCloseKey(hentry);
 777             }
 778
 779             /* Windows returns only Port-Monitors here, but to simplify our code,
 780                we do no filtering for Language-Monitors */
 781             if (dllname[0]) {
 782                 numentries++;
 783                 needed += entrysize;
 784                 needed += (len+1) * sizeof(WCHAR);  /* len is lstrlenW(monitorname) */
 785                 if (level > 1) {
 786                     /* we install and return only monitors for "Windows NT x86" */
 787                     needed += (lstrlenW(envname_x86W) +1) * sizeof(WCHAR);
 788                     needed += dllsize;
 789                 }
 790
 791                 /* required size is calculated. Now fill the user-buffer */
 792                 if (pMonitors && (cbBuf >= needed)){
 793                     mi = (LPMONITOR_INFO_2W) pMonitors;
 794                     pMonitors += entrysize;
 795
 796                     TRACE("%p: writing MONITOR_INFO_%dW #%d\n", mi, level, numentries);
 797                     mi->pName = ptr;
 798                     lstrcpyW(ptr, buffer);      /* Name of the Monitor */
 799                     ptr += (len+1);               /* len is lstrlenW(monitorname) */
 800                     if (level > 1) {
 801                         mi->pEnvironment = ptr;
 802                         lstrcpyW(ptr, envname_x86W); /* fixed to "Windows NT x86" */
 803                         ptr += (lstrlenW(envname_x86W)+1);
 804
 805                         mi->pDLLName = ptr;
 806                         lstrcpyW(ptr, dllname);         /* Name of the Driver-DLL */
 807                         ptr += (dllsize / sizeof(WCHAR));
 808                     }
 809                 }
 810             }
 811             index++;
 812             len = sizeof(buffer)/sizeof(buffer[0]);
 813             buffer[0] = '\0';
 814         }
 815         RegCloseKey(hroot);
 816     }
 817     *lpreturned = numentries;
 818     TRACE("need %d byte for %d entries\n", needed, numentries);
 819     return needed;
 820 }
 821
 822 /******************************************************************
 823  * monitor_unload [internal]
 824  *
 825  * release a printmonitor and unload it from memory, when needed
 826  *
 827  */
 828 static void monitor_unload(monitor_t * pm)
 829 {
 830     if (pm == NULL) return;
 831     TRACE("%p (refcount: %d) %s\n", pm, pm->refcount, debugstr_w(pm->name));
 832
 833     EnterCriticalSection(&monitor_handles_cs);
 834
 835     if (pm->refcount) pm->refcount--;
 836
 837     if (pm->refcount == 0) {
 838         list_remove(&pm->entry);
 839         FreeLibrary(pm->hdll);
 840         HeapFree(GetProcessHeap(), 0, pm->name);
 841         HeapFree(GetProcessHeap(), 0, pm->dllname);
 842         HeapFree(GetProcessHeap(), 0, pm);
 843     }
 844     LeaveCriticalSection(&monitor_handles_cs);
 845 }
 846
 847 /******************************************************************
 848  * monitor_unloadall [internal]
 849  *
 850  * release all printmonitors and unload them from memory, when needed
 851  */
 852
 853 static void monitor_unloadall(void)
 854 {
 855     monitor_t * pm;
 856     monitor_t * next;
 857
 858     EnterCriticalSection(&monitor_handles_cs);
 859     /* iterate through the list, with safety against removal */
 860     LIST_FOR_EACH_ENTRY_SAFE(pm, next, &monitor_handles, monitor_t, entry)
 861     {
 862         monitor_unload(pm);
 863     }
 864     LeaveCriticalSection(&monitor_handles_cs);
 865 }
 866
 867 /******************************************************************
 868  * monitor_load [internal]
 869  *
 870  * load a printmonitor, get the dllname from the registry, when needed
 871  * initialize the monitor and dump found function-pointers
 872  *
 873  * On failure, SetLastError() is called and NULL is returned
 874  */
 875
 876 static monitor_t * monitor_load(LPCWSTR name, LPWSTR dllname)
 877 {
 878     LPMONITOR2  (WINAPI *pInitializePrintMonitor2) (PMONITORINIT, LPHANDLE);
 879     PMONITORUI  (WINAPI *pInitializePrintMonitorUI)(VOID);
 880     LPMONITOREX (WINAPI *pInitializePrintMonitor)  (LPWSTR);
 881     DWORD (WINAPI *pInitializeMonitorEx)(LPWSTR, LPMONITOR);
 882     DWORD (WINAPI *pInitializeMonitor)  (LPWSTR);
 883
 884     monitor_t * pm = NULL;
 885     monitor_t * cursor;
 886     LPWSTR  regroot = NULL;
 887     LPWSTR  driver = dllname;
 888
 889     TRACE("(%s, %s)\n", debugstr_w(name), debugstr_w(dllname));
 890     /* Is the Monitor already loaded? */
 891     EnterCriticalSection(&monitor_handles_cs);
 892
 893     if (name) {
 894         LIST_FOR_EACH_ENTRY(cursor, &monitor_handles, monitor_t, entry)
 895         {
 896             if (cursor->name && (lstrcmpW(name, cursor->name) == 0)) {
 897                 pm = cursor;
 898                 break;
 899             }
 900         }
 901     }
 902
 903     if (pm == NULL) {
 904         pm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(monitor_t));
 905         if (pm == NULL) goto cleanup;
 906         list_add_tail(&monitor_handles, &pm->entry);
 907     }
 908     pm->refcount++;
 909
 910     if (pm->name == NULL) {
 911         /* Load the monitor */
 912         LPMONITOREX pmonitorEx;
 913         DWORD   len;
 914
 915         if (name) {
 916             len = lstrlenW(MonitorsW) + lstrlenW(name) + 2;
 917             regroot = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 918         }
 919
 920         if (regroot) {
 921             lstrcpyW(regroot, MonitorsW);
 922             lstrcatW(regroot, name);
 923             /* Get the Driver from the Registry */
 924             if (driver == NULL) {
 925                 HKEY    hroot;
 926                 DWORD   namesize;
 927                 if (RegOpenKeyW(HKEY_LOCAL_MACHINE, regroot, &hroot) == ERROR_SUCCESS) {
 928                     if (RegQueryValueExW(hroot, DriverW, NULL, NULL, NULL,
 929                                         &namesize) == ERROR_SUCCESS) {
 930                         driver = HeapAlloc(GetProcessHeap(), 0, namesize);
 931                         RegQueryValueExW(hroot, DriverW, NULL, NULL, (LPBYTE) driver, &namesize) ;
 932                     }
 933                     RegCloseKey(hroot);
 934                 }
 935             }
 936         }
 937
 938         pm->name = strdupW(name);
 939         pm->dllname = strdupW(driver);
 940
 941         if ((name && (!regroot || !pm->name)) || !pm->dllname) {
 942             monitor_unload(pm);
 943             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 944             pm = NULL;
 945             goto cleanup;
 946         }
 947
 948         pm->hdll = LoadLibraryW(driver);
 949         TRACE("%p: LoadLibrary(%s) => %d\n", pm->hdll, debugstr_w(driver), GetLastError());
 950
 951         if (pm->hdll == NULL) {
 952             monitor_unload(pm);
 953             SetLastError(ERROR_MOD_NOT_FOUND);
 954             pm = NULL;
 955             goto cleanup;
 956         }
 957
 958         pInitializePrintMonitor2  = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitor2");
 959         pInitializePrintMonitorUI = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitorUI");
 960         pInitializePrintMonitor   = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitor");
 961         pInitializeMonitorEx = (void *)GetProcAddress(pm->hdll, "InitializeMonitorEx");
 962         pInitializeMonitor   = (void *)GetProcAddress(pm->hdll, "InitializeMonitor");
 963
 964
 965         TRACE("%p: %s,pInitializePrintMonitor2\n", pInitializePrintMonitor2, debugstr_w(driver));
 966         TRACE("%p: %s,pInitializePrintMonitorUI\n", pInitializePrintMonitorUI, debugstr_w(driver));
 967         TRACE("%p: %s,pInitializePrintMonitor\n", pInitializePrintMonitor, debugstr_w(driver));
 968         TRACE("%p: %s,pInitializeMonitorEx\n", pInitializeMonitorEx, debugstr_w(driver));
 969         TRACE("%p: %s,pInitializeMonitor\n", pInitializeMonitor, debugstr_w(driver));
 970
 971         if (pInitializePrintMonitorUI  != NULL) {
 972             pm->monitorUI = pInitializePrintMonitorUI();
 973             TRACE("%p: MONITORUI from %s,InitializePrintMonitorUI()\n", pm->monitorUI, debugstr_w(driver));
 974             if (pm->monitorUI) {
 975                 TRACE(  "0x%08x: dwMonitorSize (%d)\n",
 976                         pm->monitorUI->dwMonitorUISize, pm->monitorUI->dwMonitorUISize );
 977
 978             }
 979         }
 980
 981         if (pInitializePrintMonitor && regroot) {
 982             pmonitorEx = pInitializePrintMonitor(regroot);
 983             TRACE(  "%p: LPMONITOREX from %s,InitializePrintMonitor(%s)\n",
 984                     pmonitorEx, debugstr_w(driver), debugstr_w(regroot));
 985
 986             if (pmonitorEx) {
 987                 pm->dwMonitorSize = pmonitorEx->dwMonitorSize;
 988                 pm->monitor = &(pmonitorEx->Monitor);
 989             }
 990         }
 991
 992         if (pm->monitor) {
 993             TRACE(  "0x%08x: dwMonitorSize (%d)\n", pm->dwMonitorSize, pm->dwMonitorSize );
 994
 995         }
 996
 997         if (!pm->monitor && regroot) {
 998             if (pInitializePrintMonitor2 != NULL) {
 999                 FIXME("%s,InitializePrintMonitor2 not implemented\n", debugstr_w(driver));
1000             }
1001             if (pInitializeMonitorEx != NULL) {
1002                 FIXME("%s,InitializeMonitorEx not implemented\n", debugstr_w(driver));
1003             }
1004             if (pInitializeMonitor != NULL) {
1005                 FIXME("%s,InitializeMonitor not implemented\n", debugstr_w(driver));
1006             }
1007         }
1008         if (!pm->monitor && !pm->monitorUI) {
1009             monitor_unload(pm);
1010             SetLastError(ERROR_PROC_NOT_FOUND);
1011             pm = NULL;
1012         }
1013     }
1014 cleanup:
1015     if ((pm_localport ==  NULL) && (pm != NULL) && (lstrcmpW(pm->name, LocalPortW) == 0)) {
1016         pm->refcount++;
1017         pm_localport = pm;
1018     }
1019     LeaveCriticalSection(&monitor_handles_cs);
1020     if (driver != dllname) HeapFree(GetProcessHeap(), 0, driver);
1021     HeapFree(GetProcessHeap(), 0, regroot);
1022     TRACE("=> %p\n", pm);
1023     return pm;
1024 }
1025
1026 /******************************************************************
1027  * monitor_loadall [internal]
1028  *
1029  * Load all registered monitors
1030  *
1031  */
1032 static DWORD monitor_loadall(void)
1033 {
1034     monitor_t * pm;
1035     DWORD   registered = 0;
1036     DWORD   loaded = 0;
1037     HKEY    hmonitors;
1038     WCHAR   buffer[MAX_PATH];
1039     DWORD   id = 0;
1040
1041     if (RegOpenKeyW(HKEY_LOCAL_MACHINE, MonitorsW, &hmonitors) == ERROR_SUCCESS) {
1042         RegQueryInfoKeyW(hmonitors, NULL, NULL, NULL, &registered, NULL, NULL,
1043                         NULL, NULL, NULL, NULL, NULL);
1044
1045         TRACE("%d monitors registered\n", registered);
1046
1047         EnterCriticalSection(&monitor_handles_cs);
1048         while (id < registered) {
1049             buffer[0] = '\0';
1050             RegEnumKeyW(hmonitors, id, buffer, MAX_PATH);
1051             pm = monitor_load(buffer, NULL);
1052             if (pm) loaded++;
1053             id++;
1054         }
1055         LeaveCriticalSection(&monitor_handles_cs);
1056         RegCloseKey(hmonitors);
1057     }
1058     TRACE("%d monitors loaded\n", loaded);
1059     return loaded;
1060 }
1061
1062 /******************************************************************
1063  * monitor_loadui [internal]
1064  *
1065  * load the userinterface-dll for a given portmonitor
1066  *
1067  * On failure, NULL is returned
1068  */
1069
1070 static monitor_t * monitor_loadui(monitor_t * pm)
1071 {
1072     monitor_t * pui = NULL;
1073     LPWSTR  buffer[MAX_PATH];
1074     HANDLE  hXcv;
1075     DWORD   len;
1076     DWORD   res;
1077
1078     if (pm == NULL) return NULL;
1079     TRACE("(%p) => dllname: %s\n", pm, debugstr_w(pm->dllname));
1080
1081     /* Try the Portmonitor first; works for many monitors */
1082     if (pm->monitorUI) {
1083         EnterCriticalSection(&monitor_handles_cs);
1084         pm->refcount++;
1085         LeaveCriticalSection(&monitor_handles_cs);
1086         return pm;
1087     }
1088
1089     /* query the userinterface-dllname from the Portmonitor */
1090     if ((pm->monitor) && (pm->monitor->pfnXcvDataPort)) {
1091         /* building (",XcvMonitor %s",pm->name) not needed yet */
1092         res = pm->monitor->pfnXcvOpenPort(emptyStringW, SERVER_ACCESS_ADMINISTER, &hXcv);
1093         TRACE("got %u with %p\n", res, hXcv);
1094         if (res) {
1095             res = pm->monitor->pfnXcvDataPort(hXcv, MonitorUIW, NULL, 0, (BYTE *) buffer, sizeof(buffer), &len);
1096             TRACE("got %u with %s\n", res, debugstr_w((LPWSTR) buffer));
1097             if (res == ERROR_SUCCESS) pui = monitor_load(NULL, (LPWSTR) buffer);
1098             pm->monitor->pfnXcvClosePort(hXcv);
1099         }
1100     }
1101     return pui;
1102 }
1103
1104
1105 /******************************************************************
1106  * monitor_load_by_port [internal]
1107  *
1108  * load a printmonitor for a given port
1109  *
1110  * On failure, NULL is returned
1111  */
1112
1113 static monitor_t * monitor_load_by_port(LPCWSTR portname)
1114 {
1115     HKEY    hroot;
1116     HKEY    hport;
1117     LPWSTR  buffer;
1118     monitor_t * pm = NULL;
1119     DWORD   registered = 0;
1120     DWORD   id = 0;
1121     DWORD   len;
1122
1123     TRACE("(%s)\n", debugstr_w(portname));
1124
1125     /* Try the Local Monitor first */
1126     if (RegOpenKeyW(HKEY_LOCAL_MACHINE, WinNT_CV_PortsW, &hroot) == ERROR_SUCCESS) {
1127         if (RegQueryValueExW(hroot, portname, NULL, NULL, NULL, &len) == ERROR_SUCCESS) {
1128             /* found the portname */
1129             RegCloseKey(hroot);
1130             return monitor_load(LocalPortW, NULL);
1131         }
1132         RegCloseKey(hroot);
1133     }
1134
1135     len = MAX_PATH + lstrlenW(bs_Ports_bsW) + lstrlenW(portname) + 1;
1136     buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1137     if (buffer == NULL) return NULL;
1138
1139     if (RegOpenKeyW(HKEY_LOCAL_MACHINE, MonitorsW, &hroot) == ERROR_SUCCESS) {
1140         EnterCriticalSection(&monitor_handles_cs);
1141         RegQueryInfoKeyW(hroot, NULL, NULL, NULL, &registered, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1142
1143         while ((pm == NULL) && (id < registered)) {
1144             buffer[0] = '\0';
1145             RegEnumKeyW(hroot, id, buffer, MAX_PATH);
1146             TRACE("testing %s\n", debugstr_w(buffer));
1147             len = lstrlenW(buffer);
1148             lstrcatW(buffer, bs_Ports_bsW);
1149             lstrcatW(buffer, portname);
1150             if (RegOpenKeyW(hroot, buffer, &hport) == ERROR_SUCCESS) {
1151                 RegCloseKey(hport);
1152                 buffer[len] = '\0';             /* use only the Monitor-Name */
1153                 pm = monitor_load(buffer, NULL);
1154             }
1155             id++;
1156         }
1157         LeaveCriticalSection(&monitor_handles_cs);
1158         RegCloseKey(hroot);
1159     }
1160     HeapFree(GetProcessHeap(), 0, buffer);
1161     return pm;
1162 }
1163
1164 /******************************************************************
1165  * enumerate the local Ports from all loaded monitors (internal)
1166  *
1167  * returns the needed size (in bytes) for pPorts
1168  * and  *lpreturned is set to number of entries returned in pPorts
1169  *
1170  */
1171 static DWORD get_ports_from_all_monitors(DWORD level, LPBYTE pPorts, DWORD cbBuf, LPDWORD lpreturned)
1172 {
1173     monitor_t * pm;
1174     LPWSTR      ptr;
1175     LPPORT_INFO_2W cache;
1176     LPPORT_INFO_2W out;
1177     LPBYTE  pi_buffer = NULL;
1178     DWORD   pi_allocated = 0;
1179     DWORD   pi_needed;
1180     DWORD   pi_index;
1181     DWORD   pi_returned;
1182     DWORD   res;
1183     DWORD   outindex = 0;
1184     DWORD   needed;
1185     DWORD   numentries;
1186     DWORD   entrysize;
1187
1188
1189     TRACE("(%d, %p, %d, %p)\n", level, pPorts, cbBuf, lpreturned);
1190     entrysize = (level == 1) ? sizeof(PORT_INFO_1W) : sizeof(PORT_INFO_2W);
1191
1192     numentries = *lpreturned;       /* this is 0, when we scan the registry */
1193     needed = entrysize * numentries;
1194     ptr = (LPWSTR) &pPorts[needed];
1195
1196     numentries = 0;
1197     needed = 0;
1198
1199     LIST_FOR_EACH_ENTRY(pm, &monitor_handles, monitor_t, entry)
1200     {
1201         if ((pm->monitor) && (pm->monitor->pfnEnumPorts)) {
1202             pi_needed = 0;
1203             pi_returned = 0;
1204             res = pm->monitor->pfnEnumPorts(NULL, level, pi_buffer, pi_allocated, &pi_needed, &pi_returned);
1205             if (!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
1206                 /* Do not use HeapReAlloc (we do not need the old data in the buffer) */
1207                 HeapFree(GetProcessHeap(), 0, pi_buffer);
1208                 pi_buffer = HeapAlloc(GetProcessHeap(), 0, pi_needed);
1209                 pi_allocated = (pi_buffer) ? pi_needed : 0;
1210                 res = pm->monitor->pfnEnumPorts(NULL, level, pi_buffer, pi_allocated, &pi_needed, &pi_returned);
1211             }
1212             TRACE(  "(%s) got %d with %d (need %d byte for %d entries)\n",
1213                     debugstr_w(pm->name), res, GetLastError(), pi_needed, pi_returned);
1214
1215             numentries += pi_returned;
1216             needed += pi_needed;
1217
1218             /* fill the output-buffer (pPorts), if we have one */
1219             if (pPorts && (cbBuf >= needed ) && pi_buffer) {
1220                 pi_index = 0;
1221                 while (pi_returned > pi_index) {
1222                     cache = (LPPORT_INFO_2W) &pi_buffer[pi_index * entrysize];
1223                     out = (LPPORT_INFO_2W) &pPorts[outindex * entrysize];
1224                     out->pPortName = ptr;
1225                     lstrcpyW(ptr, cache->pPortName);
1226                     ptr += (lstrlenW(ptr)+1);
1227                     if (level > 1) {
1228                         out->pMonitorName = ptr;
1229                         lstrcpyW(ptr,  cache->pMonitorName);
1230                         ptr += (lstrlenW(ptr)+1);
1231
1232                         out->pDescription = ptr;
1233                         lstrcpyW(ptr,  cache->pDescription);
1234                         ptr += (lstrlenW(ptr)+1);
1235                         out->fPortType = cache->fPortType;
1236                         out->Reserved = cache->Reserved;
1237                     }
1238                     pi_index++;
1239                     outindex++;
1240                 }
1241             }
1242         }
1243     }
1244     /* the temporary portinfo-buffer is no longer needed */
1245     HeapFree(GetProcessHeap(), 0, pi_buffer);
1246
1247     *lpreturned = numentries;
1248     TRACE("need %d byte for %d entries\n", needed, numentries);
1249     return needed;
1250 }
1251
1252 /******************************************************************
1253  * get_servername_from_name  (internal)
1254  *
1255  * for an external server, a copy of the serverpart from the full name is returned
1256  *
1257  */
1258 static LPWSTR get_servername_from_name(LPCWSTR name)
1259 {
1260     LPWSTR  server;
1261     LPWSTR  ptr;
1262     WCHAR   buffer[MAX_PATH];
1263     DWORD   len;
1264
1265     if (name == NULL) return NULL;
1266     if ((name[0] != '\\') || (name[1] != '\\')) return NULL;
1267
1268     server = strdupW(&name[2]);     /* skip over both backslash */
1269     if (server == NULL) return NULL;
1270
1271     /* strip '\' and the printername */
1272     ptr = strchrW(server, '\\');
1273     if (ptr) ptr[0] = '\0';
1274
1275     TRACE("found %s\n", debugstr_w(server));
1276
1277     len = sizeof(buffer)/sizeof(buffer[0]);
1278     if (GetComputerNameW(buffer, &len)) {
1279         if (lstrcmpW(buffer, server) == 0) {
1280             /* The requested Servername is our computername */
1281             HeapFree(GetProcessHeap(), 0, server);
1282             return NULL;
1283         }
1284     }
1285     return server;
1286 }
1287
1288 /******************************************************************
1289  * get_basename_from_name  (internal)
1290  *
1291  * skip over the serverpart from the full name
1292  *
1293  */
1294 static LPCWSTR get_basename_from_name(LPCWSTR name)
1295 {
1296     if (name == NULL)  return NULL;
1297     if ((name[0] == '\\') && (name[1] == '\\')) {
1298         /* skip over the servername and search for the following '\'  */
1299         name = strchrW(&name[2], '\\');
1300         if ((name) && (name[1])) {
1301             /* found a separator ('\') followed by a name:
1302                skip over the separator and return the rest */
1303             name++;
1304         }
1305         else
1306         {
1307             /* no basename present (we found only a servername) */
1308             return NULL;
1309         }
1310     }
1311     return name;
1312 }
1313
1314 /******************************************************************
1315  *  get_opened_printer_entry
1316  *  Get the first place empty in the opened printer table
1317  *
1318  * ToDo:
1319  *  - pDefault is ignored
1320  */
1321 static HANDLE get_opened_printer_entry(LPCWSTR name, LPPRINTER_DEFAULTSW pDefault)
1322 {
1323     UINT_PTR handle = nb_printer_handles, i;
1324     jobqueue_t *queue = NULL;
1325     opened_printer_t *printer = NULL;
1326     LPWSTR  servername;
1327     LPCWSTR printername;
1328     HKEY    hkeyPrinters;
1329     HKEY    hkeyPrinter;
1330     DWORD   len;
1331
1332     servername = get_servername_from_name(name);
1333     if (servername) {
1334         FIXME("server %s not supported\n", debugstr_w(servername));
1335         HeapFree(GetProcessHeap(), 0, servername);
1336         SetLastError(ERROR_INVALID_PRINTER_NAME);
1337         return NULL;
1338     }
1339
1340     printername = get_basename_from_name(name);
1341     if (name != printername) TRACE("converted %s to %s\n", debugstr_w(name), debugstr_w(printername));
1342
1343     /* an empty printername is invalid */
1344     if (printername && (!printername[0])) {
1345         SetLastError(ERROR_INVALID_PARAMETER);
1346         return NULL;
1347     }
1348
1349     EnterCriticalSection(&printer_handles_cs);
1350
1351     for (i = 0; i < nb_printer_handles; i++)
1352     {
1353         if (!printer_handles[i])
1354         {
1355             if(handle == nb_printer_handles)
1356                 handle = i;
1357         }
1358         else
1359         {
1360             if(!queue && (name) && !lstrcmpW(name, printer_handles[i]->name))
1361                 queue = printer_handles[i]->queue;
1362         }
1363     }
1364
1365     if (handle >= nb_printer_handles)
1366     {
1367         opened_printer_t **new_array;
1368         if (printer_handles)
1369             new_array = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, printer_handles,
1370                                      (nb_printer_handles + 16) * sizeof(*new_array) );
1371         else
1372             new_array = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1373                                    (nb_printer_handles + 16) * sizeof(*new_array) );
1374
1375         if (!new_array)
1376         {
1377             handle = 0;
1378             goto end;
1379         }
1380         printer_handles = new_array;
1381         nb_printer_handles += 16;
1382     }
1383
1384     if (!(printer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*printer))))
1385     {
1386         handle = 0;
1387         goto end;
1388     }
1389
1390
1391     /* clone the base name. This is NULL for the printserver */
1392     printer->printername = strdupW(printername);
1393
1394     /* clone the full name */
1395     printer->name = strdupW(name);
1396     if (name && (!printer->name)) {
1397         handle = 0;
1398         goto end;
1399     }
1400
1401     if (printername) {
1402         len = sizeof(XcvMonitorW)/sizeof(WCHAR) - 1;
1403         if (strncmpW(printername, XcvMonitorW, len) == 0) {
1404             /* OpenPrinter(",XcvMonitor " detected */
1405             TRACE(",XcvMonitor: %s\n", debugstr_w(&printername[len]));
1406             printer->pm = monitor_load(&printername[len], NULL);
1407             if (printer->pm == NULL) {
1408                 SetLastError(ERROR_UNKNOWN_PORT);
1409                 handle = 0;
1410                 goto end;
1411             }
1412         }
1413         else
1414         {
1415             len = sizeof(XcvPortW)/sizeof(WCHAR) - 1;
1416             if (strncmpW( printername, XcvPortW, len) == 0) {
1417                 /* OpenPrinter(",XcvPort " detected */
1418                 TRACE(",XcvPort: %s\n", debugstr_w(&printername[len]));
1419                 printer->pm = monitor_load_by_port(&printername[len]);
1420                 if (printer->pm == NULL) {
1421                     SetLastError(ERROR_UNKNOWN_PORT);
1422                     handle = 0;
1423                     goto end;
1424                 }
1425             }
1426         }
1427
1428         if (printer->pm) {
1429             if ((printer->pm->monitor) && (printer->pm->monitor->pfnXcvOpenPort)) {
1430                 printer->pm->monitor->pfnXcvOpenPort(&printername[len],
1431                                                     pDefault ? pDefault->DesiredAccess : 0,
1432                                                     &printer->hXcv);
1433             }
1434             if (printer->hXcv == NULL) {
1435                 SetLastError(ERROR_INVALID_PARAMETER);
1436                 handle = 0;
1437                 goto end;
1438             }
1439         }
1440         else
1441         {
1442             /* Does the Printer exist? */
1443             if (RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) != ERROR_SUCCESS) {
1444                 ERR("Can't create Printers key\n");
1445                 handle = 0;
1446                 goto end;
1447             }
1448             if (RegOpenKeyW(hkeyPrinters, printername, &hkeyPrinter) != ERROR_SUCCESS) {
1449                 WARN("Printer not found in Registry: %s\n", debugstr_w(printername));
1450                 RegCloseKey(hkeyPrinters);
1451                 SetLastError(ERROR_INVALID_PRINTER_NAME);
1452                 handle = 0;
1453                 goto end;
1454             }
1455             RegCloseKey(hkeyPrinter);
1456             RegCloseKey(hkeyPrinters);
1457         }
1458     }
1459     else
1460     {
1461         TRACE("using the local printserver\n");
1462     }
1463
1464     if(queue)
1465         printer->queue = queue;
1466     else
1467     {
1468         printer->queue = HeapAlloc(GetProcessHeap(), 0, sizeof(*queue));
1469         if (!printer->queue) {
1470             handle = 0;
1471             goto end;
1472         }
1473         list_init(&printer->queue->jobs);
1474         printer->queue->ref = 0;
1475     }
1476     InterlockedIncrement(&printer->queue->ref);
1477
1478     printer_handles[handle] = printer;
1479     handle++;
1480 end:
1481     LeaveCriticalSection(&printer_handles_cs);
1482     if (!handle && printer) {
1483         /* Something failed: Free all resources */
1484         if (printer->hXcv) printer->pm->monitor->pfnXcvClosePort(printer->hXcv);
1485         monitor_unload(printer->pm);
1486         HeapFree(GetProcessHeap(), 0, printer->printername);
1487         HeapFree(GetProcessHeap(), 0, printer->name);
1488         if (!queue) HeapFree(GetProcessHeap(), 0, printer->queue);
1489         HeapFree(GetProcessHeap(), 0, printer);
1490     }
1491
1492     return (HANDLE)handle;
1493 }
1494
1495 /******************************************************************
1496  *  get_opened_printer
1497  *  Get the pointer to the opened printer referred by the handle
1498  */
1499 static opened_printer_t *get_opened_printer(HANDLE hprn)
1500 {
1501     UINT_PTR idx = (UINT_PTR)hprn;
1502     opened_printer_t *ret = NULL;
1503
1504     EnterCriticalSection(&printer_handles_cs);
1505
1506     if ((idx > 0) && (idx <= nb_printer_handles)) {
1507         ret = printer_handles[idx - 1];
1508     }
1509     LeaveCriticalSection(&printer_handles_cs);
1510     return ret;
1511 }
1512
1513 /******************************************************************
1514  *  get_opened_printer_name
1515  *  Get the pointer to the opened printer name referred by the handle
1516  */
1517 static LPCWSTR get_opened_printer_name(HANDLE hprn)
1518 {
1519     opened_printer_t *printer = get_opened_printer(hprn);
1520     if(!printer) return NULL;
1521     return printer->name;
1522 }
1523
1524 /******************************************************************
1525  *  WINSPOOL_GetOpenedPrinterRegKey
1526  *
1527  */
1528 static DWORD WINSPOOL_GetOpenedPrinterRegKey(HANDLE hPrinter, HKEY *phkey)
1529 {
1530     LPCWSTR name = get_opened_printer_name(hPrinter);
1531     DWORD ret;
1532     HKEY hkeyPrinters;
1533
1534     if(!name) return ERROR_INVALID_HANDLE;
1535
1536     if((ret = RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters)) !=
1537        ERROR_SUCCESS)
1538         return ret;
1539
1540     if(RegOpenKeyW(hkeyPrinters, name, phkey) != ERROR_SUCCESS)
1541     {
1542         ERR("Can't find opened printer %s in registry\n",
1543             debugstr_w(name));
1544         RegCloseKey(hkeyPrinters);
1545         return ERROR_INVALID_PRINTER_NAME; /* ? */
1546     }
1547     RegCloseKey(hkeyPrinters);
1548     return ERROR_SUCCESS;
1549 }
1550
1551 void WINSPOOL_LoadSystemPrinters(void)
1552 {
1553     HKEY                hkey, hkeyPrinters;
1554     HANDLE              hprn;
1555     DWORD               needed, num, i;
1556     WCHAR               PrinterName[256];
1557     BOOL                done = FALSE;
1558
1559     /* This ensures that all printer entries have a valid Name value.  If causes
1560        problems later if they don't.  If one is found to be missed we create one
1561        and set it equal to the name of the key */
1562     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) == ERROR_SUCCESS) {
1563         if(RegQueryInfoKeyA(hkeyPrinters, NULL, NULL, NULL, &num, NULL, NULL,
1564                             NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
1565             for(i = 0; i < num; i++) {
1566                 if(RegEnumKeyW(hkeyPrinters, i, PrinterName, sizeof(PrinterName)/sizeof(PrinterName[0])) == ERROR_SUCCESS) {
1567                     if(RegOpenKeyW(hkeyPrinters, PrinterName, &hkey) == ERROR_SUCCESS) {
1568                         if(RegQueryValueExW(hkey, NameW, 0, 0, 0, &needed) == ERROR_FILE_NOT_FOUND) {
1569                             set_reg_szW(hkey, NameW, PrinterName);
1570                         }
1571                         RegCloseKey(hkey);
1572                     }
1573                 }
1574             }
1575         }
1576         RegCloseKey(hkeyPrinters);
1577     }
1578
1579     /* We want to avoid calling AddPrinter on printers as much as
1580        possible, because on cups printers this will (eventually) lead
1581        to a call to cupsGetPPD which takes forever, even with non-cups
1582        printers AddPrinter takes a while.  So we'll tag all printers that
1583        were automatically added last time around, if they still exist
1584        we'll leave them be otherwise we'll delete them. */
1585     EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, NULL, 0, &needed, &num);
1586     if(needed) {
1587         PRINTER_INFO_5A* pi = HeapAlloc(GetProcessHeap(), 0, needed);
1588         if(EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, (LPBYTE)pi, needed, &needed, &num)) {
1589             for(i = 0; i < num; i++) {
1590                 if(pi[i].pPortName == NULL || !strncmp(pi[i].pPortName,"CUPS:", 5) || !strncmp(pi[i].pPortName, "LPR:", 4)) {
1591                     if(OpenPrinterA(pi[i].pPrinterName, &hprn, NULL)) {
1592                         if(WINSPOOL_GetOpenedPrinterRegKey(hprn, &hkey) == ERROR_SUCCESS) {
1593                             DWORD dw = 1;
1594                             RegSetValueExW(hkey, May_Delete_Value, 0, REG_DWORD, (LPBYTE)&dw, sizeof(dw));
1595                             RegCloseKey(hkey);
1596                         }
1597                         ClosePrinter(hprn);
1598                     }
1599                 }
1600             }
1601         }
1602         HeapFree(GetProcessHeap(), 0, pi);
1603     }
1604
1605
1606 #ifdef SONAME_LIBCUPS
1607     done = CUPS_LoadPrinters();
1608 #endif
1609
1610     if(!done) /* If we have any CUPS based printers, skip looking for printcap printers */
1611         PRINTCAP_LoadPrinters();
1612
1613     /* Now enumerate the list again and delete any printers that are still tagged */
1614     EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, NULL, 0, &needed, &num);
1615     if(needed) {
1616         PRINTER_INFO_5A* pi = HeapAlloc(GetProcessHeap(), 0, needed);
1617         if(EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, (LPBYTE)pi, needed, &needed, &num)) {
1618             for(i = 0; i < num; i++) {
1619                 if(pi[i].pPortName == NULL || !strncmp(pi[i].pPortName,"CUPS:", 5) || !strncmp(pi[i].pPortName, "LPR:", 4)) {
1620                     if(OpenPrinterA(pi[i].pPrinterName, &hprn, NULL)) {
1621                         BOOL delete_driver = FALSE;
1622                         if(WINSPOOL_GetOpenedPrinterRegKey(hprn, &hkey) == ERROR_SUCCESS) {
1623                             DWORD dw, type, size = sizeof(dw);
1624                             if(RegQueryValueExW(hkey, May_Delete_Value, NULL, &type, (LPBYTE)&dw, &size) == ERROR_SUCCESS) {
1625                                 TRACE("Deleting old printer %s\n", pi[i].pPrinterName);
1626                                 DeletePrinter(hprn);
1627                                 delete_driver = TRUE;
1628                             }
1629                             RegCloseKey(hkey);
1630                         }
1631                         ClosePrinter(hprn);
1632                         if(delete_driver)
1633                             DeletePrinterDriverExA(NULL, NULL, pi[i].pPrinterName, 0, 0);
1634                     }
1635                 }
1636             }
1637         }
1638         HeapFree(GetProcessHeap(), 0, pi);
1639     }
1640
1641     return;
1642
1643 }
1644
1645 /******************************************************************
1646  *                  get_job
1647  *
1648  *  Get the pointer to the specified job.
1649  *  Should hold the printer_handles_cs before calling.
1650  */
1651 static job_t *get_job(HANDLE hprn, DWORD JobId)
1652 {
1653     opened_printer_t *printer = get_opened_printer(hprn);
1654     job_t *job;
1655
1656     if(!printer) return NULL;
1657     LIST_FOR_EACH_ENTRY(job, &printer->queue->jobs, job_t, entry)
1658     {
1659         if(job->job_id == JobId)
1660             return job;
1661     }
1662     return NULL;
1663 }
1664
1665 /***********************************************************
1666  *      DEVMODEcpyAtoW
1667  */
1668 static LPDEVMODEW DEVMODEcpyAtoW(DEVMODEW *dmW, const DEVMODEA *dmA)
1669 {
1670     BOOL Formname;
1671     ptrdiff_t off_formname = (const char *)dmA->dmFormName - (const char *)dmA;
1672     DWORD size;
1673
1674     Formname = (dmA->dmSize > off_formname);
1675     size = dmA->dmSize + CCHDEVICENAME + (Formname ? CCHFORMNAME : 0);
1676     MultiByteToWideChar(CP_ACP, 0, (LPCSTR)dmA->dmDeviceName, -1,
1677                         dmW->dmDeviceName, CCHDEVICENAME);
1678     if(!Formname) {
1679       memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
1680              dmA->dmSize - CCHDEVICENAME);
1681     } else {
1682       memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
1683              off_formname - CCHDEVICENAME);
1684       MultiByteToWideChar(CP_ACP, 0, (LPCSTR)dmA->dmFormName, -1,
1685                           dmW->dmFormName, CCHFORMNAME);
1686       memcpy(&dmW->dmLogPixels, &dmA->dmLogPixels, dmA->dmSize -
1687              (off_formname + CCHFORMNAME));
1688     }
1689     dmW->dmSize = size;
1690     memcpy((char *)dmW + dmW->dmSize, (const char *)dmA + dmA->dmSize,
1691            dmA->dmDriverExtra);
1692     return dmW;
1693 }
1694
1695 /***********************************************************
1696  * DEVMODEdupWtoA
1697  * Creates an ansi copy of supplied devmode
1698  */
1699 static LPDEVMODEA DEVMODEdupWtoA(const DEVMODEW *dmW)
1700 {
1701     LPDEVMODEA dmA;
1702     DWORD size;
1703
1704     if (!dmW) return NULL;
1705     size = dmW->dmSize - CCHDEVICENAME -
1706                         ((dmW->dmSize > FIELD_OFFSET(DEVMODEW, dmFormName)) ? CCHFORMNAME : 0);
1707
1708     dmA = HeapAlloc(GetProcessHeap(), 0, size + dmW->dmDriverExtra);
1709     if (!dmA) return NULL;
1710
1711     WideCharToMultiByte(CP_ACP, 0, dmW->dmDeviceName, -1,
1712                         (LPSTR)dmA->dmDeviceName, CCHDEVICENAME, NULL, NULL);
1713
1714     if (FIELD_OFFSET(DEVMODEW, dmFormName) >= dmW->dmSize) {
1715         memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
1716                dmW->dmSize - FIELD_OFFSET(DEVMODEW, dmSpecVersion));
1717     }
1718     else
1719     {
1720         memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
1721                FIELD_OFFSET(DEVMODEW, dmFormName) - FIELD_OFFSET(DEVMODEW, dmSpecVersion));
1722         WideCharToMultiByte(CP_ACP, 0, dmW->dmFormName, -1,
1723                             (LPSTR)dmA->dmFormName, CCHFORMNAME, NULL, NULL);
1724
1725         memcpy(&dmA->dmLogPixels, &dmW->dmLogPixels, dmW->dmSize - FIELD_OFFSET(DEVMODEW, dmLogPixels));
1726     }
1727
1728     dmA->dmSize = size;
1729     memcpy((char *)dmA + dmA->dmSize, (const char *)dmW + dmW->dmSize, dmW->dmDriverExtra);
1730     return dmA;
1731 }
1732
1733 /***********************************************************
1734  *             PRINTER_INFO_2AtoW
1735  * Creates a unicode copy of PRINTER_INFO_2A on heap
1736  */
1737 static LPPRINTER_INFO_2W PRINTER_INFO_2AtoW(HANDLE heap, LPPRINTER_INFO_2A piA)
1738 {
1739     LPPRINTER_INFO_2W piW;
1740     UNICODE_STRING usBuffer;
1741
1742     if(!piA) return NULL;
1743     piW = HeapAlloc(heap, 0, sizeof(*piW));
1744     memcpy(piW, piA, sizeof(*piW)); /* copy everything first */
1745
1746     piW->pServerName = asciitounicode(&usBuffer,piA->pServerName);
1747     piW->pPrinterName = asciitounicode(&usBuffer,piA->pPrinterName);
1748     piW->pShareName = asciitounicode(&usBuffer,piA->pShareName);
1749     piW->pPortName = asciitounicode(&usBuffer,piA->pPortName);
1750     piW->pDriverName = asciitounicode(&usBuffer,piA->pDriverName);
1751     piW->pComment = asciitounicode(&usBuffer,piA->pComment);
1752     piW->pLocation = asciitounicode(&usBuffer,piA->pLocation);
1753     piW->pDevMode = piA->pDevMode ? GdiConvertToDevmodeW(piA->pDevMode) : NULL;
1754     piW->pSepFile = asciitounicode(&usBuffer,piA->pSepFile);
1755     piW->pPrintProcessor = asciitounicode(&usBuffer,piA->pPrintProcessor);
1756     piW->pDatatype = asciitounicode(&usBuffer,piA->pDatatype);
1757     piW->pParameters = asciitounicode(&usBuffer,piA->pParameters);
1758     return piW;
1759 }
1760
1761 /***********************************************************
1762  *       FREE_PRINTER_INFO_2W
1763  * Free PRINTER_INFO_2W and all strings
1764  */
1765 static void FREE_PRINTER_INFO_2W(HANDLE heap, LPPRINTER_INFO_2W piW)
1766 {
1767     if(!piW) return;
1768
1769     HeapFree(heap,0,piW->pServerName);
1770     HeapFree(heap,0,piW->pPrinterName);
1771     HeapFree(heap,0,piW->pShareName);
1772     HeapFree(heap,0,piW->pPortName);
1773     HeapFree(heap,0,piW->pDriverName);
1774     HeapFree(heap,0,piW->pComment);
1775     HeapFree(heap,0,piW->pLocation);
1776     HeapFree(heap,0,piW->pDevMode);
1777     HeapFree(heap,0,piW->pSepFile);
1778     HeapFree(heap,0,piW->pPrintProcessor);
1779     HeapFree(heap,0,piW->pDatatype);
1780     HeapFree(heap,0,piW->pParameters);
1781     HeapFree(heap,0,piW);
1782     return;
1783 }
1784
1785 /******************************************************************
1786  *              DeviceCapabilities     [WINSPOOL.@]
1787  *              DeviceCapabilitiesA    [WINSPOOL.@]
1788  *
1789  */
1790 INT WINAPI DeviceCapabilitiesA(LPCSTR pDevice,LPCSTR pPort, WORD cap,
1791                                LPSTR pOutput, LPDEVMODEA lpdm)
1792 {
1793     INT ret;
1794
1795     if (!GDI_CallDeviceCapabilities16)
1796     {
1797         GDI_CallDeviceCapabilities16 = (void*)GetProcAddress( GetModuleHandleA("gdi32"),
1798                                                               (LPCSTR)104 );
1799         if (!GDI_CallDeviceCapabilities16) return -1;
1800     }
1801     ret = GDI_CallDeviceCapabilities16(pDevice, pPort, cap, pOutput, lpdm);
1802
1803     /* If DC_PAPERSIZE map POINT16s to POINTs */
1804     if(ret != -1 && cap == DC_PAPERSIZE && pOutput) {
1805         POINT16 *tmp = HeapAlloc( GetProcessHeap(), 0, ret * sizeof(POINT16) );
1806         POINT *pt = (POINT *)pOutput;
1807         INT i;
1808         memcpy(tmp, pOutput, ret * sizeof(POINT16));
1809         for(i = 0; i < ret; i++, pt++)
1810         {
1811             pt->x = tmp[i].x;
1812             pt->y = tmp[i].y;
1813         }
1814         HeapFree( GetProcessHeap(), 0, tmp );
1815     }
1816     return ret;
1817 }
1818
1819
1820 /*****************************************************************************
1821  *          DeviceCapabilitiesW        [WINSPOOL.@]
1822  *
1823  * Call DeviceCapabilitiesA since we later call 16bit stuff anyway
1824  *
1825  */
1826 INT WINAPI DeviceCapabilitiesW(LPCWSTR pDevice, LPCWSTR pPort,
1827                                WORD fwCapability, LPWSTR pOutput,
1828                                const DEVMODEW *pDevMode)
1829 {
1830     LPDEVMODEA dmA = DEVMODEdupWtoA(pDevMode);
1831     LPSTR pDeviceA = strdupWtoA(pDevice);
1832     LPSTR pPortA = strdupWtoA(pPort);
1833     INT ret;
1834
1835     if(pOutput && (fwCapability == DC_BINNAMES ||
1836                    fwCapability == DC_FILEDEPENDENCIES ||
1837                    fwCapability == DC_PAPERNAMES)) {
1838       /* These need A -> W translation */
1839         INT size = 0, i;
1840         LPSTR pOutputA;
1841         ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, NULL,
1842                                   dmA);
1843         if(ret == -1)
1844             return ret;
1845         switch(fwCapability) {
1846         case DC_BINNAMES:
1847             size = 24;
1848             break;
1849         case DC_PAPERNAMES:
1850         case DC_FILEDEPENDENCIES:
1851             size = 64;
1852             break;
1853         }
1854         pOutputA = HeapAlloc(GetProcessHeap(), 0, size * ret);
1855         ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, pOutputA,
1856                                   dmA);
1857         for(i = 0; i < ret; i++)
1858             MultiByteToWideChar(CP_ACP, 0, pOutputA + (i * size), -1,
1859                                 pOutput + (i * size), size);
1860         HeapFree(GetProcessHeap(), 0, pOutputA);
1861     } else {
1862         ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability,
1863                                   (LPSTR)pOutput, dmA);
1864     }
1865     HeapFree(GetProcessHeap(),0,pPortA);
1866     HeapFree(GetProcessHeap(),0,pDeviceA);
1867     HeapFree(GetProcessHeap(),0,dmA);
1868     return ret;
1869 }
1870
1871 /******************************************************************
1872  *              DocumentPropertiesA   [WINSPOOL.@]
1873  *
1874  * FIXME: implement DocumentPropertiesA via DocumentPropertiesW, not vice versa
1875  */
1876 LONG WINAPI DocumentPropertiesA(HWND hWnd,HANDLE hPrinter,
1877                                 LPSTR pDeviceName, LPDEVMODEA pDevModeOutput,
1878                                 LPDEVMODEA pDevModeInput,DWORD fMode )
1879 {
1880     LPSTR lpName = pDeviceName;
1881     static CHAR port[] = "LPT1:";
1882     LONG ret;
1883
1884     TRACE("(%p,%p,%s,%p,%p,%d)\n",
1885         hWnd,hPrinter,pDeviceName,pDevModeOutput,pDevModeInput,fMode
1886     );
1887
1888     if(!pDeviceName) {
1889         LPCWSTR lpNameW = get_opened_printer_name(hPrinter);
1890         if(!lpNameW) {
1891                 ERR("no name from hPrinter?\n");
1892                 SetLastError(ERROR_INVALID_HANDLE);
1893                 return -1;
1894         }
1895         lpName = strdupWtoA(lpNameW);
1896     }
1897
1898     if (!GDI_CallExtDeviceMode16)
1899     {
1900         GDI_CallExtDeviceMode16 = (void*)GetProcAddress( GetModuleHandleA("gdi32"),
1901                                                          (LPCSTR)102 );
1902         if (!GDI_CallExtDeviceMode16) {
1903                 ERR("No CallExtDeviceMode16?\n");
1904                 return -1;
1905         }
1906     }
1907     ret = GDI_CallExtDeviceMode16(hWnd, pDevModeOutput, lpName, port,
1908                                   pDevModeInput, NULL, fMode);
1909
1910     if(!pDeviceName)
1911         HeapFree(GetProcessHeap(),0,lpName);
1912     return ret;
1913 }
1914
1915
1916 /*****************************************************************************
1917  *          DocumentPropertiesW (WINSPOOL.@)
1918  *
1919  * FIXME: implement DocumentPropertiesA via DocumentPropertiesW, not vice versa
1920  */
1921 LONG WINAPI DocumentPropertiesW(HWND hWnd, HANDLE hPrinter,
1922                                 LPWSTR pDeviceName,
1923                                 LPDEVMODEW pDevModeOutput,
1924                                 LPDEVMODEW pDevModeInput, DWORD fMode)
1925 {
1926
1927     LPSTR pDeviceNameA = strdupWtoA(pDeviceName);
1928     LPDEVMODEA pDevModeInputA = DEVMODEdupWtoA(pDevModeInput);
1929     LPDEVMODEA pDevModeOutputA = NULL;
1930     LONG ret;
1931
1932     TRACE("(%p,%p,%s,%p,%p,%d)\n",
1933           hWnd,hPrinter,debugstr_w(pDeviceName),pDevModeOutput,pDevModeInput,
1934           fMode);
1935     if(pDevModeOutput) {
1936         ret = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameA, NULL, NULL, 0);
1937         if(ret < 0) return ret;
1938         pDevModeOutputA = HeapAlloc(GetProcessHeap(), 0, ret);
1939     }
1940     ret = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameA, pDevModeOutputA,
1941                               pDevModeInputA, fMode);
1942     if(pDevModeOutput) {
1943         DEVMODEcpyAtoW(pDevModeOutput, pDevModeOutputA);
1944         HeapFree(GetProcessHeap(),0,pDevModeOutputA);
1945     }
1946     if(fMode == 0 && ret > 0)
1947         ret += (CCHDEVICENAME + CCHFORMNAME);
1948     HeapFree(GetProcessHeap(),0,pDevModeInputA);
1949     HeapFree(GetProcessHeap(),0,pDeviceNameA);
1950     return ret;
1951 }
1952
1953 /******************************************************************
1954  *              OpenPrinterA        [WINSPOOL.@]
1955  *
1956  * See OpenPrinterW.
1957  *
1958  */
1959 BOOL WINAPI OpenPrinterA(LPSTR lpPrinterName,HANDLE *phPrinter,
1960                          LPPRINTER_DEFAULTSA pDefault)
1961 {
1962     UNICODE_STRING lpPrinterNameW;
1963     UNICODE_STRING usBuffer;
1964     PRINTER_DEFAULTSW DefaultW, *pDefaultW = NULL;
1965     PWSTR pwstrPrinterNameW;
1966     BOOL ret;
1967
1968     pwstrPrinterNameW = asciitounicode(&lpPrinterNameW,lpPrinterName);
1969
1970     if(pDefault) {
1971         DefaultW.pDatatype = asciitounicode(&usBuffer,pDefault->pDatatype);
1972         DefaultW.pDevMode = pDefault->pDevMode ? GdiConvertToDevmodeW(pDefault->pDevMode) : NULL;
1973         DefaultW.DesiredAccess = pDefault->DesiredAccess;
1974         pDefaultW = &DefaultW;
1975     }
1976     ret = OpenPrinterW(pwstrPrinterNameW, phPrinter, pDefaultW);
1977     if(pDefault) {
1978         RtlFreeUnicodeString(&usBuffer);
1979         HeapFree(GetProcessHeap(), 0, DefaultW.pDevMode);
1980     }
1981     RtlFreeUnicodeString(&lpPrinterNameW);
1982     return ret;
1983 }
1984
1985 /******************************************************************
1986  *              OpenPrinterW        [WINSPOOL.@]
1987  *
1988  * Open a Printer / Printserver or a Printer-Object
1989  *
1990  * PARAMS
1991  *  lpPrinterName [I] Name of Printserver, Printer, or Printer-Object
1992  *  phPrinter     [O] The resulting Handle is stored here
1993  *  pDefault      [I] PTR to Default Printer Settings or NULL
1994  *
1995  * RETURNS
1996  *  Success: TRUE
1997  *  Failure: FALSE
1998  *
1999  * NOTES
2000  *  lpPrinterName is one of:
2001  *|  Printserver (NT only): "Servername" or NULL for the local Printserver
2002  *|  Printer: "PrinterName"
2003  *|  Printer-Object: "PrinterName,Job xxx"
2004  *|  XcvMonitor: "Servername,XcvMonitor MonitorName"
2005  *|  XcvPort: "Servername,XcvPort PortName"
2006  *
2007  * BUGS
2008  *|  Printer-Object not supported
2009  *|  pDefaults is ignored
2010  *
2011  */
2012 BOOL WINAPI OpenPrinterW(LPWSTR lpPrinterName,HANDLE *phPrinter, LPPRINTER_DEFAULTSW pDefault)
2013 {
2014
2015     TRACE("(%s, %p, %p)\n", debugstr_w(lpPrinterName), phPrinter, pDefault);
2016     if (pDefault) {
2017         FIXME("PRINTER_DEFAULTS ignored => %s,%p,0x%08x\n",
2018         debugstr_w(pDefault->pDatatype), pDefault->pDevMode, pDefault->DesiredAccess);
2019     }
2020
2021     if(!phPrinter) {
2022         /* NT: FALSE with ERROR_INVALID_PARAMETER, 9x: TRUE */
2023         SetLastError(ERROR_INVALID_PARAMETER);
2024         return FALSE;
2025     }
2026
2027     /* Get the unique handle of the printer or Printserver */
2028     *phPrinter = get_opened_printer_entry(lpPrinterName, pDefault);
2029     TRACE("returning %d with %u and %p\n", *phPrinter != NULL, GetLastError(), *phPrinter);
2030     return (*phPrinter != 0);
2031 }
2032
2033 /******************************************************************
2034  *              AddMonitorA        [WINSPOOL.@]
2035  *
2036  * See AddMonitorW.
2037  *
2038  */
2039 BOOL WINAPI AddMonitorA(LPSTR pName, DWORD Level, LPBYTE pMonitors)
2040 {
2041     LPWSTR  nameW = NULL;
2042     INT     len;
2043     BOOL    res;
2044     LPMONITOR_INFO_2A mi2a;
2045     MONITOR_INFO_2W mi2w;
2046
2047     mi2a = (LPMONITOR_INFO_2A) pMonitors;
2048     TRACE("(%s, %d, %p) :  %s %s %s\n", debugstr_a(pName), Level, pMonitors,
2049             mi2a ? debugstr_a(mi2a->pName) : NULL,
2050             mi2a ? debugstr_a(mi2a->pEnvironment) : NULL,
2051             mi2a ? debugstr_a(mi2a->pDLLName) : NULL);
2052
2053     if  (Level != 2) {
2054         SetLastError(ERROR_INVALID_LEVEL);
2055         return FALSE;
2056     }
2057
2058     /* XP: unchanged, win9x: ERROR_INVALID_ENVIRONMENT */
2059     if (mi2a == NULL) {
2060         return FALSE;
2061     }
2062
2063     if (pName) {
2064         len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
2065         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2066         MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
2067     }
2068
2069     memset(&mi2w, 0, sizeof(MONITOR_INFO_2W));
2070     if (mi2a->pName) {
2071         len = MultiByteToWideChar(CP_ACP, 0, mi2a->pName, -1, NULL, 0);
2072         mi2w.pName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2073         MultiByteToWideChar(CP_ACP, 0, mi2a->pName, -1, mi2w.pName, len);
2074     }
2075     if (mi2a->pEnvironment) {
2076         len = MultiByteToWideChar(CP_ACP, 0, mi2a->pEnvironment, -1, NULL, 0);
2077         mi2w.pEnvironment = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2078         MultiByteToWideChar(CP_ACP, 0, mi2a->pEnvironment, -1, mi2w.pEnvironment, len);
2079     }
2080     if (mi2a->pDLLName) {
2081         len = MultiByteToWideChar(CP_ACP, 0, mi2a->pDLLName, -1, NULL, 0);
2082         mi2w.pDLLName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2083         MultiByteToWideChar(CP_ACP, 0, mi2a->pDLLName, -1, mi2w.pDLLName, len);
2084     }
2085
2086     res = AddMonitorW(nameW, Level, (LPBYTE) &mi2w);
2087
2088     HeapFree(GetProcessHeap(), 0, mi2w.pName);
2089     HeapFree(GetProcessHeap(), 0, mi2w.pEnvironment);
2090     HeapFree(GetProcessHeap(), 0, mi2w.pDLLName);
2091
2092     HeapFree(GetProcessHeap(), 0, nameW);
2093     return (res);
2094 }
2095
2096 /******************************************************************************
2097  *              AddMonitorW        [WINSPOOL.@]
2098  *
2099  * Install a Printmonitor
2100  *
2101  * PARAMS
2102  *  pName       [I] Servername or NULL (local Computer)
2103  *  Level       [I] Structure-Level (Must be 2)
2104  *  pMonitors   [I] PTR to MONITOR_INFO_2
2105  *
2106  * RETURNS
2107  *  Success: TRUE
2108  *  Failure: FALSE
2109  *
2110  * NOTES
2111  *  All Files for the Monitor must already be copied to %winsysdir% ("%SystemRoot%\system32")
2112  *
2113  */
2114 BOOL WINAPI AddMonitorW(LPWSTR pName, DWORD Level, LPBYTE pMonitors)
2115 {
2116     monitor_t * pm = NULL;
2117     LPMONITOR_INFO_2W mi2w;
2118     HKEY    hroot = NULL;
2119     HKEY    hentry = NULL;
2120     DWORD   disposition;
2121     BOOL    res = FALSE;
2122
2123     mi2w = (LPMONITOR_INFO_2W) pMonitors;
2124     TRACE("(%s, %d, %p) :  %s %s %s\n", debugstr_w(pName), Level, pMonitors,
2125             mi2w ? debugstr_w(mi2w->pName) : NULL,
2126             mi2w ? debugstr_w(mi2w->pEnvironment) : NULL,
2127             mi2w ? debugstr_w(mi2w->pDLLName) : NULL);
2128
2129     if (Level != 2) {
2130         SetLastError(ERROR_INVALID_LEVEL);
2131         return FALSE;
2132     }
2133
2134     /* XP: unchanged, win9x: ERROR_INVALID_ENVIRONMENT */
2135     if (mi2w == NULL) {
2136         return FALSE;
2137     }
2138
2139     if (pName && (pName[0])) {
2140         FIXME("for server %s not implemented\n", debugstr_w(pName));
2141         SetLastError(ERROR_ACCESS_DENIED);
2142         return FALSE;
2143     }
2144
2145
2146     if (!mi2w->pName || (! mi2w->pName[0])) {
2147         WARN("pName not valid : %s\n", debugstr_w(mi2w->pName));
2148         SetLastError(ERROR_INVALID_PARAMETER);
2149         return FALSE;
2150     }
2151     if (!mi2w->pEnvironment || lstrcmpW(mi2w->pEnvironment, envname_x86W)) {
2152         WARN("Environment %s requested (we support only %s)\n",
2153                 debugstr_w(mi2w->pEnvironment), debugstr_w(envname_x86W));
2154         SetLastError(ERROR_INVALID_ENVIRONMENT);
2155         return FALSE;
2156     }
2157
2158     if (!mi2w->pDLLName || (! mi2w->pDLLName[0])) {
2159         WARN("pDLLName not valid : %s\n", debugstr_w(mi2w->pDLLName));
2160         SetLastError(ERROR_INVALID_PARAMETER);
2161         return FALSE;
2162     }
2163
2164     /* Load and initialize the monitor. SetLastError() is called on failure */
2165     if ((pm = monitor_load(mi2w->pName, mi2w->pDLLName)) == NULL) {
2166         return FALSE;
2167     }
2168     monitor_unload(pm);
2169
2170     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, MonitorsW, &hroot) != ERROR_SUCCESS) {
2171         ERR("unable to create key %s\n", debugstr_w(MonitorsW));
2172         return FALSE;
2173     }
2174
2175     if(RegCreateKeyExW( hroot, mi2w->pName, 0, NULL, REG_OPTION_NON_VOLATILE,
2176                         KEY_WRITE | KEY_QUERY_VALUE, NULL, &hentry,
2177                         &disposition) == ERROR_SUCCESS) {
2178
2179         /* Some installers set options for the port before calling AddMonitor.
2180            We query the "Driver" entry to verify that the monitor is installed,
2181            before we return an error.
2182            When a user installs two print monitors at the same time with the
2183            same name but with a different driver DLL and a task switch comes
2184            between RegQueryValueExW and RegSetValueExW, a race condition
2185            is possible but silently ignored. */
2186
2187         DWORD   namesize = 0;
2188
2189         if ((disposition == REG_OPENED_EXISTING_KEY) &&
2190             (RegQueryValueExW(hentry, DriverW, NULL, NULL, NULL,
2191                               &namesize) == ERROR_SUCCESS)) {
2192             TRACE("monitor %s already exists\n", debugstr_w(mi2w->pName));
2193             /* NT: ERROR_PRINT_MONITOR_ALREADY_INSTALLED (3006)
2194                9x: ERROR_ALREADY_EXISTS (183) */
2195             SetLastError(ERROR_PRINT_MONITOR_ALREADY_INSTALLED);
2196         }
2197         else
2198         {
2199                INT len;
2200                len = (lstrlenW(mi2w->pDLLName) +1) * sizeof(WCHAR);
2201                res = (RegSetValueExW(hentry, DriverW, 0,
2202                       REG_SZ, (LPBYTE) mi2w->pDLLName, len) == ERROR_SUCCESS);
2203         }
2204         RegCloseKey(hentry);
2205     }
2206
2207     RegCloseKey(hroot);
2208     return (res);
2209 }
2210
2211 /******************************************************************
2212  *              DeletePrinterDriverA        [WINSPOOL.@]
2213  *
2214  */
2215 BOOL WINAPI DeletePrinterDriverA (LPSTR pName, LPSTR pEnvironment, LPSTR pDriverName)
2216 {
2217     return DeletePrinterDriverExA(pName, pEnvironment, pDriverName, 0, 0);
2218 }
2219
2220 /******************************************************************
2221  *              DeletePrinterDriverW        [WINSPOOL.@]
2222  *
2223  */
2224 BOOL WINAPI DeletePrinterDriverW (LPWSTR pName, LPWSTR pEnvironment, LPWSTR pDriverName)
2225 {
2226     return DeletePrinterDriverExW(pName, pEnvironment, pDriverName, 0, 0);
2227 }
2228
2229 /******************************************************************
2230  *              DeleteMonitorA        [WINSPOOL.@]
2231  *
2232  * See DeleteMonitorW.
2233  *
2234  */
2235 BOOL WINAPI DeleteMonitorA (LPSTR pName, LPSTR pEnvironment, LPSTR pMonitorName)
2236 {
2237     LPWSTR  nameW = NULL;
2238     LPWSTR  EnvironmentW = NULL;
2239     LPWSTR  MonitorNameW = NULL;
2240     BOOL    res;
2241     INT     len;
2242
2243     if (pName) {
2244         len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
2245         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2246         MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
2247     }
2248
2249     if (pEnvironment) {
2250         len = MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, NULL, 0);
2251         EnvironmentW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2252         MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, EnvironmentW, len);
2253     }
2254     if (pMonitorName) {
2255         len = MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, NULL, 0);
2256         MonitorNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2257         MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, MonitorNameW, len);
2258     }
2259
2260     res = DeleteMonitorW(nameW, EnvironmentW, MonitorNameW);
2261
2262     HeapFree(GetProcessHeap(), 0, MonitorNameW);
2263     HeapFree(GetProcessHeap(), 0, EnvironmentW);
2264     HeapFree(GetProcessHeap(), 0, nameW);
2265     return (res);
2266 }
2267
2268 /******************************************************************
2269  *              DeleteMonitorW        [WINSPOOL.@]
2270  *
2271  * Delete a specific Printmonitor from a Printing-Environment
2272  *
2273  * PARAMS
2274  *  pName        [I] Servername or NULL (local Computer)
2275  *  pEnvironment [I] Printing-Environment of the Monitor or NULL (Default)
2276  *  pMonitorName [I] Name of the Monitor, that should be deleted
2277  *
2278  * RETURNS
2279  *  Success: TRUE
2280  *  Failure: FALSE
2281  *
2282  * NOTES
2283  *  pEnvironment is ignored in Windows for the local Computer.
2284  *
2285  */
2286
2287 BOOL WINAPI DeleteMonitorW (LPWSTR pName, LPWSTR pEnvironment, LPWSTR pMonitorName)
2288 {
2289     HKEY    hroot = NULL;
2290
2291     TRACE("(%s, %s, %s)\n",debugstr_w(pName),debugstr_w(pEnvironment),
2292            debugstr_w(pMonitorName));
2293
2294     if (pName && (pName[0])) {
2295         FIXME("for server %s not implemented\n", debugstr_w(pName));
2296         SetLastError(ERROR_ACCESS_DENIED);
2297         return FALSE;
2298     }
2299
2300     /*  pEnvironment is ignored in Windows for the local Computer */
2301
2302     if (!pMonitorName || !pMonitorName[0]) {
2303         WARN("pMonitorName %s is invalid\n", debugstr_w(pMonitorName));
2304         SetLastError(ERROR_INVALID_PARAMETER);
2305         return FALSE;
2306     }
2307
2308     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, MonitorsW, &hroot) != ERROR_SUCCESS) {
2309         ERR("unable to create key %s\n", debugstr_w(MonitorsW));
2310         return FALSE;
2311     }
2312
2313     if(RegDeleteTreeW(hroot, pMonitorName) == ERROR_SUCCESS) {
2314         TRACE("monitor %s deleted\n", debugstr_w(pMonitorName));
2315         RegCloseKey(hroot);
2316         return TRUE;
2317     }
2318
2319     WARN("monitor %s does not exist\n", debugstr_w(pMonitorName));
2320     RegCloseKey(hroot);
2321
2322     /* NT: ERROR_UNKNOWN_PRINT_MONITOR (3000), 9x: ERROR_INVALID_PARAMETER (87) */
2323     SetLastError(ERROR_UNKNOWN_PRINT_MONITOR);
2324     return (FALSE);
2325 }
2326
2327 /******************************************************************
2328  *              DeletePortA        [WINSPOOL.@]
2329  *
2330  * See DeletePortW.
2331  *
2332  */
2333 BOOL WINAPI DeletePortA (LPSTR pName, HWND hWnd, LPSTR pPortName)
2334 {
2335     LPWSTR  nameW = NULL;
2336     LPWSTR  portW = NULL;
2337     INT     len;
2338     DWORD   res;
2339
2340     TRACE("(%s, %p, %s)\n", debugstr_a(pName), hWnd, debugstr_a(pPortName));
2341
2342     /* convert servername to unicode */
2343     if (pName) {
2344         len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
2345         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2346         MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
2347     }
2348
2349     /* convert portname to unicode */
2350     if (pPortName) {
2351         len = MultiByteToWideChar(CP_ACP, 0, pPortName, -1, NULL, 0);
2352         portW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2353         MultiByteToWideChar(CP_ACP, 0, pPortName, -1, portW, len);
2354     }
2355
2356     res = DeletePortW(nameW, hWnd, portW);
2357     HeapFree(GetProcessHeap(), 0, nameW);
2358     HeapFree(GetProcessHeap(), 0, portW);
2359     return res;
2360 }
2361
2362 /******************************************************************
2363  *              DeletePortW        [WINSPOOL.@]
2364  *
2365  * Delete a specific Port
2366  *
2367  * PARAMS
2368  *  pName     [I] Servername or NULL (local Computer)
2369  *  hWnd      [I] Handle to parent Window for the Dialog-Box
2370  *  pPortName [I] Name of the Port, that should be deleted
2371  *
2372  * RETURNS
2373  *  Success: TRUE
2374  *  Failure: FALSE
2375  *
2376  */
2377 BOOL WINAPI DeletePortW (LPWSTR pName, HWND hWnd, LPWSTR pPortName)
2378 {
2379     monitor_t * pm;
2380     monitor_t * pui;
2381     DWORD       res;
2382
2383     TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
2384
2385     if (pName && pName[0]) {
2386         SetLastError(ERROR_INVALID_PARAMETER);
2387         return FALSE;
2388     }
2389
2390     if (!pPortName) {
2391         SetLastError(RPC_X_NULL_REF_POINTER);
2392         return FALSE;
2393     }
2394
2395     /* an empty Portname is Invalid */
2396     if (!pPortName[0]) {
2397         SetLastError(ERROR_NOT_SUPPORTED);
2398         return FALSE;
2399     }
2400
2401     pm = monitor_load_by_port(pPortName);
2402     if (pm && pm->monitor && pm->monitor->pfnDeletePort) {
2403         TRACE("Using %s for %s (%p: %s)\n", debugstr_w(pm->name), debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
2404         res = pm->monitor->pfnDeletePort(pName, hWnd, pPortName);
2405         TRACE("got %d with %u\n", res, GetLastError());
2406     }
2407     else
2408     {
2409         pui = monitor_loadui(pm);
2410         if (pui && pui->monitorUI && pui->monitorUI->pfnDeletePortUI) {
2411             TRACE("use %s for %s (%p: %s)\n", debugstr_w(pui->name), debugstr_w(pPortName), pui, debugstr_w(pui->dllname));
2412             res = pui->monitorUI->pfnDeletePortUI(pName, hWnd, pPortName);
2413             TRACE("got %d with %u\n", res, GetLastError());
2414         }
2415         else
2416         {
2417             FIXME("not implemented for %s (%p: %s => %p: %s)\n", debugstr_w(pPortName),
2418                 pm, pm ? debugstr_w(pm->dllname) : NULL, pui, pui ? debugstr_w(pui->dllname) : NULL);
2419
2420             /* XP: ERROR_NOT_SUPPORTED, NT351,9x: ERROR_INVALID_PARAMETER */
2421             SetLastError(ERROR_NOT_SUPPORTED);
2422             res = FALSE;
2423         }
2424         monitor_unload(pui);
2425     }
2426     monitor_unload(pm);
2427
2428     TRACE("returning %d with %u\n", res, GetLastError());
2429     return res;
2430 }
2431
2432 /******************************************************************************
2433  *    SetPrinterW  [WINSPOOL.@]
2434  */
2435 BOOL WINAPI SetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD Command)
2436 {
2437     FIXME("(%p, %d, %p, %d): stub\n", hPrinter, Level, pPrinter, Command);
2438     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2439     return FALSE;
2440 }
2441
2442 /******************************************************************************
2443  *    WritePrinter  [WINSPOOL.@]
2444  */
2445 BOOL WINAPI WritePrinter(HANDLE hPrinter, LPVOID pBuf, DWORD cbBuf, LPDWORD pcWritten)
2446 {
2447     opened_printer_t *printer;
2448     BOOL ret = FALSE;
2449
2450     TRACE("(%p, %p, %d, %p)\n", hPrinter, pBuf, cbBuf, pcWritten);
2451
2452     EnterCriticalSection(&printer_handles_cs);
2453     printer = get_opened_printer(hPrinter);
2454     if(!printer)
2455     {
2456         SetLastError(ERROR_INVALID_HANDLE);
2457         goto end;
2458     }
2459
2460     if(!printer->doc)
2461     {
2462         SetLastError(ERROR_SPL_NO_STARTDOC);
2463         goto end;
2464     }
2465
2466     ret = WriteFile(printer->doc->hf, pBuf, cbBuf, pcWritten, NULL);
2467 end:
2468     LeaveCriticalSection(&printer_handles_cs);
2469     return ret;
2470 }
2471
2472 /*****************************************************************************
2473  *          AddFormA  [WINSPOOL.@]
2474  */
2475 BOOL WINAPI AddFormA(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
2476 {
2477     FIXME("(%p,%d,%p): stub\n", hPrinter, Level, pForm);
2478     return 1;
2479 }
2480
2481 /*****************************************************************************
2482  *          AddFormW  [WINSPOOL.@]
2483  */
2484 BOOL WINAPI AddFormW(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
2485 {
2486     FIXME("(%p,%d,%p): stub\n", hPrinter, Level, pForm);
2487     return 1;
2488 }
2489
2490 /*****************************************************************************
2491  *          AddJobA  [WINSPOOL.@]
2492  */
2493 BOOL WINAPI AddJobA(HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf, LPDWORD pcbNeeded)
2494 {
2495     BOOL ret;
2496     BYTE buf[MAX_PATH * sizeof(WCHAR) + sizeof(ADDJOB_INFO_1W)];
2497     DWORD needed;
2498
2499     if(Level != 1) {
2500         SetLastError(ERROR_INVALID_LEVEL);
2501         return FALSE;
2502     }
2503
2504     ret = AddJobW(hPrinter, Level, buf, sizeof(buf), &needed);
2505
2506     if(ret) {
2507         ADDJOB_INFO_1W *addjobW = (ADDJOB_INFO_1W*)buf;
2508         DWORD len = WideCharToMultiByte(CP_ACP, 0, addjobW->Path, -1, NULL, 0, NULL, NULL);
2509         *pcbNeeded = len + sizeof(ADDJOB_INFO_1A);
2510         if(*pcbNeeded > cbBuf) {
2511             SetLastError(ERROR_INSUFFICIENT_BUFFER);
2512             ret = FALSE;
2513         } else {
2514             ADDJOB_INFO_1A *addjobA = (ADDJOB_INFO_1A*)pData;
2515             addjobA->JobId = addjobW->JobId;
2516             addjobA->Path = (char *)(addjobA + 1);
2517             WideCharToMultiByte(CP_ACP, 0, addjobW->Path, -1, addjobA->Path, len, NULL, NULL);
2518         }
2519     }
2520     return ret;
2521 }
2522
2523 /*****************************************************************************
2524  *          AddJobW  [WINSPOOL.@]
2525  */
2526 BOOL WINAPI AddJobW(HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf, LPDWORD pcbNeeded)
2527 {
2528     opened_printer_t *printer;
2529     job_t *job;
2530     BOOL ret = FALSE;
2531     static const WCHAR spool_path[] = {'s','p','o','o','l','\\','P','R','I','N','T','E','R','S','\\',0};
2532     static const WCHAR fmtW[] = {'%','s','%','0','5','d','.','S','P','L',0};
2533     WCHAR path[MAX_PATH], filename[MAX_PATH];
2534     DWORD len;
2535     ADDJOB_INFO_1W *addjob;
2536
2537     TRACE("(%p,%d,%p,%d,%p)\n", hPrinter, Level, pData, cbBuf, pcbNeeded);
2538
2539     EnterCriticalSection(&printer_handles_cs);
2540
2541     printer = get_opened_printer(hPrinter);
2542
2543     if(!printer) {
2544         SetLastError(ERROR_INVALID_HANDLE);
2545         goto end;
2546     }
2547
2548     if(Level != 1) {
2549         SetLastError(ERROR_INVALID_LEVEL);
2550         goto end;
2551     }
2552
2553     job = HeapAlloc(GetProcessHeap(), 0, sizeof(*job));
2554     if(!job)
2555         goto end;
2556
2557     job->job_id = InterlockedIncrement(&next_job_id);
2558
2559     len = GetSystemDirectoryW(path, sizeof(path) / sizeof(WCHAR));
2560     if(path[len - 1] != '\\')
2561         path[len++] = '\\';
2562     memcpy(path + len, spool_path, sizeof(spool_path));
2563     sprintfW(filename, fmtW, path, job->job_id);
2564
2565     len = strlenW(filename);
2566     job->filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
2567     memcpy(job->filename, filename, (len + 1) * sizeof(WCHAR));
2568     job->document_title = strdupW(default_doc_title);
2569     list_add_tail(&printer->queue->jobs, &job->entry);
2570
2571     *pcbNeeded = (len + 1) * sizeof(WCHAR) + sizeof(*addjob);
2572     if(*pcbNeeded <= cbBuf) {
2573         addjob = (ADDJOB_INFO_1W*)pData;
2574         addjob->JobId = job->job_id;
2575         addjob->Path = (WCHAR *)(addjob + 1);
2576         memcpy(addjob->Path, filename, (len + 1) * sizeof(WCHAR));
2577         ret = TRUE;
2578     } else
2579         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2580
2581 end:
2582     LeaveCriticalSection(&printer_handles_cs);
2583     return ret;
2584 }
2585
2586 /*****************************************************************************
2587  *          GetPrintProcessorDirectoryA  [WINSPOOL.@]
2588  *
2589  * Return the PATH for the Print-Processors
2590  *
2591  * See GetPrintProcessorDirectoryW.
2592  *
2593  *
2594  */
2595 BOOL WINAPI GetPrintProcessorDirectoryA(LPSTR server, LPSTR env,
2596                                         DWORD level,  LPBYTE Info,
2597                                         DWORD cbBuf,  LPDWORD pcbNeeded)
2598 {
2599     LPWSTR  serverW = NULL;
2600     LPWSTR  envW = NULL;
2601     BOOL    ret;
2602     INT     len;
2603
2604     TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_a(server),
2605           debugstr_a(env), level, Info, cbBuf, pcbNeeded);
2606
2607
2608     if (server) {
2609         len = MultiByteToWideChar(CP_ACP, 0, server, -1, NULL, 0);
2610         serverW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2611         MultiByteToWideChar(CP_ACP, 0, server, -1, serverW, len);
2612     }
2613
2614     if (env) {
2615         len = MultiByteToWideChar(CP_ACP, 0, env, -1, NULL, 0);
2616         envW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2617         MultiByteToWideChar(CP_ACP, 0, env, -1, envW, len);
2618     }
2619
2620     /* NT requires the buffersize from GetPrintProcessorDirectoryW also
2621        for GetPrintProcessorDirectoryA and WC2MB is done in-place.
2622      */
2623     ret = GetPrintProcessorDirectoryW(serverW, envW, level, Info,
2624                                       cbBuf, pcbNeeded);
2625
2626     if (ret) ret = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)Info, -1, (LPSTR)Info,
2627                                        cbBuf, NULL, NULL) > 0;
2628
2629
2630     TRACE(" required: 0x%x/%d\n", pcbNeeded ? *pcbNeeded : 0, pcbNeeded ? *pcbNeeded : 0);
2631     HeapFree(GetProcessHeap(), 0, envW);
2632     HeapFree(GetProcessHeap(), 0, serverW);
2633     return ret;
2634 }
2635
2636 /*****************************************************************************
2637  *          GetPrintProcessorDirectoryW  [WINSPOOL.@]
2638  *
2639  * Return the PATH for the Print-Processors
2640  *
2641  * PARAMS
2642  *   server     [I] Servername (NT only) or NULL (local Computer)
2643  *   env        [I] Printing-Environment (see below) or NULL (Default)
2644  *   level      [I] Structure-Level (must be 1)
2645  *   Info       [O] PTR to Buffer that receives the Result
2646  *   cbBuf      [I] Size of Buffer at "Info"
2647  *   pcbNeeded  [O] PTR to DWORD that receives the size in Bytes used /
2648  *                  required for the Buffer at "Info"
2649  *
2650  * RETURNS
2651  *   Success: TRUE  and in pcbNeeded the Bytes used in Info
2652  *   Failure: FALSE and in pcbNeeded the Bytes required for Info,
2653  *   if cbBuf is too small
2654  *
2655  *   Native Values returned in Info on Success:
2656  *|  NT(Windows NT x86):  "%winsysdir%\\spool\\PRTPROCS\\w32x86"
2657  *|  NT(Windows 4.0):     "%winsysdir%\\spool\\PRTPROCS\\win40"
2658  *|  win9x(Windows 4.0):  "%winsysdir%"
2659  *
2660  *   "%winsysdir%" is the Value from GetSystemDirectoryW()
2661  *
2662  * BUGS
2663  *  Only NULL or "" is supported for server
2664  *
2665  */
2666 BOOL WINAPI GetPrintProcessorDirectoryW(LPWSTR server, LPWSTR env,
2667                                         DWORD level,  LPBYTE Info,
2668                                         DWORD cbBuf,  LPDWORD pcbNeeded)
2669 {
2670     DWORD needed;
2671     const printenv_t * env_t;
2672
2673     TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(server),
2674             debugstr_w(env), level, Info, cbBuf, pcbNeeded);
2675
2676     if(server != NULL && server[0]) {
2677         FIXME("server not supported: %s\n", debugstr_w(server));
2678         SetLastError(ERROR_INVALID_PARAMETER);
2679         return FALSE;
2680     }
2681
2682     env_t = validate_envW(env);
2683     if(!env_t) return FALSE;  /* environment invalid or unsupported */
2684
2685     if(level != 1) {
2686         WARN("(Level: %d) is ignored in win9x\n", level);
2687         SetLastError(ERROR_INVALID_LEVEL);
2688         return FALSE;
2689     }
2690
2691     /* GetSystemDirectoryW returns number of WCHAR including the '\0' */
2692     needed = GetSystemDirectoryW(NULL, 0);
2693     /* add the Size for the Subdirectories */
2694     needed += lstrlenW(spoolprtprocsW);
2695     needed += lstrlenW(env_t->subdir);
2696     needed *= sizeof(WCHAR);  /* return-value is size in Bytes */
2697
2698     if(pcbNeeded) *pcbNeeded = needed;
2699     TRACE ("required: 0x%x/%d\n", needed, needed);
2700     if (needed > cbBuf) {
2701         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2702         return FALSE;
2703     }
2704     if(pcbNeeded == NULL) {
2705         /* NT: RPC_X_NULL_REF_POINTER, 9x: ignored */
2706         WARN("(pcbNeeded == NULL) is ignored in win9x\n");
2707         SetLastError(RPC_X_NULL_REF_POINTER);
2708         return FALSE;
2709     }
2710     if(Info == NULL) {
2711         /* NT: RPC_X_NULL_REF_POINTER, 9x: ERROR_INVALID_PARAMETER */
2712         SetLastError(RPC_X_NULL_REF_POINTER);
2713         return FALSE;
2714     }
2715
2716     GetSystemDirectoryW((LPWSTR) Info, cbBuf/sizeof(WCHAR));
2717     /* add the Subdirectories */
2718     lstrcatW((LPWSTR) Info, spoolprtprocsW);
2719     lstrcatW((LPWSTR) Info, env_t->subdir);
2720     TRACE(" => %s\n", debugstr_w((LPWSTR) Info));
2721     return TRUE;
2722 }
2723
2724 /*****************************************************************************
2725  *          WINSPOOL_OpenDriverReg [internal]
2726  *
2727  * opens the registry for the printer drivers depending on the given input
2728  * variable pEnvironment
2729  *
2730  * RETURNS:
2731  *    the opened hkey on success
2732  *    NULL on error
2733  */
2734 static HKEY WINSPOOL_OpenDriverReg( LPCVOID pEnvironment, BOOL unicode)
2735 {
2736     HKEY  retval = NULL;
2737     LPWSTR buffer;
2738     const printenv_t * env;
2739
2740     TRACE("(%s, %d)\n",
2741           (unicode) ? debugstr_w(pEnvironment) : debugstr_a(pEnvironment), unicode);
2742
2743     if (!pEnvironment || unicode) {
2744         /* pEnvironment was NULL or an Unicode-String: use it direct */
2745         env = validate_envW(pEnvironment);
2746     }
2747     else
2748     {
2749         /* pEnvironment was an ANSI-String: convert to unicode first */
2750         LPWSTR  buffer;
2751         INT len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pEnvironment, -1, NULL, 0);
2752         buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2753         if (buffer) MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pEnvironment, -1, buffer, len);
2754         env = validate_envW(buffer);
2755         HeapFree(GetProcessHeap(), 0, buffer);
2756     }
2757     if (!env) return NULL;
2758
2759     buffer = HeapAlloc( GetProcessHeap(), 0,
2760                 (strlenW(DriversW) + strlenW(env->envname) +
2761                  strlenW(env->versionregpath) + 1) * sizeof(WCHAR));
2762     if(buffer) {
2763         wsprintfW(buffer, DriversW, env->envname, env->versionregpath);
2764         RegCreateKeyW(HKEY_LOCAL_MACHINE, buffer, &retval);
2765         HeapFree(GetProcessHeap(), 0, buffer);
2766     }
2767     return retval;
2768 }
2769
2770 /*****************************************************************************
2771  *          AddPrinterW  [WINSPOOL.@]
2772  */
2773 HANDLE WINAPI AddPrinterW(LPWSTR pName, DWORD Level, LPBYTE pPrinter)
2774 {
2775     PRINTER_INFO_2W *pi = (PRINTER_INFO_2W *) pPrinter;
2776     LPDEVMODEA dmA;
2777     LPDEVMODEW dmW;
2778     HANDLE retval;
2779     HKEY hkeyPrinter, hkeyPrinters, hkeyDriver, hkeyDrivers;
2780     LONG size;
2781     static const WCHAR attributesW[]      = {'A','t','t','r','i','b','u','t','e','s',0},
2782                        default_devmodeW[] = {'D','e','f','a','u','l','t',' ','D','e','v','M','o','d','e',0},
2783                        priorityW[]        = {'P','r','i','o','r','i','t','y',0},
2784                        start_timeW[]      = {'S','t','a','r','t','T','i','m','e',0},
2785                        statusW[]          = {'S','t','a','t','u','s',0},
2786                        until_timeW[]      = {'U','n','t','i','l','T','i','m','e',0};
2787
2788     TRACE("(%s,%d,%p)\n", debugstr_w(pName), Level, pPrinter);
2789
2790     if(pName != NULL) {
2791         ERR("pName = %s - unsupported\n", debugstr_w(pName));
2792         SetLastError(ERROR_INVALID_PARAMETER);
2793         return 0;
2794     }
2795     if(Level != 2) {
2796         ERR("Level = %d, unsupported!\n", Level);
2797         SetLastError(ERROR_INVALID_LEVEL);
2798         return 0;
2799     }
2800     if(!pPrinter) {
2801         SetLastError(ERROR_INVALID_PARAMETER);
2802         return 0;
2803     }
2804     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
2805        ERROR_SUCCESS) {
2806         ERR("Can't create Printers key\n");
2807         return 0;
2808     }
2809     if(!RegOpenKeyW(hkeyPrinters, pi->pPrinterName, &hkeyPrinter)) {
2810         if (!RegQueryValueW(hkeyPrinter, attributesW, NULL, NULL)) {
2811             SetLastError(ERROR_PRINTER_ALREADY_EXISTS);
2812             RegCloseKey(hkeyPrinter);
2813             RegCloseKey(hkeyPrinters);
2814             return 0;
2815         }
2816         RegCloseKey(hkeyPrinter);
2817     }
2818     hkeyDrivers = WINSPOOL_OpenDriverReg( NULL, TRUE);
2819     if(!hkeyDrivers) {
2820         ERR("Can't create Drivers key\n");
2821         RegCloseKey(hkeyPrinters);
2822         return 0;
2823     }
2824     if(RegOpenKeyW(hkeyDrivers, pi->pDriverName, &hkeyDriver) !=
2825        ERROR_SUCCESS) {
2826         WARN("Can't find driver %s\n", debugstr_w(pi->pDriverName));
2827         RegCloseKey(hkeyPrinters);
2828         RegCloseKey(hkeyDrivers);
2829         SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER);
2830         return 0;
2831     }
2832     RegCloseKey(hkeyDriver);
2833     RegCloseKey(hkeyDrivers);
2834
2835     if(lstrcmpiW(pi->pPrintProcessor, WinPrintW)) {  /* FIXME */
2836         FIXME("Can't find processor %s\n", debugstr_w(pi->pPrintProcessor));
2837         SetLastError(ERROR_UNKNOWN_PRINTPROCESSOR);
2838         RegCloseKey(hkeyPrinters);
2839         return 0;
2840     }
2841
2842     if(RegCreateKeyW(hkeyPrinters, pi->pPrinterName, &hkeyPrinter) !=
2843        ERROR_SUCCESS) {
2844         FIXME("Can't create printer %s\n", debugstr_w(pi->pPrinterName));
2845         SetLastError(ERROR_INVALID_PRINTER_NAME);
2846         RegCloseKey(hkeyPrinters);
2847         return 0;
2848     }
2849     RegSetValueExW(hkeyPrinter, attributesW, 0, REG_DWORD,
2850                    (LPBYTE)&pi->Attributes, sizeof(DWORD));
2851     set_reg_szW(hkeyPrinter, DatatypeW, pi->pDatatype);
2852
2853     /* See if we can load the driver.  We may need the devmode structure anyway
2854      *
2855      * FIXME:
2856      * Note that DocumentPropertiesW will briefly try to open the printer we
2857      * just create to find a DEVMODEA struct (it will use the WINEPS default
2858      * one in case it is not there, so we are ok).
2859      */
2860     size = DocumentPropertiesW(0, 0, pi->pPrinterName, NULL, NULL, 0);
2861
2862     if(size < 0) {
2863         FIXME("DocumentPropertiesW on printer %s fails\n", debugstr_w(pi->pPrinterName));
2864         size = sizeof(DEVMODEW);
2865     }
2866     if(pi->pDevMode)
2867         dmW = pi->pDevMode;
2868     else
2869     {
2870         dmW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2871         dmW->dmSize = size;
2872         if (0>DocumentPropertiesW(0,0,pi->pPrinterName,dmW,NULL,DM_OUT_BUFFER))
2873         {
2874             WARN("DocumentPropertiesW on printer %s failed!\n", debugstr_w(pi->pPrinterName));
2875             HeapFree(GetProcessHeap(),0,dmW);
2876             dmW=NULL;
2877         }
2878         else
2879         {
2880             /* set devmode to printer name */
2881             lstrcpynW(dmW->dmDeviceName, pi->pPrinterName, CCHDEVICENAME);
2882         }
2883     }
2884
2885     /* Write DEVMODEA not DEVMODEW into reg.  This is what win9x does
2886        and we support these drivers.  NT writes DEVMODEW so somehow
2887        we'll need to distinguish between these when we support NT
2888        drivers */
2889     if (dmW)
2890     {
2891         dmA = DEVMODEdupWtoA(dmW);
2892         RegSetValueExW(hkeyPrinter, default_devmodeW, 0, REG_BINARY,
2893                        (LPBYTE)dmA, dmA->dmSize + dmA->dmDriverExtra);
2894         HeapFree(GetProcessHeap(), 0, dmA);
2895         if(!pi->pDevMode)
2896             HeapFree(GetProcessHeap(), 0, dmW);
2897     }
2898     set_reg_szW(hkeyPrinter, DescriptionW, pi->pComment);
2899     set_reg_szW(hkeyPrinter, LocationW, pi->pLocation);
2900     set_reg_szW(hkeyPrinter, NameW, pi->pPrinterName);
2901     set_reg_szW(hkeyPrinter, ParametersW, pi->pParameters);
2902
2903     set_reg_szW(hkeyPrinter, PortW, pi->pPortName);
2904     set_reg_szW(hkeyPrinter, Print_ProcessorW, pi->pPrintProcessor);
2905     set_reg_szW(hkeyPrinter, Printer_DriverW, pi->pDriverName);
2906     RegSetValueExW(hkeyPrinter, priorityW, 0, REG_DWORD,
2907                    (LPBYTE)&pi->Priority, sizeof(DWORD));
2908     set_reg_szW(hkeyPrinter, Separator_FileW, pi->pSepFile);
2909     set_reg_szW(hkeyPrinter, Share_NameW, pi->pShareName);
2910     RegSetValueExW(hkeyPrinter, start_timeW, 0, REG_DWORD,
2911                    (LPBYTE)&pi->StartTime, sizeof(DWORD));
2912     RegSetValueExW(hkeyPrinter, statusW, 0, REG_DWORD,
2913                    (LPBYTE)&pi->Status, sizeof(DWORD));
2914     RegSetValueExW(hkeyPrinter, until_timeW, 0, REG_DWORD,
2915                    (LPBYTE)&pi->UntilTime, sizeof(DWORD));
2916
2917     RegCloseKey(hkeyPrinter);
2918     RegCloseKey(hkeyPrinters);
2919     if(!OpenPrinterW(pi->pPrinterName, &retval, NULL)) {
2920         ERR("OpenPrinter failing\n");
2921         return 0;
2922     }
2923     return retval;
2924 }
2925
2926 /*****************************************************************************
2927  *          AddPrinterA  [WINSPOOL.@]
2928  */
2929 HANDLE WINAPI AddPrinterA(LPSTR pName, DWORD Level, LPBYTE pPrinter)
2930 {
2931     UNICODE_STRING pNameW;
2932     PWSTR pwstrNameW;
2933     PRINTER_INFO_2W *piW;
2934     PRINTER_INFO_2A *piA = (PRINTER_INFO_2A*)pPrinter;
2935     HANDLE ret;
2936
2937     TRACE("(%s,%d,%p): stub\n", debugstr_a(pName), Level, pPrinter);
2938     if(Level != 2) {
2939         ERR("Level = %d, unsupported!\n", Level);
2940         SetLastError(ERROR_INVALID_LEVEL);
2941         return 0;
2942     }
2943     pwstrNameW = asciitounicode(&pNameW,pName);
2944     piW = PRINTER_INFO_2AtoW(GetProcessHeap(), piA);
2945
2946     ret = AddPrinterW(pwstrNameW, Level, (LPBYTE)piW);
2947
2948     FREE_PRINTER_INFO_2W(GetProcessHeap(), piW);
2949     RtlFreeUnicodeString(&pNameW);
2950     return ret;
2951 }
2952
2953
2954 /*****************************************************************************
2955  *          ClosePrinter  [WINSPOOL.@]
2956  */
2957 BOOL WINAPI ClosePrinter(HANDLE hPrinter)
2958 {
2959     UINT_PTR i = (UINT_PTR)hPrinter;
2960     opened_printer_t *printer = NULL;
2961     BOOL ret = FALSE;
2962
2963     TRACE("(%p)\n", hPrinter);
2964
2965     EnterCriticalSection(&printer_handles_cs);
2966
2967     if ((i > 0) && (i <= nb_printer_handles))
2968         printer = printer_handles[i - 1];
2969
2970
2971     if(printer)
2972     {
2973         struct list *cursor, *cursor2;
2974
2975         TRACE("%p: %s (hXcv: %p) for %s (doc: %p)\n", printer->pm,
2976                 debugstr_w(printer->pm ? printer->pm->dllname : NULL),
2977                 printer->hXcv, debugstr_w(printer->name), printer->doc );
2978
2979         if(printer->doc)
2980             EndDocPrinter(hPrinter);
2981
2982         if(InterlockedDecrement(&printer->queue->ref) == 0)
2983         {
2984             LIST_FOR_EACH_SAFE(cursor, cursor2, &printer->queue->jobs)
2985             {
2986                 job_t *job = LIST_ENTRY(cursor, job_t, entry);
2987                 ScheduleJob(hPrinter, job->job_id);
2988             }
2989             HeapFree(GetProcessHeap(), 0, printer->queue);
2990         }
2991         if (printer->hXcv) printer->pm->monitor->pfnXcvClosePort(printer->hXcv);
2992         monitor_unload(printer->pm);
2993         HeapFree(GetProcessHeap(), 0, printer->printername);
2994         HeapFree(GetProcessHeap(), 0, printer->name);
2995         HeapFree(GetProcessHeap(), 0, printer);
2996         printer_handles[i - 1] = NULL;
2997         ret = TRUE;
2998     }
2999     LeaveCriticalSection(&printer_handles_cs);
3000     return ret;
3001 }
3002
3003 /*****************************************************************************
3004  *          DeleteFormA  [WINSPOOL.@]
3005  */
3006 BOOL WINAPI DeleteFormA(HANDLE hPrinter, LPSTR pFormName)
3007 {
3008     FIXME("(%p,%s): stub\n", hPrinter, pFormName);
3009     return 1;
3010 }
3011
3012 /*****************************************************************************
3013  *          DeleteFormW  [WINSPOOL.@]
3014  */
3015 BOOL WINAPI DeleteFormW(HANDLE hPrinter, LPWSTR pFormName)
3016 {
3017     FIXME("(%p,%s): stub\n", hPrinter, debugstr_w(pFormName));
3018     return 1;
3019 }
3020
3021 /*****************************************************************************
3022  *          DeletePrinter  [WINSPOOL.@]
3023  */
3024 BOOL WINAPI DeletePrinter(HANDLE hPrinter)
3025 {
3026     LPCWSTR lpNameW = get_opened_printer_name(hPrinter);
3027     HKEY hkeyPrinters, hkey;
3028
3029     if(!lpNameW) {
3030         SetLastError(ERROR_INVALID_HANDLE);
3031         return FALSE;
3032     }
3033     if(RegOpenKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) == ERROR_SUCCESS) {
3034         RegDeleteTreeW(hkeyPrinters, lpNameW);
3035         RegCloseKey(hkeyPrinters);
3036     }
3037     WriteProfileStringW(devicesW, lpNameW, NULL);
3038     if(RegCreateKeyW(HKEY_CURRENT_USER, user_printers_reg_key, &hkey) == ERROR_SUCCESS) {
3039         RegDeleteValueW(hkey, lpNameW);
3040         RegCloseKey(hkey);
3041     }
3042     return TRUE;
3043 }
3044
3045 /*****************************************************************************
3046  *          SetPrinterA  [WINSPOOL.@]
3047  */
3048 BOOL WINAPI SetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
3049                            DWORD Command)
3050 {
3051     FIXME("(%p,%d,%p,%d): stub\n",hPrinter,Level,pPrinter,Command);
3052     return FALSE;
3053 }
3054
3055 /*****************************************************************************
3056  *          SetJobA  [WINSPOOL.@]
3057  */
3058 BOOL WINAPI SetJobA(HANDLE hPrinter, DWORD JobId, DWORD Level,
3059                     LPBYTE pJob, DWORD Command)
3060 {
3061     BOOL ret;
3062     LPBYTE JobW;
3063     UNICODE_STRING usBuffer;
3064
3065     TRACE("(%p, %d, %d, %p, %d)\n",hPrinter, JobId, Level, pJob, Command);
3066
3067     /* JobId, pPrinterName, pMachineName, pDriverName, Size, Submitted, Time and TotalPages
3068        are all ignored by SetJob, so we don't bother copying them */
3069     switch(Level)
3070     {
3071     case 0:
3072         JobW = NULL;
3073         break;
3074     case 1:
3075       {
3076         JOB_INFO_1W *info1W = HeapAlloc(GetProcessHeap(), 0, sizeof(*info1W));
3077         JOB_INFO_1A *info1A = (JOB_INFO_1A*)pJob;
3078
3079         JobW = (LPBYTE)info1W;
3080         info1W->pUserName = asciitounicode(&usBuffer, info1A->pUserName);
3081         info1W->pDocument = asciitounicode(&usBuffer, info1A->pDocument);
3082         info1W->pDatatype = asciitounicode(&usBuffer, info1A->pDatatype);
3083         info1W->pStatus = asciitounicode(&usBuffer, info1A->pStatus);
3084         info1W->Status = info1A->Status;
3085         info1W->Priority = info1A->Priority;
3086         info1W->Position = info1A->Position;
3087         info1W->PagesPrinted = info1A->PagesPrinted;
3088         break;
3089       }
3090     case 2:
3091       {
3092         JOB_INFO_2W *info2W = HeapAlloc(GetProcessHeap(), 0, sizeof(*info2W));
3093         JOB_INFO_2A *info2A = (JOB_INFO_2A*)pJob;
3094
3095         JobW = (LPBYTE)info2W;
3096         info2W->pUserName = asciitounicode(&usBuffer, info2A->pUserName);
3097         info2W->pDocument = asciitounicode(&usBuffer, info2A->pDocument);
3098         info2W->pNotifyName = asciitounicode(&usBuffer, info2A->pNotifyName);
3099         info2W->pDatatype = asciitounicode(&usBuffer, info2A->pDatatype);
3100         info2W->pPrintProcessor = asciitounicode(&usBuffer, info2A->pPrintProcessor);
3101         info2W->pParameters = asciitounicode(&usBuffer, info2A->pParameters);
3102         info2W->pDevMode = info2A->pDevMode ? GdiConvertToDevmodeW(info2A->pDevMode) : NULL;
3103         info2W->pStatus = asciitounicode(&usBuffer, info2A->pStatus);
3104         info2W->pSecurityDescriptor = info2A->pSecurityDescriptor;
3105         info2W->Status = info2A->Status;
3106         info2W->Priority = info2A->Priority;
3107         info2W->Position = info2A->Position;
3108         info2W->StartTime = info2A->StartTime;
3109         info2W->UntilTime = info2A->UntilTime;
3110         info2W->PagesPrinted = info2A->PagesPrinted;
3111         break;
3112       }
3113     case 3:
3114         JobW = HeapAlloc(GetProcessHeap(), 0, sizeof(JOB_INFO_3));
3115         memcpy(JobW, pJob, sizeof(JOB_INFO_3));
3116         break;
3117     default:
3118         SetLastError(ERROR_INVALID_LEVEL);
3119         return FALSE;
3120     }
3121
3122     ret = SetJobW(hPrinter, JobId, Level, JobW, Command);
3123
3124     switch(Level)
3125     {
3126     case 1:
3127       {
3128         JOB_INFO_1W *info1W = (JOB_INFO_1W*)JobW;
3129         HeapFree(GetProcessHeap(), 0, info1W->pUserName);
3130         HeapFree(GetProcessHeap(), 0, info1W->pDocument);
3131         HeapFree(GetProcessHeap(), 0, info1W->pDatatype);
3132         HeapFree(GetProcessHeap(), 0, info1W->pStatus);
3133         break;
3134       }
3135     case 2:
3136       {
3137         JOB_INFO_2W *info2W = (JOB_INFO_2W*)JobW;
3138         HeapFree(GetProcessHeap(), 0, info2W->pUserName);
3139         HeapFree(GetProcessHeap(), 0, info2W->pDocument);
3140         HeapFree(GetProcessHeap(), 0, info2W->pNotifyName);
3141         HeapFree(GetProcessHeap(), 0, info2W->pDatatype);
3142         HeapFree(GetProcessHeap(), 0, info2W->pPrintProcessor);
3143         HeapFree(GetProcessHeap(), 0, info2W->pParameters);
3144         HeapFree(GetProcessHeap(), 0, info2W->pDevMode);
3145         HeapFree(GetProcessHeap(), 0, info2W->pStatus);
3146         break;
3147       }
3148     }
3149     HeapFree(GetProcessHeap(), 0, JobW);
3150
3151     return ret;
3152 }
3153
3154 /*****************************************************************************
3155  *          SetJobW  [WINSPOOL.@]
3156  */
3157 BOOL WINAPI SetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level,
3158                     LPBYTE pJob, DWORD Command)
3159 {
3160     BOOL ret = FALSE;
3161     job_t *job;
3162
3163     TRACE("(%p, %d, %d, %p, %d)\n", hPrinter, JobId, Level, pJob, Command);
3164     FIXME("Ignoring everything other than document title\n");
3165
3166     EnterCriticalSection(&printer_handles_cs);
3167     job = get_job(hPrinter, JobId);
3168     if(!job)
3169         goto end;
3170
3171     switch(Level)
3172     {
3173     case 0:
3174         break;
3175     case 1:
3176       {
3177         JOB_INFO_1W *info1 = (JOB_INFO_1W*)pJob;
3178         HeapFree(GetProcessHeap(), 0, job->document_title);
3179         job->document_title = strdupW(info1->pDocument);
3180         break;
3181       }
3182     case 2:
3183       {
3184         JOB_INFO_2W *info2 = (JOB_INFO_2W*)pJob;
3185         HeapFree(GetProcessHeap(), 0, job->document_title);
3186         job->document_title = strdupW(info2->pDocument);
3187         break;
3188       }
3189     case 3:
3190         break;
3191     default:
3192         SetLastError(ERROR_INVALID_LEVEL);
3193         goto end;
3194     }
3195     ret = TRUE;
3196 end:
3197     LeaveCriticalSection(&printer_handles_cs);
3198     return ret;
3199 }
3200
3201 /*****************************************************************************
3202  *          EndDocPrinter  [WINSPOOL.@]
3203  */
3204 BOOL WINAPI EndDocPrinter(HANDLE hPrinter)
3205 {
3206     opened_printer_t *printer;
3207     BOOL ret = FALSE;
3208     TRACE("(%p)\n", hPrinter);
3209
3210     EnterCriticalSection(&printer_handles_cs);
3211
3212     printer = get_opened_printer(hPrinter);
3213     if(!printer)
3214     {
3215         SetLastError(ERROR_INVALID_HANDLE);
3216         goto end;
3217     }
3218
3219     if(!printer->doc)
3220     {
3221         SetLastError(ERROR_SPL_NO_STARTDOC);
3222         goto end;
3223     }
3224
3225     CloseHandle(printer->doc->hf);
3226     ScheduleJob(hPrinter, printer->doc->job_id);
3227     HeapFree(GetProcessHeap(), 0, printer->doc);
3228     printer->doc = NULL;
3229     ret = TRUE;
3230 end:
3231     LeaveCriticalSection(&printer_handles_cs);
3232     return ret;
3233 }
3234
3235 /*****************************************************************************
3236  *          EndPagePrinter  [WINSPOOL.@]
3237  */
3238 BOOL WINAPI EndPagePrinter(HANDLE hPrinter)
3239 {
3240     FIXME("(%p): stub\n", hPrinter);
3241     return TRUE;
3242 }
3243
3244 /*****************************************************************************
3245  *          StartDocPrinterA  [WINSPOOL.@]
3246  */
3247 DWORD WINAPI StartDocPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pDocInfo)
3248 {
3249     UNICODE_STRING usBuffer;
3250     DOC_INFO_2W doc2W;
3251     DOC_INFO_2A *doc2 = (DOC_INFO_2A*)pDocInfo;
3252     DWORD ret;
3253
3254     /* DOC_INFO_1, 2 and 3 all have the strings in the same place with either two (DOC_INFO_2)
3255        or one (DOC_INFO_3) extra DWORDs */
3256
3257     switch(Level) {
3258     case 2:
3259         doc2W.JobId = doc2->JobId;
3260         /* fall through */
3261     case 3:
3262         doc2W.dwMode = doc2->dwMode;
3263         /* fall through */
3264     case 1:
3265         doc2W.pDocName = asciitounicode(&usBuffer, doc2->pDocName);
3266         doc2W.pOutputFile = asciitounicode(&usBuffer, doc2->pOutputFile);
3267         doc2W.pDatatype = asciitounicode(&usBuffer, doc2->pDatatype);
3268         break;
3269
3270     default:
3271         SetLastError(ERROR_INVALID_LEVEL);
3272         return FALSE;
3273     }
3274
3275     ret = StartDocPrinterW(hPrinter, Level, (LPBYTE)&doc2W);
3276
3277     HeapFree(GetProcessHeap(), 0, doc2W.pDatatype);
3278     HeapFree(GetProcessHeap(), 0, doc2W.pOutputFile);
3279     HeapFree(GetProcessHeap(), 0, doc2W.pDocName);
3280
3281     return ret;
3282 }
3283
3284 /*****************************************************************************
3285  *          StartDocPrinterW  [WINSPOOL.@]
3286  */
3287 DWORD WINAPI StartDocPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pDocInfo)
3288 {
3289     DOC_INFO_2W *doc = (DOC_INFO_2W *)pDocInfo;
3290     opened_printer_t *printer;
3291     BYTE addjob_buf[MAX_PATH * sizeof(WCHAR) + sizeof(ADDJOB_INFO_1W)];
3292     ADDJOB_INFO_1W *addjob = (ADDJOB_INFO_1W*) addjob_buf;
3293     JOB_INFO_1W job_info;
3294     DWORD needed, ret = 0;
3295     HANDLE hf;
3296     WCHAR *filename;
3297
3298     TRACE("(hPrinter = %p, Level = %d, pDocInfo = %p {pDocName = %s, pOutputFile = %s, pDatatype = %s}):\n",
3299           hPrinter, Level, doc, debugstr_w(doc->pDocName), debugstr_w(doc->pOutputFile),
3300           debugstr_w(doc->pDatatype));
3301
3302     if(Level < 1 || Level > 3)
3303     {
3304         SetLastError(ERROR_INVALID_LEVEL);
3305         return 0;
3306     }
3307
3308     EnterCriticalSection(&printer_handles_cs);
3309     printer = get_opened_printer(hPrinter);
3310     if(!printer)
3311     {
3312         SetLastError(ERROR_INVALID_HANDLE);
3313         goto end;
3314     }
3315
3316     if(printer->doc)
3317     {
3318         SetLastError(ERROR_INVALID_PRINTER_STATE);
3319         goto end;
3320     }
3321
3322     /* Even if we're printing to a file we still add a print job, we'll
3323        just ignore the spool file name */
3324
3325     if(!AddJobW(hPrinter, 1, addjob_buf, sizeof(addjob_buf), &needed))
3326     {
3327         ERR("AddJob failed gle %u\n", GetLastError());
3328         goto end;
3329     }
3330
3331     if(doc->pOutputFile)
3332         filename = doc->pOutputFile;
3333     else
3334         filename = addjob->Path;
3335
3336     hf = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
3337     if(hf == INVALID_HANDLE_VALUE)
3338         goto end;
3339
3340     memset(&job_info, 0, sizeof(job_info));
3341     job_info.pDocument = doc->pDocName;
3342     SetJobW(hPrinter, addjob->JobId, 1, (LPBYTE)&job_info, 0);
3343
3344     printer->doc = HeapAlloc(GetProcessHeap(), 0, sizeof(*printer->doc));
3345     printer->doc->hf = hf;
3346     ret = printer->doc->job_id = addjob->JobId;
3347 end:
3348     LeaveCriticalSection(&printer_handles_cs);
3349
3350     return ret;
3351 }
3352
3353 /*****************************************************************************
3354  *          StartPagePrinter  [WINSPOOL.@]
3355  */
3356 BOOL WINAPI StartPagePrinter(HANDLE hPrinter)
3357 {
3358     FIXME("(%p): stub\n", hPrinter);
3359     return TRUE;
3360 }
3361
3362 /*****************************************************************************
3363  *          GetFormA  [WINSPOOL.@]
3364  */
3365 BOOL WINAPI GetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
3366                  LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
3367 {
3368     FIXME("(%p,%s,%d,%p,%d,%p): stub\n",hPrinter,pFormName,
3369          Level,pForm,cbBuf,pcbNeeded);
3370     return FALSE;
3371 }
3372
3373 /*****************************************************************************
3374  *          GetFormW  [WINSPOOL.@]
3375  */
3376 BOOL WINAPI GetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
3377                  LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
3378 {
3379     FIXME("(%p,%s,%d,%p,%d,%p): stub\n",hPrinter,
3380           debugstr_w(pFormName),Level,pForm,cbBuf,pcbNeeded);
3381     return FALSE;
3382 }
3383
3384 /*****************************************************************************
3385  *          SetFormA  [WINSPOOL.@]
3386  */
3387 BOOL WINAPI SetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
3388                         LPBYTE pForm)
3389 {
3390     FIXME("(%p,%s,%d,%p): stub\n",hPrinter,pFormName,Level,pForm);
3391     return FALSE;
3392 }
3393
3394 /*****************************************************************************
3395  *          SetFormW  [WINSPOOL.@]
3396  */
3397 BOOL WINAPI SetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
3398                         LPBYTE pForm)
3399 {
3400     FIXME("(%p,%p,%d,%p): stub\n",hPrinter,pFormName,Level,pForm);
3401     return FALSE;
3402 }
3403
3404 /*****************************************************************************
3405  *          ReadPrinter  [WINSPOOL.@]
3406  */
3407 BOOL WINAPI ReadPrinter(HANDLE hPrinter, LPVOID pBuf, DWORD cbBuf,
3408                            LPDWORD pNoBytesRead)
3409 {
3410     FIXME("(%p,%p,%d,%p): stub\n",hPrinter,pBuf,cbBuf,pNoBytesRead);
3411     return FALSE;
3412 }
3413
3414 /*****************************************************************************
3415  *          ResetPrinterA  [WINSPOOL.@]
3416  */
3417 BOOL WINAPI ResetPrinterA(HANDLE hPrinter, LPPRINTER_DEFAULTSA pDefault)
3418 {
3419     FIXME("(%p, %p): stub\n", hPrinter, pDefault);
3420     return FALSE;
3421 }
3422
3423 /*****************************************************************************
3424  *          ResetPrinterW  [WINSPOOL.@]
3425  */
3426 BOOL WINAPI ResetPrinterW(HANDLE hPrinter, LPPRINTER_DEFAULTSW pDefault)
3427 {
3428     FIXME("(%p, %p): stub\n", hPrinter, pDefault);
3429     return FALSE;
3430 }
3431
3432 /*****************************************************************************
3433  *    WINSPOOL_GetDWORDFromReg
3434  *
3435  * Return DWORD associated with ValueName from hkey.
3436  */
3437 static DWORD WINSPOOL_GetDWORDFromReg(HKEY hkey, LPCSTR ValueName)
3438 {
3439     DWORD sz = sizeof(DWORD), type, value = 0;
3440     LONG ret;
3441
3442     ret = RegQueryValueExA(hkey, ValueName, 0, &type, (LPBYTE)&value, &sz);
3443
3444     if(ret != ERROR_SUCCESS) {
3445         WARN("Got ret = %d on name %s\n", ret, ValueName);
3446         return 0;
3447     }
3448     if(type != REG_DWORD) {
3449         ERR("Got type %d\n", type);
3450         return 0;
3451     }
3452     return value;
3453 }
3454
3455
3456 /*****************************************************************************
3457  * get_filename_from_reg [internal]
3458  *
3459  * Get ValueName from hkey storing result in out
3460  * when the Value in the registry has only a filename, use driverdir as prefix
3461  * outlen is space left in out
3462  * String is stored either as unicode or ascii
3463  *
3464  */
3465
3466 static BOOL get_filename_from_reg(HKEY hkey, LPCWSTR driverdir, DWORD dirlen, LPCWSTR ValueName,
3467                                   LPBYTE out, DWORD outlen, LPDWORD needed, BOOL unicode)
3468 {
3469     WCHAR   filename[MAX_PATH];
3470     DWORD   size;
3471     DWORD   type;
3472     LONG    ret;
3473     LPWSTR  buffer = filename;
3474     LPWSTR  ptr;
3475
3476     *needed = 0;
3477     size = sizeof(filename);
3478     buffer[0] = '\0';
3479     ret = RegQueryValueExW(hkey, ValueName, NULL, &type, (LPBYTE) buffer, &size);
3480     if (ret == ERROR_MORE_DATA) {
3481         TRACE("need dynamic buffer: %u\n", size);
3482         buffer = HeapAlloc(GetProcessHeap(), 0, size);
3483         if (!buffer) {
3484             /* No Memory is bad */
3485             return FALSE;
3486         }
3487         buffer[0] = '\0';
3488         ret = RegQueryValueExW(hkey, ValueName, NULL, &type, (LPBYTE) buffer, &size);
3489     }
3490
3491     if ((ret != ERROR_SUCCESS) || (!buffer[0])) {
3492         if (buffer != filename) HeapFree(GetProcessHeap(), 0, buffer);
3493         return FALSE;
3494     }
3495
3496     ptr = buffer;
3497     while (ptr) {
3498         /* do we have a full path ? */
3499         ret = (((buffer[0] == '\\') && (buffer[1] == '\\')) ||
3500                 (buffer[0] && (buffer[1] == ':') && (buffer[2] == '\\')) );
3501
3502         if (!ret) {
3503             /* we must build the full Path */
3504             *needed += dirlen;
3505             if ((out) && (outlen > dirlen)) {
3506                 if (unicode) {
3507                     lstrcpyW((LPWSTR)out, driverdir);
3508                 }
3509                 else
3510                 {
3511                     WideCharToMultiByte(CP_ACP, 0, driverdir, -1, (LPSTR)out, outlen, NULL, NULL);
3512                 }
3513                 out += dirlen;
3514                 outlen -= dirlen;
3515             }
3516             else
3517                 out = NULL;
3518         }
3519
3520         /* write the filename */
3521         if (unicode) {
3522             size = (lstrlenW(ptr) + 1) * sizeof(WCHAR);
3523             if ((out) && (outlen >= size)) {
3524                 lstrcpyW((LPWSTR)out, ptr);
3525                 out += size;
3526                 outlen -= size;
3527             }
3528             else
3529                 out = NULL;
3530         }
3531         else
3532         {
3533             size = WideCharToMultiByte(CP_ACP, 0, ptr, -1, NULL, 0, NULL, NULL);
3534             if ((out) && (outlen >= size)) {
3535                 WideCharToMultiByte(CP_ACP, 0, ptr, -1, (LPSTR)out, outlen, NULL, NULL);
3536                 out += size;
3537                 outlen -= size;
3538             }
3539             else
3540                 out = NULL;
3541         }
3542         *needed += size;
3543         ptr +=  lstrlenW(ptr)+1;
3544         if ((type != REG_MULTI_SZ) || (!ptr[0]))  ptr = NULL;
3545     }
3546
3547     if (buffer != filename) HeapFree(GetProcessHeap(), 0, buffer);
3548
3549     /* write the multisz-termination */
3550     if (type == REG_MULTI_SZ) {
3551         size = (unicode) ? sizeof(WCHAR) : 1;
3552
3553         *needed += size;
3554         if (out && (outlen >= size)) {
3555             memset (out, 0, size);
3556         }
3557     }
3558     return TRUE;
3559 }
3560
3561 /*****************************************************************************
3562  *    WINSPOOL_GetStringFromReg
3563  *
3564  * Get ValueName from hkey storing result in ptr.  buflen is space left in ptr
3565  * String is stored either as unicode or ascii.
3566  * Bit of a hack here to get the ValueName if we want ascii.
3567  */
3568 static BOOL WINSPOOL_GetStringFromReg(HKEY hkey, LPCWSTR ValueName, LPBYTE ptr,
3569                                       DWORD buflen, DWORD *needed,
3570                                       BOOL unicode)
3571 {
3572     DWORD sz = buflen, type;
3573     LONG ret;
3574
3575     if(unicode)
3576         ret = RegQueryValueExW(hkey, ValueName, 0, &type, ptr, &sz);
3577     else {
3578         LPSTR ValueNameA = strdupWtoA(ValueName);
3579         ret = RegQueryValueExA(hkey, ValueNameA, 0, &type, ptr, &sz);
3580         HeapFree(GetProcessHeap(),0,ValueNameA);
3581     }
3582     if(ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA) {
3583         WARN("Got ret = %d\n", ret);
3584         *needed = 0;
3585         return FALSE;
3586     }
3587     /* add space for terminating '\0' */
3588     sz += unicode ? sizeof(WCHAR) : 1;
3589     *needed = sz;
3590
3591     if (ptr)
3592         TRACE("%s: %s\n", debugstr_w(ValueName), unicode ? debugstr_w((LPCWSTR)ptr) : debugstr_a((LPCSTR)ptr));
3593
3594     return TRUE;
3595 }
3596
3597 /*****************************************************************************
3598  *    WINSPOOL_GetDefaultDevMode
3599  *
3600  * Get a default DevMode values for wineps.
3601  * FIXME - use ppd.
3602  */
3603
3604 static void WINSPOOL_GetDefaultDevMode(
3605         LPBYTE ptr,
3606         DWORD buflen, DWORD *needed,
3607         BOOL unicode)
3608 {
3609     DEVMODEA    dm;
3610     static const char szwps[] = "wineps.drv";
3611
3612         /* fill default DEVMODE - should be read from ppd... */
3613         ZeroMemory( &dm, sizeof(dm) );
3614         memcpy(dm.dmDeviceName,szwps,sizeof szwps);
3615         dm.dmSpecVersion = DM_SPECVERSION;
3616         dm.dmDriverVersion = 1;
3617         dm.dmSize = sizeof(DEVMODEA);
3618         dm.dmDriverExtra = 0;
3619         dm.dmFields =
3620                 DM_ORIENTATION | DM_PAPERSIZE |
3621                 DM_PAPERLENGTH | DM_PAPERWIDTH |
3622                 DM_SCALE |
3623                 DM_COPIES |
3624                 DM_DEFAULTSOURCE | DM_PRINTQUALITY |
3625                 DM_YRESOLUTION | DM_TTOPTION;
3626
3627         dm.u1.s1.dmOrientation = DMORIENT_PORTRAIT;
3628         dm.u1.s1.dmPaperSize = DMPAPER_A4;
3629         dm.u1.s1.dmPaperLength = 2970;
3630         dm.u1.s1.dmPaperWidth = 2100;
3631
3632         dm.u1.s1.dmScale = 100;
3633         dm.u1.s1.dmCopies = 1;
3634         dm.u1.s1.dmDefaultSource = DMBIN_AUTO;
3635         dm.u1.s1.dmPrintQuality = DMRES_MEDIUM;
3636         /* dm.dmColor */
3637         /* dm.dmDuplex */
3638         dm.dmYResolution = 300; /* 300dpi */
3639         dm.dmTTOption = DMTT_BITMAP;
3640         /* dm.dmCollate */
3641         /* dm.dmFormName */
3642         /* dm.dmLogPixels */
3643         /* dm.dmBitsPerPel */
3644         /* dm.dmPelsWidth */
3645         /* dm.dmPelsHeight */
3646         /* dm.u2.dmDisplayFlags */
3647         /* dm.dmDisplayFrequency */
3648         /* dm.dmICMMethod */
3649         /* dm.dmICMIntent */
3650         /* dm.dmMediaType */
3651         /* dm.dmDitherType */
3652         /* dm.dmReserved1 */
3653         /* dm.dmReserved2 */
3654         /* dm.dmPanningWidth */
3655         /* dm.dmPanningHeight */
3656
3657     if(unicode) {
3658         if(buflen >= sizeof(DEVMODEW)) {
3659             DEVMODEW *pdmW = GdiConvertToDevmodeW(&dm);
3660             memcpy(ptr, pdmW, sizeof(DEVMODEW));
3661             HeapFree(GetProcessHeap(),0,pdmW);
3662         }
3663         *needed = sizeof(DEVMODEW);
3664     }
3665     else
3666     {
3667         if(buflen >= sizeof(DEVMODEA)) {
3668             memcpy(ptr, &dm, sizeof(DEVMODEA));
3669         }
3670         *needed = sizeof(DEVMODEA);
3671     }
3672 }
3673
3674 /*****************************************************************************
3675  *    WINSPOOL_GetDevModeFromReg
3676  *
3677  * Get ValueName from hkey storing result in ptr.  buflen is space left in ptr
3678  * DevMode is stored either as unicode or ascii.
3679  */
3680 static BOOL WINSPOOL_GetDevModeFromReg(HKEY hkey, LPCWSTR ValueName,
3681                                        LPBYTE ptr,
3682                                        DWORD buflen, DWORD *needed,
3683                                        BOOL unicode)
3684 {
3685     DWORD sz = buflen, type;
3686     LONG ret;
3687
3688     if (ptr && buflen>=sizeof(DEVMODEA)) memset(ptr, 0, sizeof(DEVMODEA));
3689     ret = RegQueryValueExW(hkey, ValueName, 0, &type, ptr, &sz);
3690     if ((ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)) sz = 0;
3691     if (sz < sizeof(DEVMODEA))
3692     {
3693         TRACE("corrupted registry for %s ( size %d)\n",debugstr_w(ValueName),sz);
3694         return FALSE;
3695     }
3696     /* ensures that dmSize is not erratically bogus if registry is invalid */
3697     if (ptr && ((DEVMODEA*)ptr)->dmSize < sizeof(DEVMODEA))
3698         ((DEVMODEA*)ptr)->dmSize = sizeof(DEVMODEA);
3699     if(unicode) {
3700         sz += (CCHDEVICENAME + CCHFORMNAME);
3701         if(buflen >= sz) {
3702             DEVMODEW *dmW = GdiConvertToDevmodeW((DEVMODEA*)ptr);
3703             memcpy(ptr, dmW, sz);
3704             HeapFree(GetProcessHeap(),0,dmW);
3705         }
3706     }
3707     *needed = sz;
3708     return TRUE;
3709 }
3710
3711 /*********************************************************************
3712  *    WINSPOOL_GetPrinter_1
3713  *
3714  * Fills out a PRINTER_INFO_1A|W struct storing the strings in buf.
3715  * The strings are either stored as unicode or ascii.
3716  */
3717 static BOOL WINSPOOL_GetPrinter_1(HKEY hkeyPrinter, PRINTER_INFO_1W *pi1,
3718                                   LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
3719                                   BOOL unicode)
3720 {
3721     DWORD size, left = cbBuf;
3722     BOOL space = (cbBuf > 0);
3723     LPBYTE ptr = buf;
3724
3725     *pcbNeeded = 0;
3726
3727     if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3728                                  unicode)) {
3729         if(space && size <= left) {
3730             pi1->pName = (LPWSTR)ptr;
3731             ptr += size;
3732             left -= size;
3733         } else
3734             space = FALSE;
3735         *pcbNeeded += size;
3736     }
3737
3738     /* FIXME: pDescription should be something like "Name,Driver_Name,". */
3739     if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3740                                  unicode)) {
3741         if(space && size <= left) {
3742             pi1->pDescription = (LPWSTR)ptr;
3743             ptr += size;
3744             left -= size;
3745         } else
3746             space = FALSE;
3747         *pcbNeeded += size;
3748     }
3749
3750     if(WINSPOOL_GetStringFromReg(hkeyPrinter, DescriptionW, ptr, left, &size,
3751                                  unicode)) {
3752         if(space && size <= left) {
3753             pi1->pComment = (LPWSTR)ptr;
3754             ptr += size;
3755             left -= size;
3756         } else
3757             space = FALSE;
3758         *pcbNeeded += size;
3759     }
3760
3761     if(pi1) pi1->Flags = PRINTER_ENUM_ICON8; /* We're a printer */
3762
3763     if(!space && pi1) /* zero out pi1 if we can't completely fill buf */
3764         memset(pi1, 0, sizeof(*pi1));
3765
3766     return space;
3767 }
3768 /*********************************************************************
3769  *    WINSPOOL_GetPrinter_2
3770  *
3771  * Fills out a PRINTER_INFO_2A|W struct storing the strings in buf.
3772  * The strings are either stored as unicode or ascii.
3773  */
3774 static BOOL WINSPOOL_GetPrinter_2(HKEY hkeyPrinter, PRINTER_INFO_2W *pi2,
3775                                   LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
3776                                   BOOL unicode)
3777 {
3778     DWORD size, left = cbBuf;
3779     BOOL space = (cbBuf > 0);
3780     LPBYTE ptr = buf;
3781
3782     *pcbNeeded = 0;
3783
3784     if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3785                                  unicode)) {
3786         if(space && size <= left) {
3787             pi2->pPrinterName = (LPWSTR)ptr;
3788             ptr += size;
3789             left -= size;
3790         } else
3791             space = FALSE;
3792         *pcbNeeded += size;
3793     }
3794     if(WINSPOOL_GetStringFromReg(hkeyPrinter, Share_NameW, ptr, left, &size,
3795                                  unicode)) {
3796         if(space && size <= left) {
3797             pi2->pShareName = (LPWSTR)ptr;
3798             ptr += size;
3799             left -= size;
3800         } else
3801             space = FALSE;
3802         *pcbNeeded += size;
3803     }
3804     if(WINSPOOL_GetStringFromReg(hkeyPrinter, PortW, ptr, left, &size,
3805                                  unicode)) {
3806         if(space && size <= left) {
3807             pi2->pPortName = (LPWSTR)ptr;
3808             ptr += size;
3809             left -= size;
3810         } else
3811             space = FALSE;
3812         *pcbNeeded += size;
3813     }
3814     if(WINSPOOL_GetStringFromReg(hkeyPrinter, Printer_DriverW, ptr, left,
3815                                  &size, unicode)) {
3816         if(space && size <= left) {
3817             pi2->pDriverName = (LPWSTR)ptr;
3818             ptr += size;
3819             left -= size;
3820         } else
3821             space = FALSE;
3822         *pcbNeeded += size;
3823     }
3824     if(WINSPOOL_GetStringFromReg(hkeyPrinter, DescriptionW, ptr, left, &size,
3825                                  unicode)) {
3826         if(space && size <= left) {
3827             pi2->pComment = (LPWSTR)ptr;
3828             ptr += size;
3829             left -= size;
3830         } else
3831             space = FALSE;
3832         *pcbNeeded += size;
3833     }
3834     if(WINSPOOL_GetStringFromReg(hkeyPrinter, LocationW, ptr, left, &size,
3835                                  unicode)) {
3836         if(space && size <= left) {
3837             pi2->pLocation = (LPWSTR)ptr;
3838             ptr += size;
3839             left -= size;
3840         } else
3841             space = FALSE;
3842         *pcbNeeded += size;
3843     }
3844     if(WINSPOOL_GetDevModeFromReg(hkeyPrinter, Default_DevModeW, ptr, left,
3845                                   &size, unicode)) {
3846         if(space && size <= left) {
3847             pi2->pDevMode = (LPDEVMODEW)ptr;
3848             ptr += size;
3849             left -= size;
3850         } else
3851             space = FALSE;
3852         *pcbNeeded += size;
3853     }
3854     else
3855     {
3856         WINSPOOL_GetDefaultDevMode(ptr, left, &size, unicode);
3857         if(space && size <= left) {
3858             pi2->pDevMode = (LPDEVMODEW)ptr;
3859             ptr += size;
3860             left -= size;
3861         } else
3862             space = FALSE;
3863         *pcbNeeded += size;
3864     }
3865     if(WINSPOOL_GetStringFromReg(hkeyPrinter, Separator_FileW, ptr, left,
3866                                  &size, unicode)) {
3867         if(space && size <= left) {
3868             pi2->pSepFile = (LPWSTR)ptr;
3869             ptr += size;
3870             left -= size;
3871         } else
3872             space = FALSE;
3873         *pcbNeeded += size;
3874     }
3875     if(WINSPOOL_GetStringFromReg(hkeyPrinter, Print_ProcessorW, ptr, left,
3876                                  &size, unicode)) {
3877         if(space && size <= left) {
3878             pi2->pPrintProcessor = (LPWSTR)ptr;
3879             ptr += size;
3880             left -= size;
3881         } else
3882             space = FALSE;
3883         *pcbNeeded += size;
3884     }
3885     if(WINSPOOL_GetStringFromReg(hkeyPrinter, DatatypeW, ptr, left,
3886                                  &size, unicode)) {
3887         if(space && size <= left) {
3888             pi2->pDatatype = (LPWSTR)ptr;
3889             ptr += size;
3890             left -= size;
3891         } else
3892             space = FALSE;
3893         *pcbNeeded += size;
3894     }
3895     if(WINSPOOL_GetStringFromReg(hkeyPrinter, ParametersW, ptr, left,
3896                                  &size, unicode)) {
3897         if(space && size <= left) {
3898             pi2->pParameters = (LPWSTR)ptr;
3899             ptr += size;
3900             left -= size;
3901         } else
3902             space = FALSE;
3903         *pcbNeeded += size;
3904     }
3905     if(pi2) {
3906         pi2->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
3907         pi2->Priority = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Priority");
3908         pi2->DefaultPriority = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
3909                                                         "Default Priority");
3910         pi2->StartTime = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "StartTime");
3911         pi2->UntilTime = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "UntilTime");
3912     }
3913
3914     if(!space && pi2) /* zero out pi2 if we can't completely fill buf */
3915         memset(pi2, 0, sizeof(*pi2));
3916
3917     return space;
3918 }
3919
3920 /*********************************************************************
3921  *    WINSPOOL_GetPrinter_4
3922  *
3923  * Fills out a PRINTER_INFO_4 struct storing the strings in buf.
3924  */
3925 static BOOL WINSPOOL_GetPrinter_4(HKEY hkeyPrinter, PRINTER_INFO_4W *pi4,
3926                                   LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
3927                                   BOOL unicode)
3928 {
3929     DWORD size, left = cbBuf;
3930     BOOL space = (cbBuf > 0);
3931     LPBYTE ptr = buf;
3932
3933     *pcbNeeded = 0;
3934
3935     if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3936                                  unicode)) {
3937         if(space && size <= left) {
3938             pi4->pPrinterName = (LPWSTR)ptr;
3939             ptr += size;
3940             left -= size;
3941         } else
3942             space = FALSE;
3943         *pcbNeeded += size;
3944     }
3945     if(pi4) {
3946         pi4->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
3947     }
3948
3949     if(!space && pi4) /* zero out pi4 if we can't completely fill buf */
3950         memset(pi4, 0, sizeof(*pi4));
3951
3952     return space;
3953 }
3954
3955 /*********************************************************************
3956  *    WINSPOOL_GetPrinter_5
3957  *
3958  * Fills out a PRINTER_INFO_5 struct storing the strings in buf.
3959  */
3960 static BOOL WINSPOOL_GetPrinter_5(HKEY hkeyPrinter, PRINTER_INFO_5W *pi5,
3961                                   LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
3962                                   BOOL unicode)
3963 {
3964     DWORD size, left = cbBuf;
3965     BOOL space = (cbBuf > 0);
3966     LPBYTE ptr = buf;
3967
3968     *pcbNeeded = 0;
3969
3970     if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3971                                  unicode)) {
3972         if(space && size <= left) {
3973             pi5->pPrinterName = (LPWSTR)ptr;
3974             ptr += size;
3975             left -= size;
3976         } else
3977             space = FALSE;
3978         *pcbNeeded += size;
3979     }
3980     if(WINSPOOL_GetStringFromReg(hkeyPrinter, PortW, ptr, left, &size,
3981                                  unicode)) {
3982         if(space && size <= left) {
3983             pi5->pPortName = (LPWSTR)ptr;
3984             ptr += size;
3985             left -= size;
3986         } else
3987             space = FALSE;
3988         *pcbNeeded += size;
3989     }
3990     if(pi5) {
3991         pi5->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
3992         pi5->DeviceNotSelectedTimeout = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
3993                                                                 "dnsTimeout");
3994         pi5->TransmissionRetryTimeout = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
3995                                                                  "txTimeout");
3996     }
3997
3998     if(!space && pi5) /* zero out pi5 if we can't completely fill buf */
3999         memset(pi5, 0, sizeof(*pi5));
4000
4001     return space;
4002 }
4003
4004 /*********************************************************************
4005  *    WINSPOOL_GetPrinter_7
4006  *
4007  * Fills out a PRINTER_INFO_7 struct storing the strings in buf.
4008  */
4009 static BOOL WINSPOOL_GetPrinter_7(HKEY hkeyPrinter, PRINTER_INFO_7W *pi7, LPBYTE buf,
4010                                   DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
4011 {
4012     DWORD size, left = cbBuf;
4013     BOOL space = (cbBuf > 0);
4014     LPBYTE ptr = buf;
4015
4016     *pcbNeeded = 0;
4017
4018     if (WINSPOOL_GetStringFromReg(hkeyPrinter, ObjectGUIDW, ptr, left, &size, unicode))
4019     {
4020         if (space && size <= left) {
4021             pi7->pszObjectGUID = (LPWSTR)ptr;
4022             ptr += size;
4023             left -= size;
4024         } else
4025             space = FALSE;
4026         *pcbNeeded += size;
4027     }
4028     if (pi7) {
4029         /* We do not have a Directory Service */
4030         pi7->dwAction = DSPRINT_UNPUBLISH;
4031     }
4032
4033     if (!space && pi7) /* zero out pi7 if we can't completely fill buf */
4034         memset(pi7, 0, sizeof(*pi7));
4035
4036     return space;
4037 }
4038
4039 /*********************************************************************
4040  *    WINSPOOL_GetPrinter_9
4041  *
4042  * Fills out a PRINTER_INFO_9A|W struct storing the strings in buf.
4043  * The strings are either stored as unicode or ascii.
4044  */
4045 static BOOL WINSPOOL_GetPrinter_9(HKEY hkeyPrinter, PRINTER_INFO_9W *pi9, LPBYTE buf,
4046                                   DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
4047 {
4048     DWORD size;
4049     BOOL space = (cbBuf > 0);
4050
4051     *pcbNeeded = 0;
4052
4053     if(WINSPOOL_GetDevModeFromReg(hkeyPrinter, Default_DevModeW, buf, cbBuf, &size, unicode)) {
4054         if(space && size <= cbBuf) {
4055             pi9->pDevMode = (LPDEVMODEW)buf;
4056         } else
4057             space = FALSE;
4058         *pcbNeeded += size;
4059     }
4060     else
4061     {
4062         WINSPOOL_GetDefaultDevMode(buf, cbBuf, &size, unicode);
4063         if(space && size <= cbBuf) {
4064             pi9->pDevMode = (LPDEVMODEW)buf;
4065         } else
4066             space = FALSE;
4067         *pcbNeeded += size;
4068     }
4069
4070     if(!space && pi9) /* zero out pi9 if we can't completely fill buf */
4071         memset(pi9, 0, sizeof(*pi9));
4072
4073     return space;
4074 }
4075
4076 /*****************************************************************************
4077  *          WINSPOOL_GetPrinter
4078  *
4079  *    Implementation of GetPrinterA|W.  Relies on PRINTER_INFO_*W being
4080  *    essentially the same as PRINTER_INFO_*A. i.e. the structure itself is
4081  *    just a collection of pointers to strings.
4082  */
4083 static BOOL WINSPOOL_GetPrinter(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
4084                                 DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
4085 {
4086     LPCWSTR name;
4087     DWORD size, needed = 0;
4088     LPBYTE ptr = NULL;
4089     HKEY hkeyPrinter, hkeyPrinters;
4090     BOOL ret;
4091
4092     TRACE("(%p,%d,%p,%d,%p)\n",hPrinter,Level,pPrinter,cbBuf, pcbNeeded);
4093
4094     if (!(name = get_opened_printer_name(hPrinter))) {
4095         SetLastError(ERROR_INVALID_HANDLE);
4096         return FALSE;
4097     }
4098
4099     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
4100        ERROR_SUCCESS) {
4101         ERR("Can't create Printers key\n");
4102         return FALSE;
4103     }
4104     if(RegOpenKeyW(hkeyPrinters, name, &hkeyPrinter) != ERROR_SUCCESS)
4105     {
4106         ERR("Can't find opened printer %s in registry\n", debugstr_w(name));
4107         RegCloseKey(hkeyPrinters);
4108         SetLastError(ERROR_INVALID_PRINTER_NAME); /* ? */
4109         return FALSE;
4110     }
4111
4112     switch(Level) {
4113     case 2:
4114       {
4115         PRINTER_INFO_2W *pi2 = (PRINTER_INFO_2W *)pPrinter;
4116
4117         size = sizeof(PRINTER_INFO_2W);
4118         if(size <= cbBuf) {
4119             ptr = pPrinter + size;
4120             cbBuf -= size;
4121             memset(pPrinter, 0, size);
4122         } else {
4123             pi2 = NULL;
4124             cbBuf = 0;
4125         }
4126         ret = WINSPOOL_GetPrinter_2(hkeyPrinter, pi2, ptr, cbBuf, &needed,
4127                                     unicode);
4128         needed += size;
4129         break;
4130       }
4131
4132     case 4:
4133       {
4134         PRINTER_INFO_4W *pi4 = (PRINTER_INFO_4W *)pPrinter;
4135
4136         size = sizeof(PRINTER_INFO_4W);
4137         if(size <= cbBuf) {
4138             ptr = pPrinter + size;
4139             cbBuf -= size;
4140             memset(pPrinter, 0, size);
4141         } else {
4142             pi4 = NULL;
4143             cbBuf = 0;
4144         }
4145         ret = WINSPOOL_GetPrinter_4(hkeyPrinter, pi4, ptr, cbBuf, &needed,
4146                                     unicode);
4147         needed += size;
4148         break;
4149       }
4150
4151
4152     case 5:
4153       {
4154         PRINTER_INFO_5W *pi5 = (PRINTER_INFO_5W *)pPrinter;
4155
4156         size = sizeof(PRINTER_INFO_5W);
4157         if(size <= cbBuf) {
4158             ptr = pPrinter + size;
4159             cbBuf -= size;
4160             memset(pPrinter, 0, size);
4161         } else {
4162             pi5 = NULL;
4163             cbBuf = 0;
4164         }
4165
4166         ret = WINSPOOL_GetPrinter_5(hkeyPrinter, pi5, ptr, cbBuf, &needed,
4167                                     unicode);
4168         needed += size;
4169         break;
4170       }
4171
4172
4173     case 6:
4174       {
4175         PRINTER_INFO_6 *pi6 = (PRINTER_INFO_6 *) pPrinter;
4176
4177         size = sizeof(PRINTER_INFO_6);
4178         if (size <= cbBuf) {
4179             /* FIXME: We do not update the status yet */
4180             pi6->dwStatus = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Status");
4181             ret = TRUE;
4182         } else {
4183             ret = FALSE;
4184         }
4185
4186         needed += size;
4187         break;
4188       }
4189
4190     case 7:
4191       {
4192         PRINTER_INFO_7W *pi7 = (PRINTER_INFO_7W *) pPrinter;
4193
4194         size = sizeof(PRINTER_INFO_7W);
4195         if (size <= cbBuf) {
4196             ptr = pPrinter + size;
4197             cbBuf -= size;
4198             memset(pPrinter, 0, size);
4199         } else {
4200             pi7 = NULL;
4201             cbBuf = 0;
4202         }
4203
4204         ret = WINSPOOL_GetPrinter_7(hkeyPrinter, pi7, ptr, cbBuf, &needed, unicode);
4205         needed += size;
4206         break;
4207       }
4208
4209
4210     case 9:
4211       {
4212         PRINTER_INFO_9W *pi9 = (PRINTER_INFO_9W *)pPrinter;
4213
4214         size = sizeof(PRINTER_INFO_9W);
4215         if(size <= cbBuf) {
4216             ptr = pPrinter + size;
4217             cbBuf -= size;
4218             memset(pPrinter, 0, size);
4219         } else {
4220             pi9 = NULL;
4221             cbBuf = 0;
4222         }
4223
4224         ret = WINSPOOL_GetPrinter_9(hkeyPrinter, pi9, ptr, cbBuf, &needed, unicode);
4225         needed += size;
4226         break;
4227       }
4228
4229
4230     default:
4231         FIXME("Unimplemented level %d\n", Level);
4232         SetLastError(ERROR_INVALID_LEVEL);
4233         RegCloseKey(hkeyPrinters);
4234         RegCloseKey(hkeyPrinter);
4235         return FALSE;
4236     }
4237
4238     RegCloseKey(hkeyPrinter);
4239     RegCloseKey(hkeyPrinters);
4240
4241     TRACE("returning %d needed = %d\n", ret, needed);
4242     if(pcbNeeded) *pcbNeeded = needed;
4243     if(!ret)
4244         SetLastError(ERROR_INSUFFICIENT_BUFFER);
4245     return ret;
4246 }
4247
4248 /*****************************************************************************
4249  *          GetPrinterW  [WINSPOOL.@]
4250  */
4251 BOOL WINAPI GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
4252                         DWORD cbBuf, LPDWORD pcbNeeded)
4253 {
4254     return WINSPOOL_GetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded,
4255                                TRUE);
4256 }
4257
4258 /*****************************************************************************
4259  *          GetPrinterA  [WINSPOOL.@]
4260  */
4261 BOOL WINAPI GetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
4262                     DWORD cbBuf, LPDWORD pcbNeeded)
4263 {
4264     return WINSPOOL_GetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded,
4265                                FALSE);
4266 }
4267
4268 /*****************************************************************************
4269  *          WINSPOOL_EnumPrinters
4270  *
4271  *    Implementation of EnumPrintersA|W
4272  */
4273 static BOOL WINSPOOL_EnumPrinters(DWORD dwType, LPWSTR lpszName,
4274                                   DWORD dwLevel, LPBYTE lpbPrinters,
4275                                   DWORD cbBuf, LPDWORD lpdwNeeded,
4276                                   LPDWORD lpdwReturned, BOOL unicode)
4277
4278 {
4279     HKEY hkeyPrinters, hkeyPrinter;
4280     WCHAR PrinterName[255];
4281     DWORD needed = 0, number = 0;
4282     DWORD used, i, left;
4283     PBYTE pi, buf;
4284
4285     if(lpbPrinters)
4286         memset(lpbPrinters, 0, cbBuf);
4287     if(lpdwReturned)
4288         *lpdwReturned = 0;
4289     if(lpdwNeeded)
4290         *lpdwNeeded = 0;
4291
4292     /* PRINTER_ENUM_DEFAULT is only supported under win9x, we behave like NT */
4293     if(dwType == PRINTER_ENUM_DEFAULT)
4294         return TRUE;
4295
4296     if (dwType & PRINTER_ENUM_CONNECTIONS) {
4297         TRACE("ignoring PRINTER_ENUM_CONNECTIONS\n");
4298         dwType &= ~PRINTER_ENUM_CONNECTIONS; /* we don't handle that */
4299         if (!dwType) {
4300             FIXME("We don't handle PRINTER_ENUM_CONNECTIONS\n");
4301             *lpdwNeeded = 0;
4302             *lpdwReturned = 0;
4303             return TRUE;
4304         }
4305
4306     }
4307
4308     if (!((dwType & PRINTER_ENUM_LOCAL) || (dwType & PRINTER_ENUM_NAME))) {
4309         FIXME("dwType = %08x\n", dwType);
4310         SetLastError(ERROR_INVALID_FLAGS);
4311         return FALSE;
4312     }
4313
4314     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
4315        ERROR_SUCCESS) {
4316         ERR("Can't create Printers key\n");
4317         return FALSE;
4318     }
4319
4320     if(RegQueryInfoKeyA(hkeyPrinters, NULL, NULL, NULL, &number, NULL, NULL,
4321                         NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
4322         RegCloseKey(hkeyPrinters);
4323         ERR("Can't query Printers key\n");
4324         return FALSE;
4325     }
4326     TRACE("Found %d printers\n", number);
4327
4328     switch(dwLevel) {
4329     case 1:
4330         used = number * sizeof(PRINTER_INFO_1W);
4331         break;
4332     case 2:
4333         used = number * sizeof(PRINTER_INFO_2W);
4334         break;
4335     case 4:
4336         used = number * sizeof(PRINTER_INFO_4W);
4337         break;
4338     case 5:
4339         used = number * sizeof(PRINTER_INFO_5W);
4340         break;
4341
4342     default:
4343         SetLastError(ERROR_INVALID_LEVEL);
4344         RegCloseKey(hkeyPrinters);
4345         return FALSE;
4346     }
4347     pi = (used <= cbBuf) ? lpbPrinters : NULL;
4348
4349     for(i = 0; i < number; i++) {
4350         if(RegEnumKeyW(hkeyPrinters, i, PrinterName, sizeof(PrinterName)/sizeof(PrinterName[0])) !=
4351            ERROR_SUCCESS) {
4352             ERR("Can't enum key number %d\n", i);
4353             RegCloseKey(hkeyPrinters);
4354             return FALSE;
4355         }
4356         TRACE("Printer %d is %s\n", i, debugstr_w(PrinterName));
4357         if(RegOpenKeyW(hkeyPrinters, PrinterName, &hkeyPrinter) !=
4358            ERROR_SUCCESS) {
4359             ERR("Can't open key %s\n", debugstr_w(PrinterName));
4360             RegCloseKey(hkeyPrinters);
4361             return FALSE;
4362         }
4363
4364         if(cbBuf > used) {
4365             buf = lpbPrinters + used;
4366             left = cbBuf - used;
4367         } else {
4368             buf = NULL;
4369             left = 0;
4370         }
4371
4372         switch(dwLevel) {
4373         case 1:
4374             WINSPOOL_GetPrinter_1(hkeyPrinter, (PRINTER_INFO_1W *)pi, buf,
4375                                   left, &needed, unicode);
4376             used += needed;
4377             if(pi) pi += sizeof(PRINTER_INFO_1W);
4378             break;
4379         case 2:
4380             WINSPOOL_GetPrinter_2(hkeyPrinter, (PRINTER_INFO_2W *)pi, buf,
4381                                   left, &needed, unicode);
4382             used += needed;
4383             if(pi) pi += sizeof(PRINTER_INFO_2W);
4384             break;
4385         case 4:
4386             WINSPOOL_GetPrinter_4(hkeyPrinter, (PRINTER_INFO_4W *)pi, buf,
4387                                   left, &needed, unicode);
4388             used += needed;
4389             if(pi) pi += sizeof(PRINTER_INFO_4W);
4390             break;
4391         case 5:
4392             WINSPOOL_GetPrinter_5(hkeyPrinter, (PRINTER_INFO_5W *)pi, buf,
4393                                   left, &needed, unicode);
4394             used += needed;
4395             if(pi) pi += sizeof(PRINTER_INFO_5W);
4396             break;
4397         default:
4398             ERR("Shouldn't be here!\n");
4399             RegCloseKey(hkeyPrinter);
4400             RegCloseKey(hkeyPrinters);
4401             return FALSE;
4402         }
4403         RegCloseKey(hkeyPrinter);
4404     }
4405     RegCloseKey(hkeyPrinters);
4406
4407     if(lpdwNeeded)
4408         *lpdwNeeded = used;
4409
4410     if(used > cbBuf) {
4411         if(lpbPrinters)
4412             memset(lpbPrinters, 0, cbBuf);
4413         SetLastError(ERROR_INSUFFICIENT_BUFFER);
4414         return FALSE;
4415     }
4416     if(lpdwReturned)
4417         *lpdwReturned = number;
4418     SetLastError(ERROR_SUCCESS);
4419     return TRUE;
4420 }
4421
4422
4423 /******************************************************************
4424  *              EnumPrintersW        [WINSPOOL.@]
4425  *
4426  *    Enumerates the available printers, print servers and print
4427  *    providers, depending on the specified flags, name and level.
4428  *
4429  * RETURNS:
4430  *
4431  *    If level is set to 1:
4432  *      Returns an array of PRINTER_INFO_1 data structures in the
4433  *      lpbPrinters buffer.
4434  *
4435  *    If level is set to 2:
4436  *              Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
4437  *      Returns an array of PRINTER_INFO_2 data structures in the
4438  *      lpbPrinters buffer. Note that according to MSDN also an
4439  *      OpenPrinter should be performed on every remote printer.
4440  *
4441  *    If level is set to 4 (officially WinNT only):
4442  *              Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
4443  *      Fast: Only the registry is queried to retrieve printer names,
4444  *      no connection to the driver is made.
4445  *      Returns an array of PRINTER_INFO_4 data structures in the
4446  *      lpbPrinters buffer.
4447  *
4448  *    If level is set to 5 (officially WinNT4/Win9x only):
4449  *      Fast: Only the registry is queried to retrieve printer names,
4450  *      no connection to the driver is made.
4451  *      Returns an array of PRINTER_INFO_5 data structures in the
4452  *      lpbPrinters buffer.
4453  *
4454  *    If level set to 3 or 6+:
4455  *          returns zero (failure!)
4456  *
4457  *    Returns nonzero (TRUE) on success, or zero on failure, use GetLastError
4458  *    for information.
4459  *
4460  * BUGS:
4461  *    - Only PRINTER_ENUM_LOCAL and PRINTER_ENUM_NAME are implemented.
4462  *    - Only levels 2, 4 and 5 are implemented at the moment.
4463  *    - 16-bit printer drivers are not enumerated.
4464  *    - Returned amount of bytes used/needed does not match the real Windoze
4465  *      implementation (as in this implementation, all strings are part
4466  *      of the buffer, whereas Win32 keeps them somewhere else)
4467  *    - At level 2, EnumPrinters should also call OpenPrinter for remote printers.
4468  *
4469  * NOTE:
4470  *    - In a regular Wine installation, no registry settings for printers
4471  *      exist, which makes this function return an empty list.
4472  */
4473 BOOL  WINAPI EnumPrintersW(
4474                 DWORD dwType,        /* [in] Types of print objects to enumerate */
4475                 LPWSTR lpszName,     /* [in] name of objects to enumerate */
4476                 DWORD dwLevel,       /* [in] type of printer info structure */
4477                 LPBYTE lpbPrinters,  /* [out] buffer which receives info */
4478                 DWORD cbBuf,         /* [in] max size of buffer in bytes */
4479                 LPDWORD lpdwNeeded,  /* [out] pointer to var: # bytes used/needed */
4480                 LPDWORD lpdwReturned /* [out] number of entries returned */
4481                 )
4482 {
4483     return WINSPOOL_EnumPrinters(dwType, lpszName, dwLevel, lpbPrinters, cbBuf,
4484                                  lpdwNeeded, lpdwReturned, TRUE);
4485 }
4486
4487 /******************************************************************
4488  *              EnumPrintersA        [WINSPOOL.@]
4489  *
4490  */
4491 BOOL WINAPI EnumPrintersA(DWORD dwType, LPSTR lpszName,
4492                           DWORD dwLevel, LPBYTE lpbPrinters,
4493                           DWORD cbBuf, LPDWORD lpdwNeeded,
4494                           LPDWORD lpdwReturned)
4495 {
4496     BOOL ret, unicode = FALSE;
4497     UNICODE_STRING lpszNameW;
4498     PWSTR pwstrNameW;
4499
4500     pwstrNameW = asciitounicode(&lpszNameW,lpszName);
4501     if(!cbBuf) unicode = TRUE; /* return a buffer that's big enough for the unicode version */
4502     ret = WINSPOOL_EnumPrinters(dwType, pwstrNameW, dwLevel, lpbPrinters, cbBuf,
4503                                 lpdwNeeded, lpdwReturned, unicode);
4504     RtlFreeUnicodeString(&lpszNameW);
4505     return ret;
4506 }
4507
4508 /*****************************************************************************
4509  *          WINSPOOL_GetDriverInfoFromReg [internal]
4510  *
4511  *    Enters the information from the registry into the DRIVER_INFO struct
4512  *
4513  * RETURNS
4514  *    zero if the printer driver does not exist in the registry
4515  *    (only if Level > 1) otherwise nonzero
4516  */
4517 static BOOL WINSPOOL_GetDriverInfoFromReg(
4518                             HKEY    hkeyDrivers,
4519                             LPWSTR  DriverName,
4520                             const printenv_t * env,
4521                             DWORD   Level,
4522                             LPBYTE  ptr,            /* DRIVER_INFO */
4523                             LPBYTE  pDriverStrings, /* strings buffer */
4524                             DWORD   cbBuf,          /* size of string buffer */
4525                             LPDWORD pcbNeeded,      /* space needed for str. */
4526                             BOOL    unicode)        /* type of strings */
4527 {
4528     DWORD  size, tmp;
4529     HKEY   hkeyDriver;
4530     WCHAR  driverdir[MAX_PATH];
4531     DWORD  dirlen;
4532     LPBYTE strPtr = pDriverStrings;
4533     LPDRIVER_INFO_8W di = (LPDRIVER_INFO_8W) ptr;
4534
4535     TRACE("(%p, %s, %p, %d, %p, %p, %d, %d)\n", hkeyDrivers,
4536           debugstr_w(DriverName), env,
4537           Level, di, pDriverStrings, cbBuf, unicode);
4538
4539     if (di) ZeroMemory(di, di_sizeof[Level]);
4540
4541     if (unicode) {
4542         *pcbNeeded = (lstrlenW(DriverName) + 1) * sizeof(WCHAR);
4543         if (*pcbNeeded <= cbBuf)
4544            strcpyW((LPWSTR)strPtr, DriverName);
4545     }
4546     else
4547     {
4548         *pcbNeeded = WideCharToMultiByte(CP_ACP, 0, DriverName, -1, NULL, 0, NULL, NULL);
4549         if (*pcbNeeded <= cbBuf)
4550             WideCharToMultiByte(CP_ACP, 0, DriverName, -1, (LPSTR)strPtr, *pcbNeeded, NULL, NULL);
4551     }
4552
4553     /* pName for level 1 has a different offset! */
4554     if (Level == 1) {
4555        if (di) ((LPDRIVER_INFO_1W) di)->pName = (LPWSTR) strPtr;
4556        return TRUE;
4557     }
4558
4559     /* .cVersion and .pName for level > 1 */
4560     if (di) {
4561         di->cVersion = env->driverversion;
4562         di->pName = (LPWSTR) strPtr;
4563         strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
4564     }
4565
4566     /* Reserve Space for the largest subdir and a Backslash*/
4567     size = sizeof(driverdir) - sizeof(Version3_SubdirW) - sizeof(WCHAR);
4568     if (!GetPrinterDriverDirectoryW(NULL, (LPWSTR) env->envname, 1, (LPBYTE) driverdir, size, &size)) {
4569         /* Should never Fail */
4570         return FALSE;
4571     }
4572     lstrcatW(driverdir, env->versionsubdir);
4573     lstrcatW(driverdir, backslashW);
4574
4575     /* dirlen must not include the terminating zero */
4576     dirlen = (unicode) ? lstrlenW(driverdir) * sizeof(WCHAR) :
4577              WideCharToMultiByte(CP_ACP, 0, driverdir, -1, NULL, 0, NULL, NULL) -1;
4578
4579     if (!DriverName[0] || RegOpenKeyW(hkeyDrivers, DriverName, &hkeyDriver) != ERROR_SUCCESS) {
4580         ERR("Can't find driver %s in registry\n", debugstr_w(DriverName));
4581         SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER); /* ? */
4582         return FALSE;
4583     }
4584
4585     /* pEnvironment */
4586     if (unicode)
4587         size = (lstrlenW(env->envname) + 1) * sizeof(WCHAR);
4588     else
4589         size = WideCharToMultiByte(CP_ACP, 0, env->envname, -1, NULL, 0, NULL, NULL);
4590
4591     *pcbNeeded += size;
4592     if (*pcbNeeded <= cbBuf) {
4593         if (unicode) {
4594             lstrcpyW((LPWSTR)strPtr, env->envname);
4595         }
4596         else
4597         {
4598             WideCharToMultiByte(CP_ACP, 0, env->envname, -1, (LPSTR)strPtr, size, NULL, NULL);
4599         }
4600         if (di) di->pEnvironment = (LPWSTR)strPtr;
4601         strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
4602     }
4603
4604     /* .pDriverPath is the Graphics rendering engine.
4605         The full Path is required to avoid a crash in some apps */
4606     if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, DriverW, strPtr, 0, &size, unicode)) {
4607         *pcbNeeded += size;
4608         if (*pcbNeeded <= cbBuf)
4609             get_filename_from_reg(hkeyDriver, driverdir, dirlen, DriverW, strPtr, size, &tmp, unicode);
4610
4611         if (di) di->pDriverPath = (LPWSTR)strPtr;
4612         strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
4613     }
4614
4615     /* .pDataFile: For postscript-drivers, this is the ppd-file */
4616     if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, Data_FileW, strPtr, 0, &size, unicode)) {
4617         *pcbNeeded += size;
4618         if (*pcbNeeded <= cbBuf)
4619             get_filename_from_reg(hkeyDriver, driverdir, dirlen, Data_FileW, strPtr, size, &size, unicode);
4620
4621         if (di) di->pDataFile = (LPWSTR)strPtr;
4622         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4623     }
4624
4625     /* .pConfigFile is the Driver user Interface */
4626     if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, Configuration_FileW, strPtr, 0, &size, unicode)) {
4627         *pcbNeeded += size;
4628         if (*pcbNeeded <= cbBuf)
4629             get_filename_from_reg(hkeyDriver, driverdir, dirlen, Configuration_FileW, strPtr, size, &size, unicode);
4630
4631         if (di) di->pConfigFile = (LPWSTR)strPtr;
4632         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4633     }
4634
4635     if (Level == 2 ) {
4636         RegCloseKey(hkeyDriver);
4637         TRACE("buffer space %d required %d\n", cbBuf, *pcbNeeded);
4638         return TRUE;
4639     }
4640
4641     if (Level == 5 ) {
4642         RegCloseKey(hkeyDriver);
4643         FIXME("level 5: incomplete\n");
4644         return TRUE;
4645     }
4646
4647     /* .pHelpFile */
4648     if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, Help_FileW, strPtr, 0, &size, unicode)) {
4649         *pcbNeeded += size;
4650         if (*pcbNeeded <= cbBuf)
4651             get_filename_from_reg(hkeyDriver, driverdir, dirlen, Help_FileW, strPtr, size, &size, unicode);
4652
4653         if (di) di->pHelpFile = (LPWSTR)strPtr;
4654         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4655     }
4656
4657     /* .pDependentFiles */
4658     if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, Dependent_FilesW, strPtr, 0, &size, unicode)) {
4659         *pcbNeeded += size;
4660         if (*pcbNeeded <= cbBuf)
4661             get_filename_from_reg(hkeyDriver, driverdir, dirlen, Dependent_FilesW, strPtr, size, &size, unicode);
4662
4663         if (di) di->pDependentFiles = (LPWSTR)strPtr;
4664         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4665     }
4666     else if (GetVersion() & 0x80000000) {
4667         /* PowerPoint XP expects that pDependentFiles is always valid on win9x */
4668         size = 2 * ((unicode) ? sizeof(WCHAR) : 1);
4669         *pcbNeeded += size;
4670         if ((*pcbNeeded <= cbBuf) && strPtr) ZeroMemory(strPtr, size);
4671
4672         if (di) di->pDependentFiles = (LPWSTR)strPtr;
4673         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4674     }
4675
4676     /* .pMonitorName is the optional Language Monitor */
4677     if (WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr, 0, &size, unicode)) {
4678         *pcbNeeded += size;
4679         if (*pcbNeeded <= cbBuf)
4680             WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr, size, &size, unicode);
4681
4682         if (di) di->pMonitorName = (LPWSTR)strPtr;
4683         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4684     }
4685
4686     /* .pDefaultDataType */
4687     if (WINSPOOL_GetStringFromReg(hkeyDriver, DatatypeW, strPtr, 0, &size, unicode)) {
4688         *pcbNeeded += size;
4689         if(*pcbNeeded <= cbBuf)
4690             WINSPOOL_GetStringFromReg(hkeyDriver, DatatypeW, strPtr, size, &size, unicode);
4691
4692         if (di) di->pDefaultDataType = (LPWSTR)strPtr;
4693         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4694     }
4695
4696     if (Level == 3 ) {
4697         RegCloseKey(hkeyDriver);
4698         TRACE("buffer space %d required %d\n", cbBuf, *pcbNeeded);
4699         return TRUE;
4700     }
4701
4702     /* .pszzPreviousNames */
4703     if (WINSPOOL_GetStringFromReg(hkeyDriver, Previous_NamesW, strPtr, 0, &size, unicode)) {
4704         *pcbNeeded += size;
4705         if(*pcbNeeded <= cbBuf)
4706             WINSPOOL_GetStringFromReg(hkeyDriver, Previous_NamesW, strPtr, size, &size, unicode);
4707
4708         if (di) di->pszzPreviousNames = (LPWSTR)strPtr;
4709         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4710     }
4711
4712     if (Level == 4 ) {
4713         RegCloseKey(hkeyDriver);
4714         TRACE("buffer space %d required %d\n", cbBuf, *pcbNeeded);
4715         return TRUE;
4716     }
4717
4718     /* support is missing, but not important enough for a FIXME */
4719     TRACE("%s: DriverDate + DriverVersion not supported\n", debugstr_w(DriverName));
4720
4721     /* .pszMfgName */
4722     if (WINSPOOL_GetStringFromReg(hkeyDriver, ManufacturerW, strPtr, 0, &size, unicode)) {
4723         *pcbNeeded += size;
4724         if(*pcbNeeded <= cbBuf)
4725             WINSPOOL_GetStringFromReg(hkeyDriver, ManufacturerW, strPtr, size, &size, unicode);
4726
4727         if (di) di->pszMfgName = (LPWSTR)strPtr;
4728         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4729     }
4730
4731     /* .pszOEMUrl */
4732     if (WINSPOOL_GetStringFromReg(hkeyDriver, OEM_UrlW, strPtr, 0, &size, unicode)) {
4733         *pcbNeeded += size;
4734         if(*pcbNeeded <= cbBuf)
4735             WINSPOOL_GetStringFromReg(hkeyDriver, OEM_UrlW, strPtr, size, &size, unicode);
4736
4737         if (di) di->pszOEMUrl = (LPWSTR)strPtr;
4738         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4739     }
4740
4741     /* .pszHardwareID */
4742     if (WINSPOOL_GetStringFromReg(hkeyDriver, HardwareIDW, strPtr, 0, &size, unicode)) {
4743         *pcbNeeded += size;
4744         if(*pcbNeeded <= cbBuf)
4745             WINSPOOL_GetStringFromReg(hkeyDriver, HardwareIDW, strPtr, size, &size, unicode);
4746
4747         if (di) di->pszHardwareID = (LPWSTR)strPtr;
4748         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4749     }
4750
4751     /* .pszProvider */
4752     if (WINSPOOL_GetStringFromReg(hkeyDriver, ProviderW, strPtr, 0, &size, unicode)) {
4753         *pcbNeeded += size;
4754         if(*pcbNeeded <= cbBuf)
4755             WINSPOOL_GetStringFromReg(hkeyDriver, ProviderW, strPtr, size, &size, unicode);
4756
4757         if (di) di->pszProvider = (LPWSTR)strPtr;
4758         strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4759     }
4760
4761     if (Level == 6 ) {
4762         RegCloseKey(hkeyDriver);
4763         return TRUE;
4764     }
4765
4766     /* support is missing, but not important enough for a FIXME */
4767     TRACE("level 8: incomplete\n");
4768
4769     TRACE("buffer space %d required %d\n", cbBuf, *pcbNeeded);
4770     RegCloseKey(hkeyDriver);
4771     return TRUE;
4772 }
4773
4774 /*****************************************************************************
4775  *          WINSPOOL_GetPrinterDriver
4776  */
4777 static BOOL WINSPOOL_GetPrinterDriver(HANDLE hPrinter, LPCWSTR pEnvironment,
4778                                       DWORD Level, LPBYTE pDriverInfo,
4779                                       DWORD cbBuf, LPDWORD pcbNeeded,
4780                                       BOOL unicode)
4781 {
4782     LPCWSTR name;
4783     WCHAR DriverName[100];
4784     DWORD ret, type, size, needed = 0;
4785     LPBYTE ptr = NULL;
4786     HKEY hkeyPrinter, hkeyPrinters, hkeyDrivers;
4787     const printenv_t * env;
4788
4789     TRACE("(%p,%s,%d,%p,%d,%p)\n",hPrinter,debugstr_w(pEnvironment),
4790           Level,pDriverInfo,cbBuf, pcbNeeded);
4791
4792
4793     if (!(name = get_opened_printer_name(hPrinter))) {
4794         SetLastError(ERROR_INVALID_HANDLE);
4795         return FALSE;
4796     }
4797
4798     if (Level < 1 || Level == 7 || Level > 8) {
4799         SetLastError(ERROR_INVALID_LEVEL);
4800         return FALSE;
4801     }
4802
4803     env = validate_envW(pEnvironment);
4804     if (!env) return FALSE;     /* SetLastError() is in validate_envW */
4805
4806     if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
4807        ERROR_SUCCESS) {
4808         ERR("Can't create Printers key\n");
4809         return FALSE;
4810     }
4811     if(RegOpenKeyW(hkeyPrinters, name, &hkeyPrinter)
4812        != ERROR_SUCCESS) {
4813         ERR("Can't find opened printer %s in registry\n", debugstr_w(name));
4814         RegCloseKey(hkeyPrinters);
4815         SetLastError(ERROR_INVALID_PRINTER_NAME); /* ? */
4816         return FALSE;
4817     }
4818     size = sizeof(DriverName);
4819     DriverName[0] = 0;
4820     ret = RegQueryValueExW(hkeyPrinter, Printer_DriverW, 0, &type,
4821                            (LPBYTE)DriverName, &size);
4822     RegCloseKey(hkeyPrinter);
4823     RegCloseKey(hkeyPrinters);
4824     if(ret != ERROR_SUCCESS) {
4825         ERR("Can't get DriverName for printer %s\n", debugstr_w(name));
4826         return FALSE;
4827     }
4828
4829     hkeyDrivers = WINSPOOL_OpenDriverReg( pEnvironment, TRUE);
4830     if(!hkeyDrivers) {
4831         ERR("Can't create Drivers key\n");
4832         return FALSE;
4833     }
4834
4835     size = di_sizeof[Level];
4836     if ((size <= cbBuf) && pDriverInfo)
4837         ptr = pDriverInfo + size;
4838
4839     if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverName,
4840                          env, Level, pDriverInfo, ptr,
4841                          (cbBuf < size) ? 0 : cbBuf - size,
4842                          &needed, unicode)) {
4843             RegCloseKey(hkeyDrivers);
4844             return FALSE;
4845     }
4846
4847     RegCloseKey(hkeyDrivers);
4848
4849     if(pcbNeeded) *pcbNeeded = size + needed;
4850     TRACE("buffer space %d required %d\n", cbBuf, size + needed);
4851     if(cbBuf >= needed) return TRUE;
4852     SetLastError(ERROR_INSUFFICIENT_BUFFER);
4853     return FALSE;
4854 }
4855
4856 /*****************************************************************************
4857  *          GetPrinterDriverA  [WINSPOOL.@]
4858  */
4859 BOOL WINAPI GetPrinterDriverA(HANDLE hPrinter, LPSTR pEnvironment,
4860                               DWORD Level, LPBYTE pDriverInfo,
4861                               DWORD cbBuf, LPDWORD pcbNeeded)
4862 {
4863     BOOL ret;
4864     UNICODE_STRING pEnvW;
4865     PWSTR pwstrEnvW;
4866
4867     pwstrEnvW = asciitounicode(&pEnvW, pEnvironment);
4868     ret = WINSPOOL_GetPrinterDriver(hPrinter, pwstrEnvW, Level, pDriverInfo,
4869                                     cbBuf, pcbNeeded, FALSE);
4870     RtlFreeUnicodeString(&pEnvW);
4871     return ret;
4872 }
4873 /*****************************************************************************
4874  *          GetPrinterDriverW  [WINSPOOL.@]
4875  */
4876 BOOL WINAPI GetPrinterDriverW(HANDLE hPrinter, LPWSTR pEnvironment,
4877                                   DWORD Level, LPBYTE pDriverInfo,
4878                                   DWORD cbBuf, LPDWORD pcbNeeded)
4879 {
4880     return WINSPOOL_GetPrinterDriver(hPrinter, pEnvironment, Level,
4881                                      pDriverInfo, cbBuf, pcbNeeded, TRUE);
4882 }
4883
4884 /*****************************************************************************
4885  *       GetPrinterDriverDirectoryW  [WINSPOOL.@]
4886  *
4887  * Return the PATH for the Printer-Drivers (UNICODE)
4888  *
4889  * PARAMS
4890  *   pName            [I] Servername (NT only) or NULL (local Computer)
4891  *   pEnvironment     [I] Printing-Environment (see below) or NULL (Default)
4892  *   Level            [I] Structure-Level (must be 1)
4893  *   pDriverDirectory [O] PTR to Buffer that receives the Result
4894  *   cbBuf            [I] Size of Buffer at pDriverDirectory
4895  *   pcbNeeded        [O] PTR to DWORD that receives the size in Bytes used /
4896  *                        required for pDriverDirectory
4897  *
4898  * RETURNS
4899  *   Success: TRUE  and in pcbNeeded the Bytes used in pDriverDirectory
4900  *   Failure: FALSE and in pcbNeeded the Bytes required for pDriverDirectory,
4901  *   if cbBuf is too small
4902  *
4903  *   Native Values returned in pDriverDirectory on Success:
4904  *|  NT(Windows NT x86):  "%winsysdir%\\spool\\DRIVERS\\w32x86"
4905  *|  NT(Windows 4.0):     "%winsysdir%\\spool\\DRIVERS\\win40"
4906  *|  win9x(Windows 4.0):  "%winsysdir%"
4907  *
4908  *   "%winsysdir%" is the Value from GetSystemDirectoryW()
4909  *
4910  * FIXME
4911  *-  Only NULL or "" is supported for pName
4912  *
4913  */
4914 BOOL WINAPI GetPrinterDriverDirectoryW(LPWSTR pName, LPWSTR pEnvironment,
4915                                        DWORD Level, LPBYTE pDriverDirectory,
4916                                        DWORD cbBuf, LPDWORD pcbNeeded)
4917 {
4918     TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName),
4919           debugstr_w(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
4920
4921     if ((backend == NULL)  && !load_backend()) return FALSE;
4922
4923     if (Level != 1) {
4924         /* (Level != 1) is ignored in win9x */
4925         SetLastError(ERROR_INVALID_LEVEL);
4926         return FALSE;
4927     }
4928     if (pcbNeeded == NULL) {
4929         /* (pcbNeeded == NULL) is ignored in win9x */
4930         SetLastError(RPC_X_NULL_REF_POINTER);
4931         return FALSE;
4932     }
4933
4934     return backend->fpGetPrinterDriverDirectory(pName, pEnvironment, Level,
4935                                                 pDriverDirectory, cbBuf, pcbNeeded);
4936
4937 }
4938
4939
4940 /*****************************************************************************
4941  *       GetPrinterDriverDirectoryA  [WINSPOOL.@]
4942  *
4943  * Return the PATH for the Printer-Drivers (ANSI)
4944  *
4945  * See GetPrinterDriverDirectoryW.
4946  *
4947  * NOTES
4948  * On NT, pDriverDirectory need the same Size as the Unicode-Version
4949  *
4950  */
4951 BOOL WINAPI GetPrinterDriverDirectoryA(LPSTR pName, LPSTR pEnvironment,
4952                                        DWORD Level, LPBYTE pDriverDirectory,
4953                                        DWORD cbBuf, LPDWORD pcbNeeded)
4954 {
4955     UNICODE_STRING nameW, environmentW;
4956     BOOL ret;
4957     DWORD pcbNeededW;
4958     INT len = cbBuf * sizeof(WCHAR)/sizeof(CHAR);
4959     WCHAR *driverDirectoryW = NULL;
4960
4961     TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_a(pName),
4962           debugstr_a(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
4963
4964     if (len) driverDirectoryW = HeapAlloc( GetProcessHeap(), 0, len );
4965
4966     if(pName) RtlCreateUnicodeStringFromAsciiz(&nameW, pName);
4967     else nameW.Buffer = NULL;
4968     if(pEnvironment) RtlCreateUnicodeStringFromAsciiz(&environmentW, pEnvironment);
4969     else environmentW.Buffer = NULL;
4970
4971     ret = GetPrinterDriverDirectoryW( nameW.Buffer, environmentW.Buffer, Level,
4972                                       (LPBYTE)driverDirectoryW, len, &pcbNeededW );
4973     if (ret) {
4974         DWORD needed;
4975         needed =  WideCharToMultiByte( CP_ACP, 0, driverDirectoryW, -1,
4976                                    (LPSTR)pDriverDirectory, cbBuf, NULL, NULL);
4977         if(pcbNeeded)
4978             *pcbNeeded = needed;
4979         ret = (needed <= cbBuf) ? TRUE : FALSE;
4980     } else
4981         if(pcbNeeded) *pcbNeeded = pcbNeededW * sizeof(CHAR)/sizeof(WCHAR);
4982
4983     TRACE("required: 0x%x/%d\n", pcbNeeded ? *pcbNeeded : 0, pcbNeeded ? *pcbNeeded : 0);
4984
4985     HeapFree( GetProcessHeap(), 0, driverDirectoryW );
4986     RtlFreeUnicodeString(&environmentW);
4987     RtlFreeUnicodeString(&nameW);
4988
4989     return ret;
4990 }
4991
4992 /*****************************************************************************
4993  *          AddPrinterDriverA  [WINSPOOL.@]
4994  *
4995  * See AddPrinterDriverW.
4996  *
4997  */
4998 BOOL WINAPI AddPrinterDriverA(LPSTR pName, DWORD level, LPBYTE pDriverInfo)
4999 {
5000     TRACE("(%s, %d, %p)\n", debugstr_a(pName), level, pDriverInfo);
5001     return AddPrinterDriverExA(pName, level, pDriverInfo, APD_COPY_NEW_FILES);
5002 }
5003
5004 /******************************************************************************
5005  *  AddPrinterDriverW (WINSPOOL.@)
5006  *
5007  * Install a Printer Driver
5008  *
5009  * PARAMS
5010  *  pName           [I] Servername or NULL (local Computer)
5011  *  level           [I] Level for the supplied DRIVER_INFO_*W struct
5012  *  pDriverInfo     [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
5013  *
5014  * RESULTS
5015  *  Success: TRUE
5016  *  Failure: FALSE
5017  *
5018  */
5019 BOOL WINAPI AddPrinterDriverW(LPWSTR pName, DWORD level, LPBYTE pDriverInfo)
5020 {
5021     TRACE("(%s, %d, %p)\n", debugstr_w(pName), level, pDriverInfo);
5022     return AddPrinterDriverExW(pName, level, pDriverInfo, APD_COPY_NEW_FILES);
5023 }
5024
5025 /*****************************************************************************
5026  *          AddPrintProcessorA  [WINSPOOL.@]
5027  */
5028 BOOL WINAPI AddPrintProcessorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPathName,
5029                                LPSTR pPrintProcessorName)
5030 {
5031     FIXME("(%s,%s,%s,%s): stub\n", debugstr_a(pName), debugstr_a(pEnvironment),
5032           debugstr_a(pPathName), debugstr_a(pPrintProcessorName));
5033     return FALSE;
5034 }
5035
5036 /*****************************************************************************
5037  *          AddPrintProcessorW  [WINSPOOL.@]
5038  */
5039 BOOL WINAPI AddPrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPathName,
5040                                LPWSTR pPrintProcessorName)
5041 {
5042     FIXME("(%s,%s,%s,%s): stub\n", debugstr_w(pName), debugstr_w(pEnvironment),
5043           debugstr_w(pPathName), debugstr_w(pPrintProcessorName));
5044     return FALSE;
5045 }
5046
5047 /*****************************************************************************
5048  *          AddPrintProvidorA  [WINSPOOL.@]
5049  */
5050 BOOL WINAPI AddPrintProvidorA(LPSTR pName, DWORD Level, LPBYTE pProviderInfo)
5051 {
5052     FIXME("(%s,0x%08x,%p): stub\n", debugstr_a(pName), Level, pProviderInfo);
5053     return FALSE;
5054 }
5055
5056 /*****************************************************************************
5057  *          AddPrintProvidorW  [WINSPOOL.@]
5058  */
5059 BOOL WINAPI AddPrintProvidorW(LPWSTR pName, DWORD Level, LPBYTE pProviderInfo)
5060 {
5061     FIXME("(%s,0x%08x,%p): stub\n", debugstr_w(pName), Level, pProviderInfo);
5062     return FALSE;
5063 }
5064
5065 /*****************************************************************************
5066  *          AdvancedDocumentPropertiesA  [WINSPOOL.@]
5067  */
5068 LONG WINAPI AdvancedDocumentPropertiesA(HWND hWnd, HANDLE hPrinter, LPSTR pDeviceName,
5069                                         PDEVMODEA pDevModeOutput, PDEVMODEA pDevModeInput)
5070 {
5071     FIXME("(%p,%p,%s,%p,%p): stub\n", hWnd, hPrinter, debugstr_a(pDeviceName),
5072           pDevModeOutput, pDevModeInput);
5073     return 0;
5074 }
5075
5076 /*****************************************************************************
5077  *          AdvancedDocumentPropertiesW  [WINSPOOL.@]
5078  */
5079 LONG WINAPI AdvancedDocumentPropertiesW(HWND hWnd, HANDLE hPrinter, LPWSTR pDeviceName,
5080                                         PDEVMODEW pDevModeOutput, PDEVMODEW pDevModeInput)
5081 {
5082     FIXME("(%p,%p,%s,%p,%p): stub\n", hWnd, hPrinter, debugstr_w(pDeviceName),
5083           pDevModeOutput, pDevModeInput);
5084     return 0;
5085 }
5086
5087 /*****************************************************************************
5088  *          PrinterProperties  [WINSPOOL.@]
5089  *
5090  *     Displays a dialog to set the properties of the printer.
5091  *
5092  * RETURNS
5093  *     nonzero on success or zero on failure
5094  *
5095  * BUGS
5096  *         implemented as stub only
5097  */
5098 BOOL WINAPI PrinterProperties(HWND hWnd,      /* [in] handle to parent window */
5099                               HANDLE hPrinter /* [in] handle to printer object */
5100 ){
5101     FIXME("(%p,%p): stub\n", hWnd, hPrinter);
5102     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5103     return FALSE;
5104 }
5105
5106 /*****************************************************************************
5107  *          EnumJobsA [WINSPOOL.@]
5108  *
5109  */
5110 BOOL WINAPI EnumJobsA(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
5111                       DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
5112                       LPDWORD pcReturned)
5113 {
5114     FIXME("(%p,first=%d,no=%d,level=%d,job=%p,cb=%d,%p,%p), stub!\n",
5115         hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded, pcReturned
5116     );
5117     if(pcbNeeded) *pcbNeeded = 0;
5118     if(pcReturned) *pcReturned = 0;
5119     return FALSE;
5120 }
5121
5122
5123 /*****************************************************************************
5124  *          EnumJobsW [WINSPOOL.@]
5125  *
5126  */
5127 BOOL WINAPI EnumJobsW(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
5128                       DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
5129                       LPDWORD pcReturned)
5130 {
5131     FIXME("(%p,first=%d,no=%d,level=%d,job=%p,cb=%d,%p,%p), stub!\n",
5132         hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded, pcReturned
5133     );
5134     if(pcbNeeded) *pcbNeeded = 0;
5135     if(pcReturned) *pcReturned = 0;
5136     return FALSE;
5137 }
5138
5139 /*****************************************************************************
5140  *          WINSPOOL_EnumPrinterDrivers [internal]
5141  *
5142  *    Delivers information about all printer drivers installed on the
5143  *    localhost or a given server
5144  *
5145  * RETURNS
5146  *    nonzero on success or zero on failure. If the buffer for the returned
5147  *    information is too small the function will return an error
5148  *
5149  * BUGS
5150  *    - only implemented for localhost, foreign hosts will return an error
5151  */
5152 static BOOL WINSPOOL_EnumPrinterDrivers(LPWSTR pName, LPCWSTR pEnvironment,
5153                                         DWORD Level, LPBYTE pDriverInfo,
5154                                         DWORD cbBuf, LPDWORD pcbNeeded,
5155                                         LPDWORD pcReturned, BOOL unicode)
5156
5157 {   HKEY  hkeyDrivers;
5158     DWORD i, needed, number = 0, size = 0;
5159     WCHAR DriverNameW[255];
5160     PBYTE ptr;
5161     const printenv_t * env;
5162
5163     TRACE("%s,%s,%d,%p,%d,%d\n",
5164           debugstr_w(pName), debugstr_w(pEnvironment),
5165           Level, pDriverInfo, cbBuf, unicode);
5166
5167     /* check for local drivers */
5168     if((pName) && (pName[0])) {
5169         FIXME("remote drivers (%s) not supported!\n", debugstr_w(pName));
5170         SetLastError(ERROR_ACCESS_DENIED);
5171         return FALSE;
5172     }
5173
5174     env = validate_envW(pEnvironment);
5175     if (!env) return FALSE;     /* SetLastError() is in validate_envW */
5176
5177     /* check input parameter */
5178     if ((Level < 1) || (Level == 7) || (Level > 8)) {
5179         SetLastError(ERROR_INVALID_LEVEL);
5180         return FALSE;
5181     }
5182
5183     if ((pcbNeeded == NULL) || (pcReturned == NULL)) {
5184         SetLastError(RPC_X_NULL_REF_POINTER);
5185         return FALSE;
5186     }
5187
5188     /* initialize return values */
5189     if(pDriverInfo)
5190         memset( pDriverInfo, 0, cbBuf);
5191     *pcbNeeded  = 0;
5192     *pcReturned = 0;
5193
5194     hkeyDrivers = WINSPOOL_OpenDriverReg(pEnvironment, TRUE);
5195     if(!hkeyDrivers) {
5196         ERR("Can't open Drivers key\n");
5197         return FALSE;
5198     }
5199
5200     if(RegQueryInfoKeyA(hkeyDrivers, NULL, NULL, NULL, &number, NULL, NULL,
5201                         NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
5202         RegCloseKey(hkeyDrivers);
5203         ERR("Can't query Drivers key\n");
5204         return FALSE;
5205     }
5206     TRACE("Found %d Drivers\n", number);
5207
5208     /* get size of single struct
5209      * unicode and ascii structure have the same size
5210      */
5211     size = di_sizeof[Level];
5212
5213     /* calculate required buffer size */
5214     *pcbNeeded = size * number;
5215
5216     for( i = 0,  ptr = (pDriverInfo && (cbBuf >= size)) ? pDriverInfo : NULL ;
5217          i < number;
5218          i++, ptr = (ptr && (cbBuf >= size * i)) ? ptr + size : NULL) {
5219         if(RegEnumKeyW(hkeyDrivers, i, DriverNameW, sizeof(DriverNameW)/sizeof(DriverNameW[0]))
5220                        != ERROR_SUCCESS) {
5221             ERR("Can't enum key number %d\n", i);
5222             RegCloseKey(hkeyDrivers);
5223             return FALSE;
5224         }
5225         if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverNameW,
5226                          env, Level, ptr,
5227                          (cbBuf < *pcbNeeded) ? NULL : pDriverInfo + *pcbNeeded,
5228                          (cbBuf < *pcbNeeded) ? 0 : cbBuf - *pcbNeeded,
5229                          &needed, unicode)) {
5230             RegCloseKey(hkeyDrivers);
5231             return FALSE;
5232         }
5233         (*pcbNeeded) += needed;
5234     }
5235
5236     RegCloseKey(hkeyDrivers);
5237
5238     if(cbBuf < *pcbNeeded){
5239         SetLastError(ERROR_INSUFFICIENT_BUFFER);
5240         return FALSE;
5241     }
5242
5243     *pcReturned = number;
5244     return TRUE;
5245 }
5246
5247 /*****************************************************************************
5248  *          EnumPrinterDriversW  [WINSPOOL.@]
5249  *
5250  *    see function EnumPrinterDrivers for RETURNS, BUGS
5251  */
5252 BOOL WINAPI EnumPrinterDriversW(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
5253                                 LPBYTE pDriverInfo, DWORD cbBuf,
5254                                 LPDWORD pcbNeeded, LPDWORD pcReturned)
5255 {
5256     return WINSPOOL_EnumPrinterDrivers(pName, pEnvironment, Level, pDriverInfo,
5257                                        cbBuf, pcbNeeded, pcReturned, TRUE);
5258 }
5259
5260 /*****************************************************************************
5261  *          EnumPrinterDriversA  [WINSPOOL.@]
5262  *
5263  *    see function EnumPrinterDrivers for RETURNS, BUGS
5264  */
5265 BOOL WINAPI EnumPrinterDriversA(LPSTR pName, LPSTR pEnvironment, DWORD Level,
5266                                 LPBYTE pDriverInfo, DWORD cbBuf,
5267                                 LPDWORD pcbNeeded, LPDWORD pcReturned)
5268 {   BOOL ret;
5269     UNICODE_STRING pNameW, pEnvironmentW;
5270     PWSTR pwstrNameW, pwstrEnvironmentW;
5271
5272     pwstrNameW = asciitounicode(&pNameW, pName);
5273     pwstrEnvironmentW = asciitounicode(&pEnvironmentW, pEnvironment);
5274
5275     ret = WINSPOOL_EnumPrinterDrivers(pwstrNameW, pwstrEnvironmentW,
5276                                       Level, pDriverInfo, cbBuf, pcbNeeded,
5277                                       pcReturned, FALSE);
5278     RtlFreeUnicodeString(&pNameW);
5279     RtlFreeUnicodeString(&pEnvironmentW);
5280
5281     return ret;
5282 }
5283
5284 /******************************************************************************
5285  *              EnumPortsA   (WINSPOOL.@)
5286  *
5287  * See EnumPortsW.
5288  *
5289  */
5290 BOOL WINAPI EnumPortsA( LPSTR pName, DWORD Level, LPBYTE pPorts, DWORD cbBuf,
5291                         LPDWORD pcbNeeded, LPDWORD pcReturned)
5292 {
5293     BOOL    res;
5294     LPBYTE  bufferW = NULL;
5295     LPWSTR  nameW = NULL;
5296     DWORD   needed = 0;
5297     DWORD   numentries = 0;
5298     INT     len;
5299
5300     TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_a(pName), Level, pPorts,
5301           cbBuf, pcbNeeded, pcReturned);
5302
5303     /* convert servername to unicode */
5304     if (pName) {
5305         len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
5306         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5307         MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
5308     }
5309     /* alloc (userbuffersize*sizeof(WCHAR) and try to enum the Ports */
5310     needed = cbBuf * sizeof(WCHAR);
5311     if (needed) bufferW = HeapAlloc(GetProcessHeap(), 0, needed);
5312     res = EnumPortsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
5313
5314     if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
5315         if (pcbNeeded) needed = *pcbNeeded;
5316         /* HeapReAlloc return NULL, when bufferW was NULL */
5317         bufferW = (bufferW) ? HeapReAlloc(GetProcessHeap(), 0, bufferW, needed) :
5318                               HeapAlloc(GetProcessHeap(), 0, needed);
5319
5320         /* Try again with the large Buffer */
5321         res = EnumPortsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
5322     }
5323     needed = pcbNeeded ? *pcbNeeded : 0;
5324     numentries = pcReturned ? *pcReturned : 0;
5325
5326     /*
5327        W2k require the buffersize from EnumPortsW also for EnumPortsA.
5328        We use the smaller Ansi-Size to avoid conflicts with fixed Buffers of old Apps.
5329      */
5330     if (res) {
5331         /* EnumPortsW collected all Data. Parse them to calculate ANSI-Size */
5332         DWORD   entrysize = 0;
5333         DWORD   index;
5334         LPSTR   ptr;
5335         LPPORT_INFO_2W pi2w;
5336         LPPORT_INFO_2A pi2a;
5337
5338         needed = 0;
5339         entrysize = (Level == 1) ? sizeof(PORT_INFO_1A) : sizeof(PORT_INFO_2A);
5340
5341         /* First pass: calculate the size for all Entries */
5342         pi2w = (LPPORT_INFO_2W) bufferW;
5343         pi2a = (LPPORT_INFO_2A) pPorts;
5344         index = 0;
5345         while (index < numentries) {
5346             index++;
5347             needed += entrysize;    /* PORT_INFO_?A */
5348             TRACE("%p: parsing #%d (%s)\n", pi2w, index, debugstr_w(pi2w->pPortName));
5349
5350             needed += WideCharToMultiByte(CP_ACP, 0, pi2w->pPortName, -1,
5351                                             NULL, 0, NULL, NULL);
5352             if (Level > 1) {
5353                 needed += WideCharToMultiByte(CP_ACP, 0, pi2w->pMonitorName, -1,
5354                                                 NULL, 0, NULL, NULL);
5355                 needed += WideCharToMultiByte(CP_ACP, 0, pi2w->pDescription, -1,
5356                                                 NULL, 0, NULL, NULL);
5357             }
5358             /* use LPBYTE with entrysize to avoid double code (PORT_INFO_1 + PORT_INFO_2) */
5359             pi2w = (LPPORT_INFO_2W) (((LPBYTE)pi2w) + entrysize);
5360             pi2a = (LPPORT_INFO_2A) (((LPBYTE)pi2a) + entrysize);
5361         }
5362
5363         /* check for errors and quit on failure */
5364         if (cbBuf < needed) {
5365             SetLastError(ERROR_INSUFFICIENT_BUFFER);
5366             res = FALSE;
5367             goto cleanup;
5368         }
5369         len = entrysize * numentries;       /* room for all PORT_INFO_?A */
5370         ptr = (LPSTR) &pPorts[len];         /* room for strings */
5371         cbBuf -= len ;                      /* free Bytes in the user-Buffer */
5372         pi2w = (LPPORT_INFO_2W) bufferW;
5373         pi2a = (LPPORT_INFO_2A) pPorts;
5374         index = 0;
5375         /* Second Pass: Fill the User Buffer (if we have one) */
5376         while ((index < numentries) && pPorts) {
5377             index++;
5378             TRACE("%p: writing PORT_INFO_%dA #%d\n", pi2a, Level, index);
5379             pi2a->pPortName = ptr;
5380             len = WideCharToMultiByte(CP_ACP, 0, pi2w->pPortName, -1,
5381                                             ptr, cbBuf , NULL, NULL);
5382             ptr += len;
5383             cbBuf -= len;
5384             if (Level > 1) {
5385                 pi2a->pMonitorName = ptr;
5386                 len = WideCharToMultiByte(CP_ACP, 0, pi2w->pMonitorName, -1,
5387                                             ptr, cbBuf, NULL, NULL);
5388                 ptr += len;
5389                 cbBuf -= len;
5390
5391                 pi2a->pDescription = ptr;
5392                 len = WideCharToMultiByte(CP_ACP, 0, pi2w->pDescription, -1,
5393                                             ptr, cbBuf, NULL, NULL);
5394                 ptr += len;
5395                 cbBuf -= len;
5396
5397                 pi2a->fPortType = pi2w->fPortType;
5398                 pi2a->Reserved = 0;              /* documented: "must be zero" */
5399
5400             }
5401             /* use LPBYTE with entrysize to avoid double code (PORT_INFO_1 + PORT_INFO_2) */
5402             pi2w = (LPPORT_INFO_2W) (((LPBYTE)pi2w) + entrysize);
5403             pi2a = (LPPORT_INFO_2A) (((LPBYTE)pi2a) + entrysize);
5404         }
5405     }
5406
5407 cleanup:
5408     if (pcbNeeded)  *pcbNeeded = needed;
5409     if (pcReturned) *pcReturned = (res) ? numentries : 0;
5410
5411     HeapFree(GetProcessHeap(), 0, nameW);
5412     HeapFree(GetProcessHeap(), 0, bufferW);
5413
5414     TRACE("returning %d with %d (%d byte for %d of %d entries)\n",
5415             (res), GetLastError(), needed, (res)? numentries : 0, numentries);
5416
5417     return (res);
5418
5419 }
5420
5421 /******************************************************************************
5422  *      EnumPortsW   (WINSPOOL.@)
5423  *
5424  * Enumerate available Ports
5425  *
5426  * PARAMS
5427  *  name        [I] Servername or NULL (local Computer)
5428  *  level       [I] Structure-Level (1 or 2)
5429  *  buffer      [O] PTR to Buffer that receives the Result
5430  *  bufsize     [I] Size of Buffer at buffer
5431  *  bufneeded   [O] PTR to DWORD that receives the size in Bytes used / required for buffer
5432  *  bufreturned [O] PTR to DWORD that receives the number of Ports in buffer
5433  *
5434  * RETURNS
5435  *  Success: TRUE
5436  *  Failure: FALSE and in bufneeded the Bytes required for buffer, if bufsize is too small
5437  *
5438  */
5439
5440 BOOL WINAPI EnumPortsW(LPWSTR pName, DWORD Level, LPBYTE pPorts, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
5441 {
5442     DWORD   needed = 0;
5443     DWORD   numentries = 0;
5444     BOOL    res = FALSE;
5445
5446     TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pPorts,
5447           cbBuf, pcbNeeded, pcReturned);
5448
5449     if (pName && (pName[0])) {
5450         FIXME("not implemented for Server %s\n", debugstr_w(pName));
5451         SetLastError(ERROR_ACCESS_DENIED);
5452         goto emP_cleanup;
5453     }
5454
5455     /* Level is not checked in win9x */
5456     if (!Level || (Level > 2)) {
5457         WARN("level (%d) is ignored in win9x\n", Level);
5458         SetLastError(ERROR_INVALID_LEVEL);
5459         goto emP_cleanup;
5460     }
5461     if (!pcbNeeded) {
5462         SetLastError(RPC_X_NULL_REF_POINTER);
5463         goto emP_cleanup;
5464     }
5465
5466     EnterCriticalSection(&monitor_handles_cs);
5467     monitor_loadall();
5468
5469     /* Scan all local Ports */
5470     numentries = 0;
5471     needed = get_ports_from_all_monitors(Level, NULL, 0, &numentries);
5472
5473     /* we calculated the needed buffersize. now do the error-checks */
5474     if (cbBuf < needed) {
5475         monitor_unloadall();
5476         SetLastError(ERROR_INSUFFICIENT_BUFFER);
5477         goto emP_cleanup_cs;
5478     }
5479     else if (!pPorts || !pcReturned) {
5480         monitor_unloadall();
5481         SetLastError(RPC_X_NULL_REF_POINTER);
5482         goto emP_cleanup_cs;
5483     }
5484
5485     /* Fill the Buffer */
5486     needed = get_ports_from_all_monitors(Level, pPorts, cbBuf, &numentries);
5487     res = TRUE;
5488     monitor_unloadall();
5489
5490 emP_cleanup_cs:
5491     LeaveCriticalSection(&monitor_handles_cs);
5492
5493 emP_cleanup:
5494     if (pcbNeeded)  *pcbNeeded = needed;
5495     if (pcReturned) *pcReturned = (res) ? numentries : 0;
5496
5497     TRACE("returning %d with %d (%d byte for %d of %d entries)\n",
5498             (res), GetLastError(), needed, (res)? numentries : 0, numentries);
5499
5500     return (res);
5501 }
5502
5503 /******************************************************************************
5504  *              GetDefaultPrinterW   (WINSPOOL.@)
5505  *
5506  * FIXME
5507  *      This function must read the value from data 'device' of key
5508  *      HCU\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows
5509  */
5510 BOOL WINAPI GetDefaultPrinterW(LPWSTR name, LPDWORD namesize)
5511 {
5512     BOOL  retval = TRUE;
5513     DWORD insize, len;
5514     WCHAR *buffer, *ptr;
5515
5516     if (!namesize)
5517     {
5518         SetLastError(ERROR_INVALID_PARAMETER);
5519         return FALSE;
5520     }
5521
5522     /* make the buffer big enough for the stuff from the profile/registry,
5523      * the content must fit into the local buffer to compute the correct
5524      * size even if the extern buffer is too small or not given.
5525      * (20 for ,driver,port) */
5526     insize = *namesize;
5527     len = max(100, (insize + 20));
5528     buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR));
5529
5530     if (!GetProfileStringW(windowsW, deviceW, emptyStringW, buffer, len))
5531     {
5532         SetLastError (ERROR_FILE_NOT_FOUND);
5533         retval = FALSE;
5534         goto end;
5535     }
5536     TRACE("%s\n", debugstr_w(buffer));
5537
5538     if ((ptr = strchrW(buffer, ',')) == NULL)
5539     {
5540         SetLastError(ERROR_INVALID_NAME);
5541         retval = FALSE;
5542         goto end;
5543     }
5544
5545     *ptr = 0;
5546     *namesize = strlenW(buffer) + 1;
5547     if(!name || (*namesize > insize))
5548     {
5549         SetLastError(ERROR_INSUFFICIENT_BUFFER);
5550         retval = FALSE;
5551         goto end;
5552     }
5553     strcpyW(name, buffer);
5554
5555 end:
5556     HeapFree( GetProcessHeap(), 0, buffer);
5557     return retval;
5558 }
5559
5560
5561 /******************************************************************************
5562  *              GetDefaultPrinterA   (WINSPOOL.@)
5563  */
5564 BOOL WINAPI GetDefaultPrinterA(LPSTR name, LPDWORD namesize)
5565 {
5566     BOOL  retval = TRUE;
5567     DWORD insize = 0;
5568     WCHAR *bufferW = NULL;
5569
5570     if (!namesize)
5571     {
5572         SetLastError(ERROR_INVALID_PARAMETER);
5573         return FALSE;
5574     }
5575
5576     if(name && *namesize) {
5577         insize = *namesize;
5578         bufferW = HeapAlloc( GetProcessHeap(), 0, insize * sizeof(WCHAR));
5579     }
5580
5581     if(!GetDefaultPrinterW( bufferW, namesize)) {
5582         retval = FALSE;
5583         goto end;
5584     }
5585
5586     *namesize = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, name, insize,
5587                                     NULL, NULL);
5588     if (!*namesize)
5589     {
5590         *namesize = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
5591         retval = FALSE;
5592     }
5593     TRACE("0x%08x/0x%08x:%s\n", *namesize, insize, debugstr_w(bufferW));
5594
5595 end:
5596     HeapFree( GetProcessHeap(), 0, bufferW);
5597     return retval;
5598 }
5599
5600
5601 /******************************************************************************
5602  *              SetDefaultPrinterW   (WINSPOOL.204)
5603  *
5604  * Set the Name of the Default Printer
5605  *
5606  * PARAMS
5607  *  pszPrinter [I] Name of the Printer or NULL
5608  *
5609  * RETURNS
5610  *  Success:    True
5611  *  Failure:    FALSE
5612  *
5613  * NOTES
5614  *  When the Parameter is NULL or points to an Empty String and
5615  *  a Default Printer was already present, then this Function changes nothing.
5616  *  Without a Default Printer and NULL (or an Empty String) as Parameter,
5617  *  the First enumerated local Printer is used.
5618  *
5619  */
5620 BOOL WINAPI SetDefaultPrinterW(LPCWSTR pszPrinter)
5621 {
5622
5623     TRACE("(%s)\n", debugstr_w(pszPrinter));
5624
5625     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5626     return FALSE;
5627 }
5628
5629 /******************************************************************************
5630  *              SetDefaultPrinterA   (WINSPOOL.202)
5631  *
5632  * See SetDefaultPrinterW.
5633  *
5634  */
5635 BOOL WINAPI SetDefaultPrinterA(LPCSTR pszPrinter)
5636 {
5637
5638     TRACE("(%s)\n", debugstr_a(pszPrinter));
5639
5640     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5641     return FALSE;
5642 }
5643
5644
5645 /******************************************************************************
5646  *              SetPrinterDataExA   (WINSPOOL.@)
5647  */
5648 DWORD WINAPI SetPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
5649                                LPCSTR pValueName, DWORD Type,
5650                                LPBYTE pData, DWORD cbData)
5651 {
5652     HKEY hkeyPrinter, hkeySubkey;
5653     DWORD ret;
5654
5655     TRACE("(%p, %s, %s %08x, %p, %08x)\n", hPrinter, debugstr_a(pKeyName),
5656           debugstr_a(pValueName), Type, pData, cbData);
5657
5658     if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5659        != ERROR_SUCCESS)
5660         return ret;
5661
5662     if((ret = RegCreateKeyA(hkeyPrinter, pKeyName, &hkeySubkey))
5663        != ERROR_SUCCESS) {
5664         ERR("Can't create subkey %s\n", debugstr_a(pKeyName));
5665         RegCloseKey(hkeyPrinter);
5666         return ret;
5667     }
5668     ret = RegSetValueExA(hkeySubkey, pValueName, 0, Type, pData, cbData);
5669     RegCloseKey(hkeySubkey);
5670     RegCloseKey(hkeyPrinter);
5671     return ret;
5672 }
5673
5674 /******************************************************************************
5675  *              SetPrinterDataExW   (WINSPOOL.@)
5676  */
5677 DWORD WINAPI SetPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
5678                                LPCWSTR pValueName, DWORD Type,
5679                                LPBYTE pData, DWORD cbData)
5680 {
5681     HKEY hkeyPrinter, hkeySubkey;
5682     DWORD ret;
5683
5684     TRACE("(%p, %s, %s %08x, %p, %08x)\n", hPrinter, debugstr_w(pKeyName),
5685           debugstr_w(pValueName), Type, pData, cbData);
5686
5687     if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5688        != ERROR_SUCCESS)
5689         return ret;
5690
5691     if((ret = RegCreateKeyW(hkeyPrinter, pKeyName, &hkeySubkey))
5692        != ERROR_SUCCESS) {
5693         ERR("Can't create subkey %s\n", debugstr_w(pKeyName));
5694         RegCloseKey(hkeyPrinter);
5695         return ret;
5696     }
5697     ret = RegSetValueExW(hkeySubkey, pValueName, 0, Type, pData, cbData);
5698     RegCloseKey(hkeySubkey);
5699     RegCloseKey(hkeyPrinter);
5700     return ret;
5701 }
5702
5703 /******************************************************************************
5704  *              SetPrinterDataA   (WINSPOOL.@)
5705  */
5706 DWORD WINAPI SetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, DWORD Type,
5707                                LPBYTE pData, DWORD cbData)
5708 {
5709     return SetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, Type,
5710                              pData, cbData);
5711 }
5712
5713 /******************************************************************************
5714  *              SetPrinterDataW   (WINSPOOL.@)
5715  */
5716 DWORD WINAPI SetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, DWORD Type,
5717                              LPBYTE pData, DWORD cbData)
5718 {
5719     return SetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, Type,
5720                              pData, cbData);
5721 }
5722
5723 /******************************************************************************
5724  *              GetPrinterDataExA   (WINSPOOL.@)
5725  */
5726 DWORD WINAPI GetPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
5727                                LPCSTR pValueName, LPDWORD pType,
5728                                LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5729 {
5730     HKEY hkeyPrinter, hkeySubkey;
5731     DWORD ret;
5732
5733     TRACE("(%p, %s, %s %p, %p, %08x, %p)\n", hPrinter,
5734           debugstr_a(pKeyName), debugstr_a(pValueName), pType, pData, nSize,
5735           pcbNeeded);
5736
5737     if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5738        != ERROR_SUCCESS)
5739         return ret;
5740
5741     if((ret = RegOpenKeyA(hkeyPrinter, pKeyName, &hkeySubkey))
5742        != ERROR_SUCCESS) {
5743         WARN("Can't open subkey %s\n", debugstr_a(pKeyName));
5744         RegCloseKey(hkeyPrinter);
5745         return ret;
5746     }
5747     *pcbNeeded = nSize;
5748     ret = RegQueryValueExA(hkeySubkey, pValueName, 0, pType, pData, pcbNeeded);
5749     RegCloseKey(hkeySubkey);
5750     RegCloseKey(hkeyPrinter);
5751     return ret;
5752 }
5753
5754 /******************************************************************************
5755  *              GetPrinterDataExW   (WINSPOOL.@)
5756  */
5757 DWORD WINAPI GetPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
5758                                LPCWSTR pValueName, LPDWORD pType,
5759                                LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5760 {
5761     HKEY hkeyPrinter, hkeySubkey;
5762     DWORD ret;
5763
5764     TRACE("(%p, %s, %s %p, %p, %08x, %p)\n", hPrinter,
5765           debugstr_w(pKeyName), debugstr_w(pValueName), pType, pData, nSize,
5766           pcbNeeded);
5767
5768     if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5769        != ERROR_SUCCESS)
5770         return ret;
5771
5772     if((ret = RegOpenKeyW(hkeyPrinter, pKeyName, &hkeySubkey))
5773        != ERROR_SUCCESS) {
5774         WARN("Can't open subkey %s\n", debugstr_w(pKeyName));
5775         RegCloseKey(hkeyPrinter);
5776         return ret;
5777     }
5778     *pcbNeeded = nSize;
5779     ret = RegQueryValueExW(hkeySubkey, pValueName, 0, pType, pData, pcbNeeded);
5780     RegCloseKey(hkeySubkey);
5781     RegCloseKey(hkeyPrinter);
5782     return ret;
5783 }
5784
5785 /******************************************************************************
5786  *              GetPrinterDataA   (WINSPOOL.@)
5787  */
5788 DWORD WINAPI GetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, LPDWORD pType,
5789                              LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5790 {
5791     return GetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, pType,
5792                              pData, nSize, pcbNeeded);
5793 }
5794
5795 /******************************************************************************
5796  *              GetPrinterDataW   (WINSPOOL.@)
5797  */
5798 DWORD WINAPI GetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, LPDWORD pType,
5799                              LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5800 {
5801     return GetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, pType,
5802                              pData, nSize, pcbNeeded);
5803 }
5804
5805 /*******************************************************************************
5806  *              EnumPrinterDataExW      [WINSPOOL.@]
5807  */
5808 DWORD WINAPI EnumPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
5809                                 LPBYTE pEnumValues, DWORD cbEnumValues,
5810                                 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
5811 {
5812     HKEY                    hkPrinter, hkSubKey;
5813     DWORD                   r, ret, dwIndex, cValues, cbMaxValueNameLen,
5814                             cbValueNameLen, cbMaxValueLen, cbValueLen,
5815                             cbBufSize, dwType;
5816     LPWSTR                  lpValueName;
5817     HANDLE                  hHeap;
5818     PBYTE                   lpValue;
5819     PPRINTER_ENUM_VALUESW   ppev;
5820
5821     TRACE ("%p %s\n", hPrinter, debugstr_w (pKeyName));
5822
5823     if (pKeyName == NULL || *pKeyName == 0)
5824         return ERROR_INVALID_PARAMETER;
5825
5826     ret = WINSPOOL_GetOpenedPrinterRegKey (hPrinter, &hkPrinter);
5827     if (ret != ERROR_SUCCESS)
5828     {
5829         TRACE ("WINSPOOL_GetOpenedPrinterRegKey (%p) returned %i\n",
5830                 hPrinter, ret);
5831         return ret;
5832     }
5833
5834     ret = RegOpenKeyExW (hkPrinter, pKeyName, 0, KEY_READ, &hkSubKey);
5835     if (ret != ERROR_SUCCESS)
5836     {
5837         r = RegCloseKey (hkPrinter);
5838         if (r != ERROR_SUCCESS)
5839             WARN ("RegCloseKey returned %i\n", r);
5840         TRACE ("RegOpenKeyExW (%p, %s) returned %i\n", hPrinter,
5841                 debugstr_w (pKeyName), ret);
5842         return ret;
5843     }
5844
5845     ret = RegCloseKey (hkPrinter);
5846     if (ret != ERROR_SUCCESS)
5847     {
5848         ERR ("RegCloseKey returned %i\n", ret);
5849         r = RegCloseKey (hkSubKey);
5850         if (r != ERROR_SUCCESS)
5851             WARN ("RegCloseKey returned %i\n", r);
5852         return ret;
5853     }
5854
5855     ret = RegQueryInfoKeyW (hkSubKey, NULL, NULL, NULL, NULL, NULL, NULL,
5856             &cValues, &cbMaxValueNameLen, &cbMaxValueLen, NULL, NULL);
5857     if (ret != ERROR_SUCCESS)
5858     {
5859         r = RegCloseKey (hkSubKey);
5860         if (r != ERROR_SUCCESS)
5861             WARN ("RegCloseKey returned %i\n", r);
5862         TRACE ("RegQueryInfoKeyW (%p) returned %i\n", hkSubKey, ret);
5863         return ret;
5864     }
5865
5866     TRACE ("RegQueryInfoKeyW returned cValues = %i, cbMaxValueNameLen = %i, "
5867             "cbMaxValueLen = %i\n", cValues, cbMaxValueNameLen, cbMaxValueLen);
5868
5869     if (cValues == 0)                   /* empty key */
5870     {
5871         r = RegCloseKey (hkSubKey);
5872         if (r != ERROR_SUCCESS)
5873             WARN ("RegCloseKey returned %i\n", r);
5874         *pcbEnumValues = *pnEnumValues = 0;
5875         return ERROR_SUCCESS;
5876     }
5877
5878     ++cbMaxValueNameLen;                        /* allow for trailing '\0' */
5879
5880     hHeap = GetProcessHeap ();
5881     if (hHeap == NULL)
5882     {
5883         ERR ("GetProcessHeap failed\n");
5884         r = RegCloseKey (hkSubKey);
5885         if (r != ERROR_SUCCESS)
5886             WARN ("RegCloseKey returned %i\n", r);
5887         return ERROR_OUTOFMEMORY;
5888     }
5889
5890     lpValueName = HeapAlloc (hHeap, 0, cbMaxValueNameLen * sizeof (WCHAR));
5891     if (lpValueName == NULL)
5892     {
5893         ERR ("Failed to allocate %i WCHARs from process heap\n", cbMaxValueNameLen);
5894         r = RegCloseKey (hkSubKey);
5895         if (r != ERROR_SUCCESS)
5896             WARN ("RegCloseKey returned %i\n", r);
5897         return ERROR_OUTOFMEMORY;
5898     }
5899
5900     lpValue = HeapAlloc (hHeap, 0, cbMaxValueLen);
5901     if (lpValue == NULL)
5902     {
5903         ERR ("Failed to allocate %i bytes from process heap\n", cbMaxValueLen);
5904         if (HeapFree (hHeap, 0, lpValueName) == 0)
5905             WARN ("HeapFree failed with code %i\n", GetLastError ());
5906         r = RegCloseKey (hkSubKey);
5907         if (r != ERROR_SUCCESS)
5908             WARN ("RegCloseKey returned %i\n", r);
5909         return ERROR_OUTOFMEMORY;
5910     }
5911
5912     TRACE ("pass 1: calculating buffer required for all names and values\n");
5913
5914     cbBufSize = cValues * sizeof (PRINTER_ENUM_VALUESW);
5915
5916     TRACE ("%i bytes required for %i headers\n", cbBufSize, cValues);
5917
5918     for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
5919     {
5920         cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
5921         ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
5922                 NULL, NULL, lpValue, &cbValueLen);
5923         if (ret != ERROR_SUCCESS)
5924         {
5925             if (HeapFree (hHeap, 0, lpValue) == 0)
5926                 WARN ("HeapFree failed with code %i\n", GetLastError ());
5927             if (HeapFree (hHeap, 0, lpValueName) == 0)
5928                 WARN ("HeapFree failed with code %i\n", GetLastError ());
5929             r = RegCloseKey (hkSubKey);
5930             if (r != ERROR_SUCCESS)
5931                 WARN ("RegCloseKey returned %i\n", r);
5932             TRACE ("RegEnumValueW (%i) returned %i\n", dwIndex, ret);
5933             return ret;
5934         }
5935
5936         TRACE ("%s [%i]: name needs %i WCHARs, data needs %i bytes\n",
5937                 debugstr_w (lpValueName), dwIndex,
5938                 cbValueNameLen + 1, cbValueLen);
5939
5940         cbBufSize += (cbValueNameLen + 1) * sizeof (WCHAR);
5941         cbBufSize += cbValueLen;
5942     }
5943
5944     TRACE ("%i bytes required for all %i values\n", cbBufSize, cValues);
5945
5946     *pcbEnumValues = cbBufSize;
5947     *pnEnumValues = cValues;
5948
5949     if (cbEnumValues < cbBufSize)       /* buffer too small */
5950     {
5951         if (HeapFree (hHeap, 0, lpValue) == 0)
5952             WARN ("HeapFree failed with code %i\n", GetLastError ());
5953         if (HeapFree (hHeap, 0, lpValueName) == 0)
5954             WARN ("HeapFree failed with code %i\n", GetLastError ());
5955         r = RegCloseKey (hkSubKey);
5956         if (r != ERROR_SUCCESS)
5957             WARN ("RegCloseKey returned %i\n", r);
5958         TRACE ("%i byte buffer is not large enough\n", cbEnumValues);
5959         return ERROR_MORE_DATA;
5960     }
5961
5962     TRACE ("pass 2: copying all names and values to buffer\n");
5963
5964     ppev = (PPRINTER_ENUM_VALUESW) pEnumValues;         /* array of structs */
5965     pEnumValues += cValues * sizeof (PRINTER_ENUM_VALUESW);
5966
5967     for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
5968     {
5969         cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
5970         ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
5971                 NULL, &dwType, lpValue, &cbValueLen);
5972         if (ret != ERROR_SUCCESS)
5973         {
5974             if (HeapFree (hHeap, 0, lpValue) == 0)
5975                 WARN ("HeapFree failed with code %i\n", GetLastError ());
5976             if (HeapFree (hHeap, 0, lpValueName) == 0)
5977                 WARN ("HeapFree failed with code %i\n", GetLastError ());
5978             r = RegCloseKey (hkSubKey);
5979             if (r != ERROR_SUCCESS)
5980                 WARN ("RegCloseKey returned %i\n", r);
5981             TRACE ("RegEnumValueW (%i) returned %i\n", dwIndex, ret);
5982             return ret;
5983         }
5984
5985         cbValueNameLen = (cbValueNameLen + 1) * sizeof (WCHAR);
5986         memcpy (pEnumValues, lpValueName, cbValueNameLen);
5987         ppev[dwIndex].pValueName = (LPWSTR) pEnumValues;
5988         pEnumValues += cbValueNameLen;
5989
5990         /* return # of *bytes* (including trailing \0), not # of chars */
5991         ppev[dwIndex].cbValueName = cbValueNameLen;
5992
5993         ppev[dwIndex].dwType = dwType;
5994
5995         memcpy (pEnumValues, lpValue, cbValueLen);
5996         ppev[dwIndex].pData = pEnumValues;
5997         pEnumValues += cbValueLen;
5998
5999         ppev[dwIndex].cbData = cbValueLen;
6000
6001         TRACE ("%s [%i]: copied name (%i bytes) and data (%i bytes)\n",
6002                 debugstr_w (lpValueName), dwIndex, cbValueNameLen, cbValueLen);
6003     }
6004
6005     if (HeapFree (hHeap, 0, lpValue) == 0)
6006     {
6007         ret = GetLastError ();
6008         ERR ("HeapFree failed with code %i\n", ret);
6009         if (HeapFree (hHeap, 0, lpValueName) == 0)
6010             WARN ("HeapFree failed with code %i\n", GetLastError ());
6011         r = RegCloseKey (hkSubKey);
6012         if (r != ERROR_SUCCESS)
6013             WARN ("RegCloseKey returned %i\n", r);
6014         return ret;
6015     }
6016
6017     if (HeapFree (hHeap, 0, lpValueName) == 0)
6018     {
6019         ret = GetLastError ();
6020         ERR ("HeapFree failed with code %i\n", ret);
6021         r = RegCloseKey (hkSubKey);
6022         if (r != ERROR_SUCCESS)
6023             WARN ("RegCloseKey returned %i\n", r);
6024         return ret;
6025     }
6026
6027     ret = RegCloseKey (hkSubKey);
6028     if (ret != ERROR_SUCCESS)
6029     {
6030         ERR ("RegCloseKey returned %i\n", ret);
6031         return ret;
6032     }
6033
6034     return ERROR_SUCCESS;
6035 }
6036
6037 /*******************************************************************************
6038  *              EnumPrinterDataExA      [WINSPOOL.@]
6039  *
6040  * This functions returns value names and REG_SZ, REG_EXPAND_SZ, and
6041  * REG_MULTI_SZ values as ASCII strings in Unicode-sized buffers.  This is
6042  * what Windows 2000 SP1 does.
6043  *
6044  */
6045 DWORD WINAPI EnumPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
6046                                 LPBYTE pEnumValues, DWORD cbEnumValues,
6047                                 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
6048 {
6049     INT     len;
6050     LPWSTR  pKeyNameW;
6051     DWORD   ret, dwIndex, dwBufSize;
6052     HANDLE  hHeap;
6053     LPSTR   pBuffer;
6054
6055     TRACE ("%p %s\n", hPrinter, pKeyName);
6056
6057     if (pKeyName == NULL || *pKeyName == 0)
6058         return ERROR_INVALID_PARAMETER;
6059
6060     len = MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, NULL, 0);
6061     if (len == 0)
6062     {
6063         ret = GetLastError ();
6064         ERR ("MultiByteToWideChar failed with code %i\n", ret);
6065         return ret;
6066     }
6067
6068     hHeap = GetProcessHeap ();
6069     if (hHeap == NULL)
6070     {
6071         ERR ("GetProcessHeap failed\n");
6072         return ERROR_OUTOFMEMORY;
6073     }
6074
6075     pKeyNameW = HeapAlloc (hHeap, 0, len * sizeof (WCHAR));
6076     if (pKeyNameW == NULL)
6077     {
6078         ERR ("Failed to allocate %i bytes from process heap\n",
6079              (LONG)(len * sizeof (WCHAR)));
6080         return ERROR_OUTOFMEMORY;
6081     }
6082
6083     if (MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, pKeyNameW, len) == 0)
6084     {
6085         ret = GetLastError ();
6086         ERR ("MultiByteToWideChar failed with code %i\n", ret);
6087         if (HeapFree (hHeap, 0, pKeyNameW) == 0)
6088             WARN ("HeapFree failed with code %i\n", GetLastError ());
6089         return ret;
6090     }
6091
6092     ret = EnumPrinterDataExW (hPrinter, pKeyNameW, pEnumValues, cbEnumValues,
6093             pcbEnumValues, pnEnumValues);
6094     if (ret != ERROR_SUCCESS)
6095     {
6096         if (HeapFree (hHeap, 0, pKeyNameW) == 0)
6097             WARN ("HeapFree failed with code %i\n", GetLastError ());
6098         TRACE ("EnumPrinterDataExW returned %i\n", ret);
6099         return ret;
6100     }
6101
6102     if (HeapFree (hHeap, 0, pKeyNameW) == 0)
6103     {
6104         ret = GetLastError ();
6105         ERR ("HeapFree failed with code %i\n", ret);
6106         return ret;
6107     }
6108
6109     if (*pnEnumValues == 0)     /* empty key */
6110         return ERROR_SUCCESS;
6111
6112     dwBufSize = 0;
6113     for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
6114     {
6115         PPRINTER_ENUM_VALUESW ppev =
6116                 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
6117
6118         if (dwBufSize < ppev->cbValueName)
6119             dwBufSize = ppev->cbValueName;
6120
6121         if (dwBufSize < ppev->cbData && (ppev->dwType == REG_SZ ||
6122                 ppev->dwType == REG_EXPAND_SZ || ppev->dwType == REG_MULTI_SZ))
6123             dwBufSize = ppev->cbData;
6124     }
6125
6126     TRACE ("Largest Unicode name or value is %i bytes\n", dwBufSize);
6127
6128     pBuffer = HeapAlloc (hHeap, 0, dwBufSize);
6129     if (pBuffer == NULL)
6130     {
6131         ERR ("Failed to allocate %i bytes from process heap\n", dwBufSize);
6132         return ERROR_OUTOFMEMORY;
6133     }
6134
6135     for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
6136     {
6137         PPRINTER_ENUM_VALUESW ppev =
6138                 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
6139
6140         len = WideCharToMultiByte (CP_ACP, 0, ppev->pValueName,
6141                 ppev->cbValueName / sizeof (WCHAR), pBuffer, dwBufSize, NULL,
6142                 NULL);
6143         if (len == 0)
6144         {
6145             ret = GetLastError ();
6146             ERR ("WideCharToMultiByte failed with code %i\n", ret);
6147             if (HeapFree (hHeap, 0, pBuffer) == 0)
6148                 WARN ("HeapFree failed with code %i\n", GetLastError ());
6149             return ret;
6150         }
6151
6152         memcpy (ppev->pValueName, pBuffer, len);
6153
6154         TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
6155
6156         if (ppev->dwType != REG_SZ && ppev->dwType != REG_EXPAND_SZ &&
6157                 ppev->dwType != REG_MULTI_SZ)
6158             continue;
6159
6160         len = WideCharToMultiByte (CP_ACP, 0, (LPWSTR) ppev->pData,
6161                 ppev->cbData / sizeof (WCHAR), pBuffer, dwBufSize, NULL, NULL);
6162         if (len == 0)
6163         {
6164             ret = GetLastError ();
6165             ERR ("WideCharToMultiByte failed with code %i\n", ret);
6166             if (HeapFree (hHeap, 0, pBuffer) == 0)
6167                 WARN ("HeapFree failed with code %i\n", GetLastError ());
6168             return ret;
6169         }
6170
6171         memcpy (ppev->pData, pBuffer, len);
6172
6173         TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
6174         TRACE ("  (only first string of REG_MULTI_SZ printed)\n");
6175     }
6176
6177     if (HeapFree (hHeap, 0, pBuffer) == 0)
6178     {
6179         ret = GetLastError ();
6180         ERR ("HeapFree failed with code %i\n", ret);
6181         return ret;
6182     }
6183
6184     return ERROR_SUCCESS;
6185 }
6186
6187 /******************************************************************************
6188  *      AbortPrinter (WINSPOOL.@)
6189  */
6190 BOOL WINAPI AbortPrinter( HANDLE hPrinter )
6191 {
6192     FIXME("(%p), stub!\n", hPrinter);
6193     return TRUE;
6194 }
6195
6196 /******************************************************************************
6197  *              AddPortA (WINSPOOL.@)
6198  *
6199  * See AddPortW.
6200  *
6201  */
6202 BOOL WINAPI AddPortA(LPSTR pName, HWND hWnd, LPSTR pMonitorName)
6203 {
6204     LPWSTR  nameW = NULL;
6205     LPWSTR  monitorW = NULL;
6206     DWORD   len;
6207     BOOL    res;
6208
6209     TRACE("(%s, %p, %s)\n",debugstr_a(pName), hWnd, debugstr_a(pMonitorName));
6210
6211     if (pName) {
6212         len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6213         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6214         MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6215     }
6216
6217     if (pMonitorName) {
6218         len = MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, NULL, 0);
6219         monitorW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6220         MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, monitorW, len);
6221     }
6222     res = AddPortW(nameW, hWnd, monitorW);
6223     HeapFree(GetProcessHeap(), 0, nameW);
6224     HeapFree(GetProcessHeap(), 0, monitorW);
6225     return res;
6226 }
6227
6228 /******************************************************************************
6229  *      AddPortW (WINSPOOL.@)
6230  *
6231  * Add a Port for a specific Monitor
6232  *
6233  * PARAMS
6234  *  pName        [I] Servername or NULL (local Computer)
6235  *  hWnd         [I] Handle to parent Window for the Dialog-Box
6236  *  pMonitorName [I] Name of the Monitor that manage the Port
6237  *
6238  * RETURNS
6239  *  Success: TRUE
6240  *  Failure: FALSE
6241  *
6242  */
6243 BOOL WINAPI AddPortW(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)
6244 {
6245     monitor_t * pm;
6246     monitor_t * pui;
6247     DWORD       res;
6248
6249     TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pMonitorName));
6250
6251     if (pName && pName[0]) {
6252         SetLastError(ERROR_INVALID_PARAMETER);
6253         return FALSE;
6254     }
6255
6256     if (!pMonitorName) {
6257         SetLastError(RPC_X_NULL_REF_POINTER);
6258         return FALSE;
6259     }
6260
6261     /* an empty Monitorname is Invalid */
6262     if (!pMonitorName[0]) {
6263         SetLastError(ERROR_NOT_SUPPORTED);
6264         return FALSE;
6265     }
6266
6267     pm = monitor_load(pMonitorName, NULL);
6268     if (pm && pm->monitor && pm->monitor->pfnAddPort) {
6269         res = pm->monitor->pfnAddPort(pName, hWnd, pMonitorName);
6270         TRACE("got %d with %u\n", res, GetLastError());
6271         res = TRUE;
6272     }
6273     else
6274     {
6275         pui = monitor_loadui(pm);
6276         if (pui && pui->monitorUI && pui->monitorUI->pfnAddPortUI) {
6277             TRACE("use %p: %s\n", pui, debugstr_w(pui->dllname));
6278             res = pui->monitorUI->pfnAddPortUI(pName, hWnd, pMonitorName, NULL);
6279             TRACE("got %d with %u\n", res, GetLastError());
6280             res = TRUE;
6281         }
6282         else
6283         {
6284             FIXME("not implemented for %s (%p: %s => %p: %s)\n", debugstr_w(pMonitorName),
6285                 pm, pm ? debugstr_w(pm->dllname) : NULL, pui, pui ? debugstr_w(pui->dllname) : NULL);
6286
6287             /* XP: ERROR_NOT_SUPPORTED, NT351,9x: ERROR_INVALID_PARAMETER */
6288             SetLastError(ERROR_NOT_SUPPORTED);
6289             res = FALSE;
6290         }
6291         monitor_unload(pui);
6292     }
6293     monitor_unload(pm);
6294     TRACE("returning %d with %u\n", res, GetLastError());
6295     return res;
6296 }
6297
6298 /******************************************************************************
6299  *             AddPortExA (WINSPOOL.@)
6300  *
6301  * See AddPortExW.
6302  *
6303  */
6304 BOOL WINAPI AddPortExA(LPSTR pName, DWORD level, LPBYTE pBuffer, LPSTR pMonitorName)
6305 {
6306     PORT_INFO_2W   pi2W;
6307     PORT_INFO_2A * pi2A;
6308     LPWSTR  nameW = NULL;
6309     LPWSTR  monitorW = NULL;
6310     DWORD   len;
6311     BOOL    res;
6312
6313     pi2A = (PORT_INFO_2A *) pBuffer;
6314
6315     TRACE("(%s, %d, %p, %s): %s\n", debugstr_a(pName), level, pBuffer,
6316             debugstr_a(pMonitorName), debugstr_a(pi2A ? pi2A->pPortName : NULL));
6317
6318     if ((level < 1) || (level > 2)) {
6319         SetLastError(ERROR_INVALID_LEVEL);
6320         return FALSE;
6321     }
6322
6323     if (!pi2A) {
6324         SetLastError(ERROR_INVALID_PARAMETER);
6325         return FALSE;
6326     }
6327
6328     if (pName) {
6329         len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6330         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6331         MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6332     }
6333
6334     if (pMonitorName) {
6335         len = MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, NULL, 0);
6336         monitorW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6337         MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, monitorW, len);
6338     }
6339
6340     ZeroMemory(&pi2W, sizeof(PORT_INFO_2W));
6341
6342     if (pi2A->pPortName) {
6343         len = MultiByteToWideChar(CP_ACP, 0, pi2A->pPortName, -1, NULL, 0);
6344         pi2W.pPortName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6345         MultiByteToWideChar(CP_ACP, 0, pi2A->pPortName, -1, pi2W.pPortName, len);
6346     }
6347
6348     if (level > 1) {
6349         if (pi2A->pMonitorName) {
6350             len = MultiByteToWideChar(CP_ACP, 0, pi2A->pMonitorName, -1, NULL, 0);
6351             pi2W.pMonitorName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6352             MultiByteToWideChar(CP_ACP, 0, pi2A->pMonitorName, -1, pi2W.pMonitorName, len);
6353         }
6354
6355         if (pi2A->pDescription) {
6356             len = MultiByteToWideChar(CP_ACP, 0, pi2A->pDescription, -1, NULL, 0);
6357             pi2W.pDescription = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6358             MultiByteToWideChar(CP_ACP, 0, pi2A->pDescription, -1, pi2W.pDescription, len);
6359         }
6360         pi2W.fPortType = pi2A->fPortType;
6361         pi2W.Reserved = pi2A->Reserved;
6362     }
6363
6364     res = AddPortExW(nameW, level, (LPBYTE) &pi2W, monitorW);
6365
6366     HeapFree(GetProcessHeap(), 0, nameW);
6367     HeapFree(GetProcessHeap(), 0, monitorW);
6368     HeapFree(GetProcessHeap(), 0, pi2W.pPortName);
6369     HeapFree(GetProcessHeap(), 0, pi2W.pMonitorName);
6370     HeapFree(GetProcessHeap(), 0, pi2W.pDescription);
6371     return res;
6372
6373 }
6374
6375 /******************************************************************************
6376  *             AddPortExW (WINSPOOL.@)
6377  *
6378  * Add a Port for a specific Monitor, without presenting a user interface
6379  *
6380  * PARAMS
6381  *  pName         [I] Servername or NULL (local Computer)
6382  *  level         [I] Structure-Level (1 or 2) for pBuffer
6383  *  pBuffer       [I] PTR to: PORT_INFO_1 or PORT_INFO_2
6384  *  pMonitorName  [I] Name of the Monitor that manage the Port
6385  *
6386  * RETURNS
6387  *  Success: TRUE
6388  *  Failure: FALSE
6389  *
6390  */
6391 BOOL WINAPI AddPortExW(LPWSTR pName, DWORD level, LPBYTE pBuffer, LPWSTR pMonitorName)
6392 {
6393     PORT_INFO_2W * pi2;
6394     monitor_t * pm;
6395     DWORD       res = FALSE;
6396
6397     pi2 = (PORT_INFO_2W *) pBuffer;
6398
6399     TRACE("(%s, %d, %p, %s): %s %s %s\n", debugstr_w(pName), level, pBuffer,
6400             debugstr_w(pMonitorName), debugstr_w(pi2 ? pi2->pPortName : NULL),
6401             debugstr_w(((level > 1) && pi2) ? pi2->pMonitorName : NULL),
6402             debugstr_w(((level > 1) && pi2) ? pi2->pDescription : NULL));
6403
6404
6405     if ((level < 1) || (level > 2)) {
6406         SetLastError(ERROR_INVALID_LEVEL);
6407         return FALSE;
6408     }
6409
6410     if ((!pi2) || (!pMonitorName) || (!pMonitorName[0])) {
6411         SetLastError(ERROR_INVALID_PARAMETER);
6412         return FALSE;
6413     }
6414
6415     /* load the Monitor */
6416     pm = monitor_load(pMonitorName, NULL);
6417     if (!pm) {
6418         SetLastError(ERROR_INVALID_PARAMETER);
6419         return FALSE;
6420     }
6421
6422     if (pm->monitor && pm->monitor->pfnAddPortEx) {
6423         res = pm->monitor->pfnAddPortEx(pName, level, pBuffer, pMonitorName);
6424         TRACE("got %u with %u\n", res, GetLastError());
6425     }
6426     else
6427     {
6428         FIXME("not implemented for %s (%p)\n", debugstr_w(pMonitorName), pm->monitor);
6429     }
6430     monitor_unload(pm);
6431     return res;
6432 }
6433
6434 /******************************************************************************
6435  *      AddPrinterConnectionA (WINSPOOL.@)
6436  */
6437 BOOL WINAPI AddPrinterConnectionA( LPSTR pName )
6438 {
6439     FIXME("%s\n", debugstr_a(pName));
6440     return FALSE;
6441 }
6442
6443 /******************************************************************************
6444  *      AddPrinterConnectionW (WINSPOOL.@)
6445  */
6446 BOOL WINAPI AddPrinterConnectionW( LPWSTR pName )
6447 {
6448     FIXME("%s\n", debugstr_w(pName));
6449     return FALSE;
6450 }
6451
6452 /******************************************************************************
6453  *  AddPrinterDriverExW (WINSPOOL.@)
6454  *
6455  * Install a Printer Driver with the Option to upgrade / downgrade the Files
6456  *
6457  * PARAMS
6458  *  pName           [I] Servername or NULL (local Computer)
6459  *  level           [I] Level for the supplied DRIVER_INFO_*W struct
6460  *  pDriverInfo     [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
6461  *  dwFileCopyFlags [I] How to Copy / Upgrade / Downgrade the needed Files
6462  *
6463  * RESULTS
6464  *  Success: TRUE
6465  *  Failure: FALSE
6466  *
6467  */
6468 BOOL WINAPI AddPrinterDriverExW( LPWSTR pName, DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
6469 {
6470     TRACE("(%s, %d, %p, 0x%x)\n", debugstr_w(pName), level, pDriverInfo, dwFileCopyFlags);
6471
6472     if ((backend == NULL)  && !load_backend()) return FALSE;
6473
6474     if (level < 2 || level == 5 || level == 7 || level > 8) {
6475         SetLastError(ERROR_INVALID_LEVEL);
6476         return FALSE;
6477     }
6478
6479     if (!pDriverInfo) {
6480         SetLastError(ERROR_INVALID_PARAMETER);
6481         return FALSE;
6482     }
6483
6484     return backend->fpAddPrinterDriverEx(pName, level, pDriverInfo, dwFileCopyFlags);
6485 }
6486
6487 /******************************************************************************
6488  *  AddPrinterDriverExA (WINSPOOL.@)
6489  *
6490  * See AddPrinterDriverExW.
6491  *
6492  */
6493 BOOL WINAPI AddPrinterDriverExA(LPSTR pName, DWORD Level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
6494 {
6495     DRIVER_INFO_8A  *diA;
6496     DRIVER_INFO_8W   diW;
6497     LPWSTR  nameW = NULL;
6498     DWORD   lenA;
6499     DWORD   len;
6500     DWORD   res = FALSE;
6501
6502     TRACE("(%s, %d, %p, 0x%x)\n", debugstr_a(pName), Level, pDriverInfo, dwFileCopyFlags);
6503
6504     diA = (DRIVER_INFO_8A  *) pDriverInfo;
6505     ZeroMemory(&diW, sizeof(diW));
6506
6507     if (Level < 2 || Level == 5 || Level == 7 || Level > 8) {
6508         SetLastError(ERROR_INVALID_LEVEL);
6509         return FALSE;
6510     }
6511
6512     if (diA == NULL) {
6513         SetLastError(ERROR_INVALID_PARAMETER);
6514         return FALSE;
6515     }
6516
6517     /* convert servername to unicode */
6518     if (pName) {
6519         len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6520         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6521         MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6522     }
6523
6524     /* common fields */
6525     diW.cVersion = diA->cVersion;
6526
6527     if (diA->pName) {
6528         len = MultiByteToWideChar(CP_ACP, 0, diA->pName, -1, NULL, 0);
6529         diW.pName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6530         MultiByteToWideChar(CP_ACP, 0, diA->pName, -1, diW.pName, len);
6531     }
6532
6533     if (diA->pEnvironment) {
6534         len = MultiByteToWideChar(CP_ACP, 0, diA->pEnvironment, -1, NULL, 0);
6535         diW.pEnvironment = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6536         MultiByteToWideChar(CP_ACP, 0, diA->pEnvironment, -1, diW.pEnvironment, len);
6537     }
6538
6539     if (diA->pDriverPath) {
6540         len = MultiByteToWideChar(CP_ACP, 0, diA->pDriverPath, -1, NULL, 0);
6541         diW.pDriverPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6542         MultiByteToWideChar(CP_ACP, 0, diA->pDriverPath, -1, diW.pDriverPath, len);
6543     }
6544
6545     if (diA->pDataFile) {
6546         len = MultiByteToWideChar(CP_ACP, 0, diA->pDataFile, -1, NULL, 0);
6547         diW.pDataFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6548         MultiByteToWideChar(CP_ACP, 0, diA->pDataFile, -1, diW.pDataFile, len);
6549     }
6550
6551     if (diA->pConfigFile) {
6552         len = MultiByteToWideChar(CP_ACP, 0, diA->pConfigFile, -1, NULL, 0);
6553         diW.pConfigFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6554         MultiByteToWideChar(CP_ACP, 0, diA->pConfigFile, -1, diW.pConfigFile, len);
6555     }
6556
6557     if ((Level > 2) && diA->pDependentFiles) {
6558         lenA = multi_sz_lenA(diA->pDependentFiles);
6559         len = MultiByteToWideChar(CP_ACP, 0, diA->pDependentFiles, lenA, NULL, 0);
6560         diW.pDependentFiles = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6561         MultiByteToWideChar(CP_ACP, 0, diA->pDependentFiles, lenA, diW.pDependentFiles, len);
6562     }
6563
6564     if ((Level > 2) && diA->pMonitorName) {
6565         len = MultiByteToWideChar(CP_ACP, 0, diA->pMonitorName, -1, NULL, 0);
6566         diW.pMonitorName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6567         MultiByteToWideChar(CP_ACP, 0, diA->pMonitorName, -1, diW.pMonitorName, len);
6568     }
6569
6570     if ((Level > 3) && diA->pDefaultDataType) {
6571         len = MultiByteToWideChar(CP_ACP, 0, diA->pDefaultDataType, -1, NULL, 0);
6572         diW.pDefaultDataType = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6573         MultiByteToWideChar(CP_ACP, 0, diA->pDefaultDataType, -1, diW.pDefaultDataType, len);
6574     }
6575
6576     if ((Level > 3) && diA->pszzPreviousNames) {
6577         lenA = multi_sz_lenA(diA->pszzPreviousNames);
6578         len = MultiByteToWideChar(CP_ACP, 0, diA->pszzPreviousNames, lenA, NULL, 0);
6579         diW.pszzPreviousNames = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6580         MultiByteToWideChar(CP_ACP, 0, diA->pszzPreviousNames, lenA, diW.pszzPreviousNames, len);
6581     }
6582
6583     if ((Level > 5) && diA->pszMfgName) {
6584         len = MultiByteToWideChar(CP_ACP, 0, diA->pszMfgName, -1, NULL, 0);
6585         diW.pszMfgName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6586         MultiByteToWideChar(CP_ACP, 0, diA->pszMfgName, -1, diW.pszMfgName, len);
6587     }
6588
6589     if ((Level > 5) && diA->pszOEMUrl) {
6590         len = MultiByteToWideChar(CP_ACP, 0, diA->pszOEMUrl, -1, NULL, 0);
6591         diW.pszOEMUrl = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6592         MultiByteToWideChar(CP_ACP, 0, diA->pszOEMUrl, -1, diW.pszOEMUrl, len);
6593     }
6594
6595     if ((Level > 5) && diA->pszHardwareID) {
6596         len = MultiByteToWideChar(CP_ACP, 0, diA->pszHardwareID, -1, NULL, 0);
6597         diW.pszHardwareID = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6598         MultiByteToWideChar(CP_ACP, 0, diA->pszHardwareID, -1, diW.pszHardwareID, len);
6599     }
6600
6601     if ((Level > 5) && diA->pszProvider) {
6602         len = MultiByteToWideChar(CP_ACP, 0, diA->pszProvider, -1, NULL, 0);
6603         diW.pszProvider = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6604         MultiByteToWideChar(CP_ACP, 0, diA->pszProvider, -1, diW.pszProvider, len);
6605     }
6606
6607     if (Level > 7) {
6608         FIXME("level %u is incomplete\n", Level);
6609     }
6610
6611     res = AddPrinterDriverExW(nameW, Level, (LPBYTE) &diW, dwFileCopyFlags);
6612     TRACE("got %u with %u\n", res, GetLastError());
6613     HeapFree(GetProcessHeap(), 0, nameW);
6614     HeapFree(GetProcessHeap(), 0, diW.pName);
6615     HeapFree(GetProcessHeap(), 0, diW.pEnvironment);
6616     HeapFree(GetProcessHeap(), 0, diW.pDriverPath);
6617     HeapFree(GetProcessHeap(), 0, diW.pDataFile);
6618     HeapFree(GetProcessHeap(), 0, diW.pConfigFile);
6619     HeapFree(GetProcessHeap(), 0, diW.pDependentFiles);
6620     HeapFree(GetProcessHeap(), 0, diW.pMonitorName);
6621     HeapFree(GetProcessHeap(), 0, diW.pDefaultDataType);
6622     HeapFree(GetProcessHeap(), 0, diW.pszzPreviousNames);
6623     HeapFree(GetProcessHeap(), 0, diW.pszMfgName);
6624     HeapFree(GetProcessHeap(), 0, diW.pszOEMUrl);
6625     HeapFree(GetProcessHeap(), 0, diW.pszHardwareID);
6626     HeapFree(GetProcessHeap(), 0, diW.pszProvider);
6627
6628     TRACE("=> %u with %u\n", res, GetLastError());
6629     return res;
6630 }
6631
6632 /******************************************************************************
6633  *      ConfigurePortA (WINSPOOL.@)
6634  *
6635  * See ConfigurePortW.
6636  *
6637  */
6638 BOOL WINAPI ConfigurePortA(LPSTR pName, HWND hWnd, LPSTR pPortName)
6639 {
6640     LPWSTR  nameW = NULL;
6641     LPWSTR  portW = NULL;
6642     INT     len;
6643     DWORD   res;
6644
6645     TRACE("(%s, %p, %s)\n", debugstr_a(pName), hWnd, debugstr_a(pPortName));
6646
6647     /* convert servername to unicode */
6648     if (pName) {
6649         len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6650         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6651         MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6652     }
6653
6654     /* convert portname to unicode */
6655     if (pPortName) {
6656         len = MultiByteToWideChar(CP_ACP, 0, pPortName, -1, NULL, 0);
6657         portW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6658         MultiByteToWideChar(CP_ACP, 0, pPortName, -1, portW, len);
6659     }
6660
6661     res = ConfigurePortW(nameW, hWnd, portW);
6662     HeapFree(GetProcessHeap(), 0, nameW);
6663     HeapFree(GetProcessHeap(), 0, portW);
6664     return res;
6665 }
6666
6667 /******************************************************************************
6668  *      ConfigurePortW (WINSPOOL.@)
6669  *
6670  * Display the Configuration-Dialog for a specific Port
6671  *
6672  * PARAMS
6673  *  pName     [I] Servername or NULL (local Computer)
6674  *  hWnd      [I] Handle to parent Window for the Dialog-Box
6675  *  pPortName [I] Name of the Port, that should be configured
6676  *
6677  * RETURNS
6678  *  Success: TRUE
6679  *  Failure: FALSE
6680  *
6681  */
6682 BOOL WINAPI ConfigurePortW(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
6683 {
6684     monitor_t * pm;
6685     monitor_t * pui;
6686     DWORD       res;
6687
6688     TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
6689
6690     if (pName && pName[0]) {
6691         SetLastError(ERROR_INVALID_PARAMETER);
6692         return FALSE;
6693     }
6694
6695     if (!pPortName) {
6696         SetLastError(RPC_X_NULL_REF_POINTER);
6697         return FALSE;
6698     }
6699
6700     /* an empty Portname is Invalid, but can popup a Dialog */
6701     if (!pPortName[0]) {
6702         SetLastError(ERROR_NOT_SUPPORTED);
6703         return FALSE;
6704     }
6705
6706     pm = monitor_load_by_port(pPortName);
6707     if (pm && pm->monitor && pm->monitor->pfnConfigurePort) {
6708         TRACE("Using %s for %s (%p: %s)\n", debugstr_w(pm->name), debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
6709         res = pm->monitor->pfnConfigurePort(pName, hWnd, pPortName);
6710         TRACE("got %d with %u\n", res, GetLastError());
6711     }
6712     else
6713     {
6714         pui = monitor_loadui(pm);
6715         if (pui && pui->monitorUI && pui->monitorUI->pfnConfigurePortUI) {
6716             TRACE("Use %s for %s (%p: %s)\n", debugstr_w(pui->name), debugstr_w(pPortName), pui, debugstr_w(pui->dllname));
6717             res = pui->monitorUI->pfnConfigurePortUI(pName, hWnd, pPortName);
6718             TRACE("got %d with %u\n", res, GetLastError());
6719         }
6720         else
6721         {
6722             FIXME("not implemented for %s (%p: %s => %p: %s)\n", debugstr_w(pPortName),
6723                 pm, pm ? debugstr_w(pm->dllname) : NULL, pui, pui ? debugstr_w(pui->dllname) : NULL);
6724
6725             /* XP: ERROR_NOT_SUPPORTED, NT351,9x: ERROR_INVALID_PARAMETER */
6726             SetLastError(ERROR_NOT_SUPPORTED);
6727             res = FALSE;
6728         }
6729         monitor_unload(pui);
6730     }
6731     monitor_unload(pm);
6732
6733     TRACE("returning %d with %u\n", res, GetLastError());
6734     return res;
6735 }
6736
6737 /******************************************************************************
6738  *      ConnectToPrinterDlg (WINSPOOL.@)
6739  */
6740 HANDLE WINAPI ConnectToPrinterDlg( HWND hWnd, DWORD Flags )
6741 {
6742     FIXME("%p %x\n", hWnd, Flags);
6743     return NULL;
6744 }
6745
6746 /******************************************************************************
6747  *      DeletePrinterConnectionA (WINSPOOL.@)
6748  */
6749 BOOL WINAPI DeletePrinterConnectionA( LPSTR pName )
6750 {
6751     FIXME("%s\n", debugstr_a(pName));
6752     return TRUE;
6753 }
6754
6755 /******************************************************************************
6756  *      DeletePrinterConnectionW (WINSPOOL.@)
6757  */
6758 BOOL WINAPI DeletePrinterConnectionW( LPWSTR pName )
6759 {
6760     FIXME("%s\n", debugstr_w(pName));
6761     return TRUE;
6762 }
6763
6764 /******************************************************************************
6765  *              DeletePrinterDriverExW (WINSPOOL.@)
6766  */
6767 BOOL WINAPI DeletePrinterDriverExW( LPWSTR pName, LPWSTR pEnvironment,
6768     LPWSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
6769 {
6770     HKEY hkey_drivers;
6771     BOOL ret = FALSE;
6772
6773     TRACE("%s %s %s %x %x\n", debugstr_w(pName), debugstr_w(pEnvironment),
6774           debugstr_w(pDriverName), dwDeleteFlag, dwVersionFlag);
6775
6776     if(pName && pName[0])
6777     {
6778         FIXME("pName = %s - unsupported\n", debugstr_w(pName));
6779         SetLastError(ERROR_INVALID_PARAMETER);
6780         return FALSE;
6781     }
6782
6783     if(dwDeleteFlag)
6784     {
6785         FIXME("dwDeleteFlag = %x - unsupported\n", dwDeleteFlag);
6786         SetLastError(ERROR_INVALID_PARAMETER);
6787         return FALSE;
6788     }
6789
6790     hkey_drivers = WINSPOOL_OpenDriverReg(pEnvironment, TRUE);
6791
6792     if(!hkey_drivers)
6793     {
6794         ERR("Can't open drivers key\n");
6795         return FALSE;
6796     }
6797
6798     if(RegDeleteTreeW(hkey_drivers, pDriverName) == ERROR_SUCCESS)
6799         ret = TRUE;
6800
6801     RegCloseKey(hkey_drivers);
6802
6803     return ret;
6804 }
6805
6806 /******************************************************************************
6807  *              DeletePrinterDriverExA (WINSPOOL.@)
6808  */
6809 BOOL WINAPI DeletePrinterDriverExA( LPSTR pName, LPSTR pEnvironment,
6810     LPSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
6811 {
6812     UNICODE_STRING NameW, EnvW, DriverW;
6813     BOOL ret;
6814
6815     asciitounicode(&NameW, pName);
6816     asciitounicode(&EnvW, pEnvironment);
6817     asciitounicode(&DriverW, pDriverName);
6818
6819     ret = DeletePrinterDriverExW(NameW.Buffer, EnvW.Buffer, DriverW.Buffer, dwDeleteFlag, dwVersionFlag);
6820
6821     RtlFreeUnicodeString(&DriverW);
6822     RtlFreeUnicodeString(&EnvW);
6823     RtlFreeUnicodeString(&NameW);
6824
6825     return ret;
6826 }
6827
6828 /******************************************************************************
6829  *              DeletePrinterDataExW (WINSPOOL.@)
6830  */
6831 DWORD WINAPI DeletePrinterDataExW( HANDLE hPrinter, LPCWSTR pKeyName,
6832                                   LPCWSTR pValueName)
6833 {
6834     FIXME("%p %s %s\n", hPrinter,
6835           debugstr_w(pKeyName), debugstr_w(pValueName));
6836     return ERROR_INVALID_PARAMETER;
6837 }
6838
6839 /******************************************************************************
6840  *              DeletePrinterDataExA (WINSPOOL.@)
6841  */
6842 DWORD WINAPI DeletePrinterDataExA( HANDLE hPrinter, LPCSTR pKeyName,
6843                                   LPCSTR pValueName)
6844 {
6845     FIXME("%p %s %s\n", hPrinter,
6846           debugstr_a(pKeyName), debugstr_a(pValueName));
6847     return ERROR_INVALID_PARAMETER;
6848 }
6849
6850 /******************************************************************************
6851  *      DeletePrintProcessorA (WINSPOOL.@)
6852  */
6853 BOOL WINAPI DeletePrintProcessorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPrintProcessorName)
6854 {
6855     FIXME("%s %s %s\n", debugstr_a(pName), debugstr_a(pEnvironment),
6856           debugstr_a(pPrintProcessorName));
6857     return TRUE;
6858 }
6859
6860 /******************************************************************************
6861  *      DeletePrintProcessorW (WINSPOOL.@)
6862  */
6863 BOOL WINAPI DeletePrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProcessorName)
6864 {
6865     FIXME("%s %s %s\n", debugstr_w(pName), debugstr_w(pEnvironment),
6866           debugstr_w(pPrintProcessorName));
6867     return TRUE;
6868 }
6869
6870 /******************************************************************************
6871  *      DeletePrintProvidorA (WINSPOOL.@)
6872  */
6873 BOOL WINAPI DeletePrintProvidorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPrintProviderName)
6874 {
6875     FIXME("%s %s %s\n", debugstr_a(pName), debugstr_a(pEnvironment),
6876           debugstr_a(pPrintProviderName));
6877     return TRUE;
6878 }
6879
6880 /******************************************************************************
6881  *      DeletePrintProvidorW (WINSPOOL.@)
6882  */
6883 BOOL WINAPI DeletePrintProvidorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProviderName)
6884 {
6885     FIXME("%s %s %s\n", debugstr_w(pName), debugstr_w(pEnvironment),
6886           debugstr_w(pPrintProviderName));
6887     return TRUE;
6888 }
6889
6890 /******************************************************************************
6891  *      EnumFormsA (WINSPOOL.@)
6892  */
6893 BOOL WINAPI EnumFormsA( HANDLE hPrinter, DWORD Level, LPBYTE pForm,
6894     DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned )
6895 {
6896     FIXME("%p %x %p %x %p %p\n", hPrinter, Level, pForm, cbBuf, pcbNeeded, pcReturned);
6897     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
6898     return FALSE;
6899 }
6900
6901 /******************************************************************************
6902  *      EnumFormsW (WINSPOOL.@)
6903  */
6904 BOOL WINAPI EnumFormsW( HANDLE hPrinter, DWORD Level, LPBYTE pForm,
6905     DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned )
6906 {
6907     FIXME("%p %x %p %x %p %p\n", hPrinter, Level, pForm, cbBuf, pcbNeeded, pcReturned);
6908     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
6909     return FALSE;
6910 }
6911
6912 /*****************************************************************************
6913  *          EnumMonitorsA [WINSPOOL.@]
6914  *
6915  * See EnumMonitorsW.
6916  *
6917  */
6918 BOOL WINAPI EnumMonitorsA(LPSTR pName, DWORD Level, LPBYTE pMonitors,
6919                           DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
6920 {
6921     BOOL    res;
6922     LPBYTE  bufferW = NULL;
6923     LPWSTR  nameW = NULL;
6924     DWORD   needed = 0;
6925     DWORD   numentries = 0;
6926     INT     len;
6927
6928     TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_a(pName), Level, pMonitors,
6929           cbBuf, pcbNeeded, pcReturned);
6930
6931     /* convert servername to unicode */
6932     if (pName) {
6933         len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6934         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6935         MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6936     }
6937     /* alloc (userbuffersize*sizeof(WCHAR) and try to enum the monitors */
6938     needed = cbBuf * sizeof(WCHAR);
6939     if (needed) bufferW = HeapAlloc(GetProcessHeap(), 0, needed);
6940     res = EnumMonitorsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
6941
6942     if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
6943         if (pcbNeeded) needed = *pcbNeeded;
6944         /* HeapReAlloc return NULL, when bufferW was NULL */
6945         bufferW = (bufferW) ? HeapReAlloc(GetProcessHeap(), 0, bufferW, needed) :
6946                               HeapAlloc(GetProcessHeap(), 0, needed);
6947
6948         /* Try again with the large Buffer */
6949         res = EnumMonitorsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
6950     }
6951     numentries = pcReturned ? *pcReturned : 0;
6952     needed = 0;
6953     /*
6954        W2k require the buffersize from EnumMonitorsW also for EnumMonitorsA.
6955        We use the smaller Ansi-Size to avoid conflicts with fixed Buffers of old Apps.
6956      */
6957     if (res) {
6958         /* EnumMonitorsW collected all Data. Parse them to calculate ANSI-Size */
6959         DWORD   entrysize = 0;
6960         DWORD   index;
6961         LPSTR   ptr;
6962         LPMONITOR_INFO_2W mi2w;
6963         LPMONITOR_INFO_2A mi2a;
6964
6965         /* MONITOR_INFO_*W and MONITOR_INFO_*A have the same size */
6966         entrysize = (Level == 1) ? sizeof(MONITOR_INFO_1A) : sizeof(MONITOR_INFO_2A);
6967
6968         /* First pass: calculate the size for all Entries */
6969         mi2w = (LPMONITOR_INFO_2W) bufferW;
6970         mi2a = (LPMONITOR_INFO_2A) pMonitors;
6971         index = 0;
6972         while (index < numentries) {
6973             index++;
6974             needed += entrysize;    /* MONITOR_INFO_?A */
6975             TRACE("%p: parsing #%d (%s)\n", mi2w, index, debugstr_w(mi2w->pName));
6976
6977             needed += WideCharToMultiByte(CP_ACP, 0, mi2w->pName, -1,
6978                                             NULL, 0, NULL, NULL);
6979             if (Level > 1) {
6980                 needed += WideCharToMultiByte(CP_ACP, 0, mi2w->pEnvironment, -1,
6981                                                 NULL, 0, NULL, NULL);
6982                 needed += WideCharToMultiByte(CP_ACP, 0, mi2w->pDLLName, -1,
6983                                                 NULL, 0, NULL, NULL);
6984             }
6985             /* use LPBYTE with entrysize to avoid double code (MONITOR_INFO_1 + MONITOR_INFO_2) */
6986             mi2w = (LPMONITOR_INFO_2W) (((LPBYTE)mi2w) + entrysize);
6987             mi2a = (LPMONITOR_INFO_2A) (((LPBYTE)mi2a) + entrysize);
6988         }
6989
6990         /* check for errors and quit on failure */
6991         if (cbBuf < needed) {
6992             SetLastError(ERROR_INSUFFICIENT_BUFFER);
6993             res = FALSE;
6994             goto emA_cleanup;
6995         }
6996         len = entrysize * numentries;       /* room for all MONITOR_INFO_?A */
6997         ptr = (LPSTR) &pMonitors[len];      /* room for strings */
6998         cbBuf -= len ;                      /* free Bytes in the user-Buffer */
6999         mi2w = (LPMONITOR_INFO_2W) bufferW;
7000         mi2a = (LPMONITOR_INFO_2A) pMonitors;
7001         index = 0;
7002         /* Second Pass: Fill the User Buffer (if we have one) */
7003         while ((index < numentries) && pMonitors) {
7004             index++;
7005             TRACE("%p: writing MONITOR_INFO_%dA #%d\n", mi2a, Level, index);
7006             mi2a->pName = ptr;
7007             len = WideCharToMultiByte(CP_ACP, 0, mi2w->pName, -1,
7008                                             ptr, cbBuf , NULL, NULL);
7009             ptr += len;
7010             cbBuf -= len;
7011             if (Level > 1) {
7012                 mi2a->pEnvironment = ptr;
7013                 len = WideCharToMultiByte(CP_ACP, 0, mi2w->pEnvironment, -1,
7014                                             ptr, cbBuf, NULL, NULL);
7015                 ptr += len;
7016                 cbBuf -= len;
7017
7018                 mi2a->pDLLName = ptr;
7019                 len = WideCharToMultiByte(CP_ACP, 0, mi2w->pDLLName, -1,
7020                                             ptr, cbBuf, NULL, NULL);
7021                 ptr += len;
7022                 cbBuf -= len;
7023             }
7024             /* use LPBYTE with entrysize to avoid double code (MONITOR_INFO_1 + MONITOR_INFO_2) */
7025             mi2w = (LPMONITOR_INFO_2W) (((LPBYTE)mi2w) + entrysize);
7026             mi2a = (LPMONITOR_INFO_2A) (((LPBYTE)mi2a) + entrysize);
7027         }
7028     }
7029 emA_cleanup:
7030     if (pcbNeeded)  *pcbNeeded = needed;
7031     if (pcReturned) *pcReturned = (res) ? numentries : 0;
7032
7033     HeapFree(GetProcessHeap(), 0, nameW);
7034     HeapFree(GetProcessHeap(), 0, bufferW);
7035
7036     TRACE("returning %d with %d (%d byte for %d entries)\n",
7037             (res), GetLastError(), needed, numentries);
7038
7039     return (res);
7040
7041 }
7042
7043 /*****************************************************************************
7044  *          EnumMonitorsW [WINSPOOL.@]
7045  *
7046  * Enumerate available Port-Monitors
7047  *
7048  * PARAMS
7049  *  pName       [I] Servername or NULL (local Computer)
7050  *  Level       [I] Structure-Level (1:Win9x+NT or 2:NT only)
7051  *  pMonitors   [O] PTR to Buffer that receives the Result
7052  *  cbBuf       [I] Size of Buffer at pMonitors
7053  *  pcbNeeded   [O] PTR to DWORD that receives the size in Bytes used / required for pMonitors
7054  *  pcReturned  [O] PTR to DWORD that receives the number of Monitors in pMonitors
7055  *
7056  * RETURNS
7057  *  Success: TRUE
7058  *  Failure: FALSE and in pcbNeeded the Bytes required for buffer, if cbBuf is too small
7059  *
7060  * NOTES
7061  *  Windows reads the Registry once and cache the Results.
7062  *
7063  *|  Language-Monitors are also installed in the same Registry-Location but
7064  *|  they are filtered in Windows (not returned by EnumMonitors).
7065  *|  We do no filtering to simplify our Code.
7066  *
7067  */
7068 BOOL WINAPI EnumMonitorsW(LPWSTR pName, DWORD Level, LPBYTE pMonitors,
7069                           DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
7070 {
7071     DWORD   needed = 0;
7072     DWORD   numentries = 0;
7073     BOOL    res = FALSE;
7074
7075     TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pMonitors,
7076           cbBuf, pcbNeeded, pcReturned);
7077
7078     if (pName && (lstrlenW(pName))) {
7079         FIXME("for Server %s not implemented\n", debugstr_w(pName));
7080         SetLastError(ERROR_ACCESS_DENIED);
7081         goto emW_cleanup;
7082     }
7083
7084     /* Level is not checked in win9x */
7085     if (!Level || (Level > 2)) {
7086         WARN("level (%d) is ignored in win9x\n", Level);
7087         SetLastError(ERROR_INVALID_LEVEL);
7088         goto emW_cleanup;
7089     }
7090     if (!pcbNeeded) {
7091         SetLastError(RPC_X_NULL_REF_POINTER);
7092         goto emW_cleanup;
7093     }
7094
7095     /* Scan all Monitor-Keys */
7096     numentries = 0;
7097     needed = get_local_monitors(Level, NULL, 0, &numentries);
7098
7099     /* we calculated the needed buffersize. now do the error-checks */
7100     if (cbBuf < needed) {
7101         SetLastError(ERROR_INSUFFICIENT_BUFFER);
7102         goto emW_cleanup;
7103     }
7104     else if (!pMonitors || !pcReturned) {
7105         SetLastError(RPC_X_NULL_REF_POINTER);
7106         goto emW_cleanup;
7107     }
7108
7109     /* fill the Buffer with the Monitor-Keys */
7110     needed = get_local_monitors(Level, pMonitors, cbBuf, &numentries);
7111     res = TRUE;
7112
7113 emW_cleanup:
7114     if (pcbNeeded)  *pcbNeeded = needed;
7115     if (pcReturned) *pcReturned = numentries;
7116
7117     TRACE("returning %d with %d (%d byte for %d entries)\n",
7118             res, GetLastError(), needed, numentries);
7119
7120     return (res);
7121 }
7122
7123 /******************************************************************************
7124  * SpoolerInit (WINSPOOL.@)
7125  *
7126  * Initialize the Spooler
7127  *
7128  * RETURNS
7129  *  Success: TRUE
7130  *  Failure: FALSE
7131  *
7132  * NOTES
7133  *  The function fails on windows, when the spooler service is not running
7134  *
7135  */
7136 BOOL WINAPI SpoolerInit(void)
7137 {
7138
7139     if ((backend == NULL)  && !load_backend()) return FALSE;
7140     return TRUE;
7141 }
7142
7143 /******************************************************************************
7144  *              XcvDataW (WINSPOOL.@)
7145  *
7146  * Execute commands in the Printmonitor DLL
7147  *
7148  * PARAMS
7149  *  hXcv            [i] Handle from OpenPrinter (with XcvMonitor or XcvPort)
7150  *  pszDataName     [i] Name of the command to execute
7151  *  pInputData      [i] Buffer for extra Input Data (needed only for some commands)
7152  *  cbInputData     [i] Size in Bytes of Buffer at pInputData
7153  *  pOutputData     [o] Buffer to receive additional Data (needed only for some commands)
7154  *  cbOutputData    [i] Size in Bytes of Buffer at pOutputData
7155  *  pcbOutputNeeded [o] PTR to receive the minimal Size in Bytes of the Buffer at pOutputData
7156  *  pdwStatus       [o] PTR to receive the win32 error code from the Printmonitor DLL
7157  *
7158  * RETURNS
7159  *  Success: TRUE
7160  *  Failure: FALSE
7161  *
7162  * NOTES
7163  *  Returning "TRUE" does mean, that the Printmonitor DLL was called successful.
7164  *  The execution of the command can still fail (check pdwStatus for ERROR_SUCCESS).
7165  *
7166  *  Minimal List of commands, that a Printmonitor DLL should support:
7167  *
7168  *| "MonitorUI" : Return the Name of the Userinterface-DLL as WSTR in pOutputData
7169  *| "AddPort"   : Add a Port
7170  *| "DeletePort": Delete a Port
7171  *
7172  *  Many Printmonitors support additional commands. Examples for localspl.dll:
7173  *  "GetDefaultCommConfig", "SetDefaultCommConfig",
7174  *  "GetTransmissionRetryTimeout", "ConfigureLPTPortCommandOK"
7175  *
7176  */
7177 BOOL WINAPI XcvDataW( HANDLE hXcv, LPCWSTR pszDataName, PBYTE pInputData,
7178     DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData,
7179     PDWORD pcbOutputNeeded, PDWORD pdwStatus)
7180 {
7181     opened_printer_t *printer;
7182
7183     TRACE("(%p, %s, %p, %d, %p, %d, %p, %p)\n", hXcv, debugstr_w(pszDataName),
7184           pInputData, cbInputData, pOutputData,
7185           cbOutputData, pcbOutputNeeded, pdwStatus);
7186
7187     printer = get_opened_printer(hXcv);
7188     if (!printer || (!printer->hXcv)) {
7189         SetLastError(ERROR_INVALID_HANDLE);
7190         return FALSE;
7191     }
7192
7193     if (!pcbOutputNeeded) {
7194         SetLastError(ERROR_INVALID_PARAMETER);
7195         return FALSE;
7196     }
7197
7198     if (!pszDataName || !pdwStatus || (!pOutputData && (cbOutputData > 0))) {
7199         SetLastError(RPC_X_NULL_REF_POINTER);
7200         return FALSE;
7201     }
7202
7203     *pcbOutputNeeded = 0;
7204
7205     *pdwStatus = printer->pm->monitor->pfnXcvDataPort(printer->hXcv, pszDataName,
7206             pInputData, cbInputData, pOutputData, cbOutputData, pcbOutputNeeded);
7207
7208     return TRUE;
7209 }
7210
7211 /*****************************************************************************
7212  *          EnumPrinterDataA [WINSPOOL.@]
7213  *
7214  */
7215 DWORD WINAPI EnumPrinterDataA( HANDLE hPrinter, DWORD dwIndex, LPSTR pValueName,
7216     DWORD cbValueName, LPDWORD pcbValueName, LPDWORD pType, LPBYTE pData,
7217     DWORD cbData, LPDWORD pcbData )
7218 {
7219     FIXME("%p %x %p %x %p %p %p %x %p\n", hPrinter, dwIndex, pValueName,
7220           cbValueName, pcbValueName, pType, pData, cbData, pcbData);
7221     return ERROR_NO_MORE_ITEMS;
7222 }
7223
7224 /*****************************************************************************
7225  *          EnumPrinterDataW [WINSPOOL.@]
7226  *
7227  */
7228 DWORD WINAPI EnumPrinterDataW( HANDLE hPrinter, DWORD dwIndex, LPWSTR pValueName,
7229     DWORD cbValueName, LPDWORD pcbValueName, LPDWORD pType, LPBYTE pData,
7230     DWORD cbData, LPDWORD pcbData )
7231 {
7232     FIXME("%p %x %p %x %p %p %p %x %p\n", hPrinter, dwIndex, pValueName,
7233           cbValueName, pcbValueName, pType, pData, cbData, pcbData);
7234     return ERROR_NO_MORE_ITEMS;
7235 }
7236
7237 /*****************************************************************************
7238  *          EnumPrintProcessorDatatypesA [WINSPOOL.@]
7239  *
7240  */
7241 BOOL WINAPI EnumPrintProcessorDatatypesA(LPSTR pName, LPSTR pPrintProcessorName,
7242                                          DWORD Level, LPBYTE pDatatypes, DWORD cbBuf,
7243                                          LPDWORD pcbNeeded, LPDWORD pcReturned)
7244 {
7245     FIXME("Stub: %s %s %d %p %d %p %p\n", debugstr_a(pName),
7246           debugstr_a(pPrintProcessorName), Level, pDatatypes, cbBuf,
7247           pcbNeeded, pcReturned);
7248     return FALSE;
7249 }
7250
7251 /*****************************************************************************
7252  *          EnumPrintProcessorDatatypesW [WINSPOOL.@]
7253  *
7254  */
7255 BOOL WINAPI EnumPrintProcessorDatatypesW(LPWSTR pName, LPWSTR pPrintProcessorName,
7256                                          DWORD Level, LPBYTE pDatatypes, DWORD cbBuf,
7257                                          LPDWORD pcbNeeded, LPDWORD pcReturned)
7258 {
7259     FIXME("Stub: %s %s %d %p %d %p %p\n", debugstr_w(pName),
7260           debugstr_w(pPrintProcessorName), Level, pDatatypes, cbBuf,
7261           pcbNeeded, pcReturned);
7262     return FALSE;
7263 }
7264
7265 /*****************************************************************************
7266  *          EnumPrintProcessorsA [WINSPOOL.@]
7267  *
7268  */
7269 BOOL WINAPI EnumPrintProcessorsA(LPSTR pName, LPSTR pEnvironment, DWORD Level,
7270     LPBYTE pPrintProcessorInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcbReturned)
7271 {
7272     FIXME("Stub: %s %s %d %p %d %p %p\n", pName, pEnvironment, Level,
7273         pPrintProcessorInfo, cbBuf, pcbNeeded, pcbReturned);
7274     return FALSE;
7275 }
7276
7277 /*****************************************************************************
7278  *          EnumPrintProcessorsW [WINSPOOL.@]
7279  *
7280  */
7281 BOOL WINAPI EnumPrintProcessorsW(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
7282     LPBYTE pPrintProcessorInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcbReturned)
7283 {
7284     FIXME("Stub: %s %s %d %p %d %p %p\n", debugstr_w(pName),
7285         debugstr_w(pEnvironment), Level, pPrintProcessorInfo,
7286         cbBuf, pcbNeeded, pcbReturned);
7287     return FALSE;
7288 }
7289
7290 /*****************************************************************************
7291  *          ExtDeviceMode [WINSPOOL.@]
7292  *
7293  */
7294 LONG WINAPI ExtDeviceMode( HWND hWnd, HANDLE hInst, LPDEVMODEA pDevModeOutput,
7295     LPSTR pDeviceName, LPSTR pPort, LPDEVMODEA pDevModeInput, LPSTR pProfile,
7296     DWORD fMode)
7297 {
7298     FIXME("Stub: %p %p %p %s %s %p %s %x\n", hWnd, hInst, pDevModeOutput,
7299           debugstr_a(pDeviceName), debugstr_a(pPort), pDevModeInput,
7300           debugstr_a(pProfile), fMode);
7301     return -1;
7302 }
7303
7304 /*****************************************************************************
7305  *          FindClosePrinterChangeNotification [WINSPOOL.@]
7306  *
7307  */
7308 BOOL WINAPI FindClosePrinterChangeNotification( HANDLE hChange )
7309 {
7310     FIXME("Stub: %p\n", hChange);
7311     return TRUE;
7312 }
7313
7314 /*****************************************************************************
7315  *          FindFirstPrinterChangeNotification [WINSPOOL.@]
7316  *
7317  */
7318 HANDLE WINAPI FindFirstPrinterChangeNotification( HANDLE hPrinter,
7319     DWORD fdwFlags, DWORD fdwOptions, LPVOID pPrinterNotifyOptions )
7320 {
7321     FIXME("Stub: %p %x %x %p\n",
7322           hPrinter, fdwFlags, fdwOptions, pPrinterNotifyOptions);
7323     return INVALID_HANDLE_VALUE;
7324 }
7325
7326 /*****************************************************************************
7327  *          FindNextPrinterChangeNotification [WINSPOOL.@]
7328  *
7329  */
7330 BOOL WINAPI FindNextPrinterChangeNotification( HANDLE hChange, PDWORD pdwChange,
7331     LPVOID pPrinterNotifyOptions, LPVOID *ppPrinterNotifyInfo )
7332 {
7333     FIXME("Stub: %p %p %p %p\n",
7334           hChange, pdwChange, pPrinterNotifyOptions, ppPrinterNotifyInfo);
7335     return FALSE;
7336 }
7337
7338 /*****************************************************************************
7339  *          FreePrinterNotifyInfo [WINSPOOL.@]
7340  *
7341  */
7342 BOOL WINAPI FreePrinterNotifyInfo( PPRINTER_NOTIFY_INFO pPrinterNotifyInfo )
7343 {
7344     FIXME("Stub: %p\n", pPrinterNotifyInfo);
7345     return TRUE;
7346 }
7347
7348 /*****************************************************************************
7349  *          string_to_buf
7350  *
7351  * Copies a unicode string into a buffer.  The buffer will either contain unicode or
7352  * ansi depending on the unicode parameter.
7353  */
7354 static BOOL string_to_buf(LPCWSTR str, LPBYTE ptr, DWORD cb, DWORD *size, BOOL unicode)
7355 {
7356     if(!str)
7357     {
7358         *size = 0;
7359         return TRUE;
7360     }
7361
7362     if(unicode)
7363     {
7364         *size = (strlenW(str) + 1) * sizeof(WCHAR);
7365         if(*size <= cb)
7366         {
7367             memcpy(ptr, str, *size);
7368             return TRUE;
7369         }
7370         return FALSE;
7371     }
7372     else
7373     {
7374         *size = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
7375         if(*size <= cb)
7376         {
7377             WideCharToMultiByte(CP_ACP, 0, str, -1, (LPSTR)ptr, *size, NULL, NULL);
7378             return TRUE;
7379         }
7380         return FALSE;
7381     }
7382 }
7383
7384 /*****************************************************************************
7385  *          get_job_info_1
7386  */
7387 static BOOL get_job_info_1(job_t *job, JOB_INFO_1W *ji1, LPBYTE buf, DWORD cbBuf,
7388                            LPDWORD pcbNeeded, BOOL unicode)
7389 {
7390     DWORD size, left = cbBuf;
7391     BOOL space = (cbBuf > 0);
7392     LPBYTE ptr = buf;
7393
7394     *pcbNeeded = 0;
7395
7396     if(space)
7397     {
7398         ji1->JobId = job->job_id;
7399     }
7400
7401     string_to_buf(job->document_title, ptr, left, &size, unicode);
7402     if(space && size <= left)
7403     {
7404         ji1->pDocument = (LPWSTR)ptr;
7405         ptr += size;
7406         left -= size;
7407     }
7408     else
7409         space = FALSE;
7410     *pcbNeeded += size;
7411
7412     return space;
7413 }
7414
7415 /*****************************************************************************
7416  *          get_job_info_2
7417  */
7418 static BOOL get_job_info_2(job_t *job, JOB_INFO_2W *ji2, LPBYTE buf, DWORD cbBuf,
7419                            LPDWORD pcbNeeded, BOOL unicode)
7420 {
7421     DWORD size, left = cbBuf;
7422     BOOL space = (cbBuf > 0);
7423     LPBYTE ptr = buf;
7424
7425     *pcbNeeded = 0;
7426
7427     if(space)
7428     {
7429         ji2->JobId = job->job_id;
7430     }
7431
7432     string_to_buf(job->document_title, ptr, left, &size, unicode);
7433     if(space && size <= left)
7434     {
7435         ji2->pDocument = (LPWSTR)ptr;
7436         ptr += size;
7437         left -= size;
7438     }
7439     else
7440         space = FALSE;
7441     *pcbNeeded += size;
7442
7443     return space;
7444 }
7445
7446 /*****************************************************************************
7447  *          get_job_info
7448  */
7449 static BOOL get_job_info(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob,
7450                          DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
7451 {
7452     BOOL ret = FALSE;
7453     DWORD needed = 0, size;
7454     job_t *job;
7455     LPBYTE ptr = pJob;
7456
7457     TRACE("%p %d %d %p %d %p\n", hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded);
7458
7459     EnterCriticalSection(&printer_handles_cs);
7460     job = get_job(hPrinter, JobId);
7461     if(!job)
7462         goto end;
7463
7464     switch(Level)
7465     {
7466     case 1:
7467         size = sizeof(JOB_INFO_1W);
7468         if(cbBuf >= size)
7469         {
7470             cbBuf -= size;
7471             ptr += size;
7472             memset(pJob, 0, size);
7473         }
7474         else
7475             cbBuf = 0;
7476         ret = get_job_info_1(job, (JOB_INFO_1W *)pJob, ptr, cbBuf, &needed, unicode);
7477         needed += size;
7478         break;
7479
7480     case 2:
7481         size = sizeof(JOB_INFO_2W);
7482         if(cbBuf >= size)
7483         {
7484             cbBuf -= size;
7485             ptr += size;
7486             memset(pJob, 0, size);
7487         }
7488         else
7489             cbBuf = 0;
7490         ret = get_job_info_2(job, (JOB_INFO_2W *)pJob, ptr, cbBuf, &needed, unicode);
7491         needed += size;
7492         break;
7493
7494     case 3:
7495         size = sizeof(JOB_INFO_3);
7496         if(cbBuf >= size)
7497         {
7498             cbBuf -= size;
7499             memset(pJob, 0, size);
7500             ret = TRUE;
7501         }
7502         else
7503             cbBuf = 0;
7504         needed = size;
7505         break;
7506
7507     default:
7508         SetLastError(ERROR_INVALID_LEVEL);
7509         goto end;
7510     }
7511     if(pcbNeeded)
7512         *pcbNeeded = needed;
7513 end:
7514     LeaveCriticalSection(&printer_handles_cs);
7515     return ret;
7516 }
7517
7518 /*****************************************************************************
7519  *          GetJobA [WINSPOOL.@]
7520  *
7521  */
7522 BOOL WINAPI GetJobA(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob,
7523                     DWORD cbBuf, LPDWORD pcbNeeded)
7524 {
7525     return get_job_info(hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded, FALSE);
7526 }
7527
7528 /*****************************************************************************
7529  *          GetJobW [WINSPOOL.@]
7530  *
7531  */
7532 BOOL WINAPI GetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob,
7533                     DWORD cbBuf, LPDWORD pcbNeeded)
7534 {
7535     return get_job_info(hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded, TRUE);
7536 }
7537
7538 /*****************************************************************************
7539  *          schedule_lpr
7540  */
7541 static BOOL schedule_lpr(LPCWSTR printer_name, LPCWSTR filename)
7542 {
7543     char *unixname, *queue, *cmd;
7544     char fmt[] = "lpr -P%s %s";
7545     DWORD len;
7546
7547     if(!(unixname = wine_get_unix_file_name(filename)))
7548         return FALSE;
7549
7550     len = WideCharToMultiByte(CP_ACP, 0, printer_name, -1, NULL, 0, NULL, NULL);
7551     queue = HeapAlloc(GetProcessHeap(), 0, len);
7552     WideCharToMultiByte(CP_ACP, 0, printer_name, -1, queue, len, NULL, NULL);
7553
7554     cmd = HeapAlloc(GetProcessHeap(), 0, strlen(unixname) + len + sizeof(fmt) - 5);
7555     sprintf(cmd, fmt, queue, unixname);
7556
7557     TRACE("printing with: %s\n", cmd);
7558     system(cmd);
7559
7560     HeapFree(GetProcessHeap(), 0, cmd);
7561     HeapFree(GetProcessHeap(), 0, queue);
7562     HeapFree(GetProcessHeap(), 0, unixname);
7563     return TRUE;
7564 }
7565
7566 /*****************************************************************************
7567  *          schedule_cups
7568  */
7569 static BOOL schedule_cups(LPCWSTR printer_name, LPCWSTR filename, LPCWSTR document_title)
7570 {
7571 #ifdef SONAME_LIBCUPS
7572     if(pcupsPrintFile)
7573     {
7574         char *unixname, *queue, *doc_titleA;
7575         DWORD len;
7576         BOOL ret;
7577
7578         if(!(unixname = wine_get_unix_file_name(filename)))
7579             return FALSE;
7580
7581         len = WideCharToMultiByte(CP_ACP, 0, printer_name, -1, NULL, 0, NULL, NULL);
7582         queue = HeapAlloc(GetProcessHeap(), 0, len);
7583         WideCharToMultiByte(CP_ACP, 0, printer_name, -1, queue, len, NULL, NULL);
7584
7585         len = WideCharToMultiByte(CP_ACP, 0, document_title, -1, NULL, 0, NULL, NULL);
7586         doc_titleA = HeapAlloc(GetProcessHeap(), 0, len);
7587         WideCharToMultiByte(CP_ACP, 0, document_title, -1, doc_titleA, len, NULL, NULL);
7588
7589         TRACE("printing via cups\n");
7590         ret = pcupsPrintFile(queue, unixname, doc_titleA, 0, NULL);
7591         HeapFree(GetProcessHeap(), 0, doc_titleA);
7592         HeapFree(GetProcessHeap(), 0, queue);
7593         HeapFree(GetProcessHeap(), 0, unixname);
7594         return ret;
7595     }
7596     else
7597 #endif
7598     {
7599         return schedule_lpr(printer_name, filename);
7600     }
7601 }
7602
7603 INT_PTR CALLBACK file_dlg_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
7604 {
7605     LPWSTR filename;
7606
7607     switch(msg)
7608     {
7609     case WM_INITDIALOG:
7610         SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
7611         return TRUE;
7612
7613     case WM_COMMAND:
7614         if(HIWORD(wparam) == BN_CLICKED)
7615         {
7616             if(LOWORD(wparam) == IDOK)
7617             {
7618                 HANDLE hf;
7619                 DWORD len = SendDlgItemMessageW(hwnd, EDITBOX, WM_GETTEXTLENGTH, 0, 0);
7620                 LPWSTR *output;
7621
7622                 filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
7623                 GetDlgItemTextW(hwnd, EDITBOX, filename, len + 1);
7624
7625                 if(GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
7626                 {
7627                     WCHAR caption[200], message[200];
7628                     int mb_ret;
7629
7630                     LoadStringW(WINSPOOL_hInstance, IDS_CAPTION, caption, sizeof(caption) / sizeof(WCHAR));
7631                     LoadStringW(WINSPOOL_hInstance, IDS_FILE_EXISTS, message, sizeof(message) / sizeof(WCHAR));
7632                     mb_ret = MessageBoxW(hwnd, message, caption, MB_OKCANCEL | MB_ICONEXCLAMATION);
7633                     if(mb_ret == IDCANCEL)
7634                     {
7635                         HeapFree(GetProcessHeap(), 0, filename);
7636                         return TRUE;
7637                     }
7638                 }
7639                 hf = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
7640                 if(hf == INVALID_HANDLE_VALUE)
7641                 {
7642                     WCHAR caption[200], message[200];
7643
7644                     LoadStringW(WINSPOOL_hInstance, IDS_CAPTION, caption, sizeof(caption) / sizeof(WCHAR));
7645                     LoadStringW(WINSPOOL_hInstance, IDS_CANNOT_OPEN, message, sizeof(message) / sizeof(WCHAR));
7646                     MessageBoxW(hwnd, message, caption, MB_OK | MB_ICONEXCLAMATION);
7647                     HeapFree(GetProcessHeap(), 0, filename);
7648                     return TRUE;
7649                 }
7650                 CloseHandle(hf);
7651                 DeleteFileW(filename);
7652                 output = (LPWSTR *)GetWindowLongPtrW(hwnd, DWLP_USER);
7653                 *output = filename;
7654                 EndDialog(hwnd, IDOK);
7655                 return TRUE;
7656             }
7657             if(LOWORD(wparam) == IDCANCEL)
7658             {
7659                 EndDialog(hwnd, IDCANCEL);
7660                 return TRUE;
7661             }
7662         }
7663         return FALSE;
7664     }
7665     return FALSE;
7666 }
7667
7668 /*****************************************************************************
7669  *          get_filename
7670  */
7671 static BOOL get_filename(LPWSTR *filename)
7672 {
7673     return DialogBoxParamW(WINSPOOL_hInstance, MAKEINTRESOURCEW(FILENAME_DIALOG), GetForegroundWindow(),
7674                            file_dlg_proc, (LPARAM)filename) == IDOK;
7675 }
7676
7677 /*****************************************************************************
7678  *          schedule_file
7679  */
7680 static BOOL schedule_file(LPCWSTR filename)
7681 {
7682     LPWSTR output = NULL;
7683
7684     if(get_filename(&output))
7685     {
7686         TRACE("copy to %s\n", debugstr_w(output));
7687         CopyFileW(filename, output, FALSE);
7688         HeapFree(GetProcessHeap(), 0, output);
7689         return TRUE;
7690     }
7691     return FALSE;
7692 }
7693
7694 /*****************************************************************************
7695  *          schedule_pipe
7696  */
7697 static BOOL schedule_pipe(LPCWSTR cmd, LPCWSTR filename)
7698 {
7699 #ifdef HAVE_FORK
7700     char *unixname, *cmdA;
7701     DWORD len;
7702     int fds[2] = {-1, -1}, file_fd = -1, no_read;
7703     BOOL ret = FALSE;
7704     char buf[1024];
7705
7706     if(!(unixname = wine_get_unix_file_name(filename)))
7707         return FALSE;
7708
7709     len = WideCharToMultiByte(CP_ACP, 0, cmd, -1, NULL, 0, NULL, NULL);
7710     cmdA = HeapAlloc(GetProcessHeap(), 0, len);
7711     WideCharToMultiByte(CP_ACP, 0, cmd, -1, cmdA, len, NULL, NULL);
7712
7713     TRACE("printing with: %s\n", cmdA);
7714
7715     if((file_fd = open(unixname, O_RDONLY)) == -1)
7716         goto end;
7717
7718     if (pipe(fds))
7719     {
7720         ERR("pipe() failed!\n");
7721         goto end;
7722     }
7723
7724     if (fork() == 0)
7725     {
7726         close(0);
7727         dup2(fds[0], 0);
7728         close(fds[1]);
7729
7730         /* reset signals that we previously set to SIG_IGN */
7731         signal(SIGPIPE, SIG_DFL);
7732         signal(SIGCHLD, SIG_DFL);
7733
7734         execl("/bin/sh", "/bin/sh", "-c", cmdA, (char*)0);
7735         _exit(1);
7736     }
7737
7738     while((no_read = read(file_fd, buf, sizeof(buf))) > 0)
7739         write(fds[1], buf, no_read);
7740
7741     ret = TRUE;
7742
7743 end:
7744     if(file_fd != -1) close(file_fd);
7745     if(fds[0] != -1) close(fds[0]);
7746     if(fds[1] != -1) close(fds[1]);
7747
7748     HeapFree(GetProcessHeap(), 0, cmdA);
7749     HeapFree(GetProcessHeap(), 0, unixname);
7750     return ret;
7751 #else
7752     return FALSE;
7753 #endif
7754 }
7755
7756 /*****************************************************************************
7757  *          schedule_unixfile
7758  */
7759 static BOOL schedule_unixfile(LPCWSTR output, LPCWSTR filename)
7760 {
7761     int in_fd, out_fd, no_read;
7762     char buf[1024];
7763     BOOL ret = FALSE;
7764     char *unixname, *outputA;
7765     DWORD len;
7766
7767     if(!(unixname = wine_get_unix_file_name(filename)))
7768         return FALSE;
7769
7770     len = WideCharToMultiByte(CP_ACP, 0, output, -1, NULL, 0, NULL, NULL);
7771     outputA = HeapAlloc(GetProcessHeap(), 0, len);
7772     WideCharToMultiByte(CP_ACP, 0, output, -1, outputA, len, NULL, NULL);
7773
7774     out_fd = open(outputA, O_CREAT | O_TRUNC | O_WRONLY, 0666);
7775     in_fd = open(unixname, O_RDONLY);
7776     if(out_fd == -1 || in_fd == -1)
7777         goto end;
7778
7779     while((no_read = read(in_fd, buf, sizeof(buf))) > 0)
7780         write(out_fd, buf, no_read);
7781
7782     ret = TRUE;
7783 end:
7784     if(in_fd != -1) close(in_fd);
7785     if(out_fd != -1) close(out_fd);
7786     HeapFree(GetProcessHeap(), 0, outputA);
7787     HeapFree(GetProcessHeap(), 0, unixname);
7788     return ret;
7789 }
7790
7791 /*****************************************************************************
7792  *          ScheduleJob [WINSPOOL.@]
7793  *
7794  */
7795 BOOL WINAPI ScheduleJob( HANDLE hPrinter, DWORD dwJobID )
7796 {
7797     opened_printer_t *printer;
7798     BOOL ret = FALSE;
7799     struct list *cursor, *cursor2;
7800
7801     TRACE("(%p, %x)\n", hPrinter, dwJobID);
7802     EnterCriticalSection(&printer_handles_cs);
7803     printer = get_opened_printer(hPrinter);
7804     if(!printer)
7805         goto end;
7806
7807     LIST_FOR_EACH_SAFE(cursor, cursor2, &printer->queue->jobs)
7808     {
7809         job_t *job = LIST_ENTRY(cursor, job_t, entry);
7810         HANDLE hf;
7811
7812         if(job->job_id != dwJobID) continue;
7813
7814         hf = CreateFileW(job->filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
7815         if(hf != INVALID_HANDLE_VALUE)
7816         {
7817             PRINTER_INFO_5W *pi5;
7818             DWORD needed;
7819             HKEY hkey;
7820             WCHAR output[1024];
7821             static const WCHAR spooler_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
7822                                                 'P','r','i','n','t','i','n','g','\\','S','p','o','o','l','e','r',0};
7823
7824             GetPrinterW(hPrinter, 5, NULL, 0, &needed);
7825             pi5 = HeapAlloc(GetProcessHeap(), 0, needed);
7826             GetPrinterW(hPrinter, 5, (LPBYTE)pi5, needed, &needed);
7827             TRACE("need to schedule job %d filename %s to port %s\n", job->job_id, debugstr_w(job->filename),
7828                   debugstr_w(pi5->pPortName));
7829
7830             output[0] = 0;
7831
7832             /* @@ Wine registry key: HKCU\Software\Wine\Printing\Spooler */
7833             if(RegOpenKeyW(HKEY_CURRENT_USER, spooler_key, &hkey) == ERROR_SUCCESS)
7834             {
7835                 DWORD type, count = sizeof(output);
7836                 RegQueryValueExW(hkey, pi5->pPortName, NULL, &type, (LPBYTE)output, &count);
7837                 RegCloseKey(hkey);
7838             }
7839             if(output[0] == '|')
7840             {
7841                 schedule_pipe(output + 1, job->filename);
7842             }
7843             else if(output[0])
7844             {
7845                 schedule_unixfile(output, job->filename);
7846             }
7847             else if(!strncmpW(pi5->pPortName, LPR_Port, strlenW(LPR_Port)))
7848             {
7849                 schedule_lpr(pi5->pPortName + strlenW(LPR_Port), job->filename);
7850             }
7851             else if(!strncmpW(pi5->pPortName, CUPS_Port, strlenW(CUPS_Port)))
7852             {
7853                 schedule_cups(pi5->pPortName + strlenW(CUPS_Port), job->filename, job->document_title);
7854             }
7855             else if(!strncmpW(pi5->pPortName, FILE_Port, strlenW(FILE_Port)))
7856             {
7857                 schedule_file(job->filename);
7858             }
7859             else
7860             {
7861                 FIXME("can't schedule to port %s\n", debugstr_w(pi5->pPortName));
7862             }
7863             HeapFree(GetProcessHeap(), 0, pi5);
7864             CloseHandle(hf);
7865             DeleteFileW(job->filename);
7866         }
7867         list_remove(cursor);
7868         HeapFree(GetProcessHeap(), 0, job->document_title);
7869         HeapFree(GetProcessHeap(), 0, job->filename);
7870         HeapFree(GetProcessHeap(), 0, job);
7871         ret = TRUE;
7872         break;
7873     }
7874 end:
7875     LeaveCriticalSection(&printer_handles_cs);
7876     return ret;
7877 }
7878
7879 /*****************************************************************************
7880  *          StartDocDlgA [WINSPOOL.@]
7881  */
7882 LPSTR WINAPI StartDocDlgA( HANDLE hPrinter, DOCINFOA *doc )
7883 {
7884     UNICODE_STRING usBuffer;
7885     DOCINFOW docW;
7886     LPWSTR retW;
7887     LPWSTR docnameW = NULL, outputW = NULL, datatypeW = NULL;
7888     LPSTR ret = NULL;
7889
7890     docW.cbSize = sizeof(docW);
7891     if (doc->lpszDocName)
7892     {
7893         docnameW = asciitounicode(&usBuffer, doc->lpszDocName);
7894         if (!(docW.lpszDocName = docnameW)) return NULL;
7895     }
7896     if (doc->lpszOutput)
7897     {
7898         outputW = asciitounicode(&usBuffer, doc->lpszOutput);
7899         if (!(docW.lpszOutput = outputW)) return NULL;
7900     }
7901     if (doc->lpszDatatype)
7902     {
7903         datatypeW = asciitounicode(&usBuffer, doc->lpszDatatype);
7904         if (!(docW.lpszDatatype = datatypeW)) return NULL;
7905     }
7906     docW.fwType = doc->fwType;
7907
7908     retW = StartDocDlgW(hPrinter, &docW);
7909
7910     if(retW)
7911     {
7912         DWORD len = WideCharToMultiByte(CP_ACP, 0, retW, -1, NULL, 0, NULL, NULL);
7913         ret = HeapAlloc(GetProcessHeap(), 0, len);
7914         WideCharToMultiByte(CP_ACP, 0, retW, -1, ret, len, NULL, NULL);
7915         HeapFree(GetProcessHeap(), 0, retW);
7916     }
7917
7918     HeapFree(GetProcessHeap(), 0, datatypeW);
7919     HeapFree(GetProcessHeap(), 0, outputW);
7920     HeapFree(GetProcessHeap(), 0, docnameW);
7921
7922     return ret;
7923 }
7924
7925 /*****************************************************************************
7926  *          StartDocDlgW [WINSPOOL.@]
7927  *
7928  * Undocumented: Apparently used by gdi32:StartDocW() to popup the file dialog
7929  * when lpszOutput is "FILE:" or if lpszOutput is NULL and the default printer
7930  * port is "FILE:". Also returns the full path if passed a relative path.
7931  *
7932  * The caller should free the returned string from the process heap.
7933  */
7934 LPWSTR WINAPI StartDocDlgW( HANDLE hPrinter, DOCINFOW *doc )
7935 {
7936     LPWSTR ret = NULL;
7937     DWORD len, attr;
7938
7939     if(doc->lpszOutput == NULL) /* Check whether default port is FILE: */
7940     {
7941         PRINTER_INFO_5W *pi5;
7942         GetPrinterW(hPrinter, 5, NULL, 0, &len);
7943         if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
7944             return NULL;
7945         pi5 = HeapAlloc(GetProcessHeap(), 0, len);
7946         GetPrinterW(hPrinter, 5, (LPBYTE)pi5, len, &len);
7947         if(!pi5->pPortName || strcmpW(pi5->pPortName, FILE_Port))
7948         {
7949             HeapFree(GetProcessHeap(), 0, pi5);
7950             return NULL;
7951         }
7952         HeapFree(GetProcessHeap(), 0, pi5);
7953     }
7954
7955     if(doc->lpszOutput == NULL || !strcmpW(doc->lpszOutput, FILE_Port))
7956     {
7957         LPWSTR name;
7958
7959         if (get_filename(&name))
7960         {
7961             if(!(len = GetFullPathNameW(name, 0, NULL, NULL)))
7962             {
7963                 HeapFree(GetProcessHeap(), 0, name);
7964                 return NULL;
7965             }
7966             ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
7967             GetFullPathNameW(name, len, ret, NULL);
7968             HeapFree(GetProcessHeap(), 0, name);
7969         }
7970         return ret;
7971     }
7972
7973     if(!(len = GetFullPathNameW(doc->lpszOutput, 0, NULL, NULL)))
7974         return NULL;
7975
7976     ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
7977     GetFullPathNameW(doc->lpszOutput, len, ret, NULL);
7978
7979     attr = GetFileAttributesW(ret);
7980     if(attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY))
7981     {
7982         HeapFree(GetProcessHeap(), 0, ret);
7983         ret = NULL;
7984     }
7985     return ret;
7986 }