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

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