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