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

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