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

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