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