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