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

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