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