misc/printdrv.c

   1 /*
   2  * Implementation of some printer driver bits
   3  *
   4  * Copyright 1996 John Harvey
   5  * Copyright 1998 Andreas Mohr
   6  */
   7
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <ctype.h>
  11 #include "winspool.h"
  12 #include "ldt.h"
  13 #include "winerror.h"
  14 #include "winreg.h"
  15 #include "debug.h"
  16
  17 static char PrinterModel[]      = "Printer Model";
  18 static char DefaultDevMode[]    = "Default DevMode";
  19 static char PrinterDriverData[] = "PrinterDriverData";
  20 static char Printers[]          = "System\\CurrentControlSet\\Control\\Print\\Printers\\";
  21
  22 /******************************************************************
  23  *                  StartDoc16  [GDI.377]
  24  *
  25  */
  26 INT16 WINAPI StartDoc16( HDC16 hdc, const DOCINFO16 *lpdoc )
  27 {
  28   INT16 retVal;
  29   TRACE(print,"(%p)\n", lpdoc );
  30   TRACE(print,"%d 0x%lx:0x%p 0x%lx:0x%p\n",lpdoc->cbSize,
  31         lpdoc->lpszDocName,PTR_SEG_TO_LIN(lpdoc->lpszDocName),
  32         lpdoc->lpszOutput,PTR_SEG_TO_LIN(lpdoc->lpszOutput));
  33   TRACE(print, "%d %s %s\n",lpdoc->cbSize,
  34         (LPSTR)PTR_SEG_TO_LIN(lpdoc->lpszDocName),
  35         (LPSTR)PTR_SEG_TO_LIN(lpdoc->lpszOutput));
  36   retVal =  Escape16(hdc, STARTDOC,
  37     strlen((LPSTR)PTR_SEG_TO_LIN(lpdoc->lpszDocName)), lpdoc->lpszDocName, 0);
  38   TRACE(print,"Escape16 returned %d\n",retVal);
  39   return retVal;
  40 }
  41
  42 /******************************************************************
  43  *                  EndPage16  [GDI.380]
  44  *
  45  */
  46 INT16 WINAPI EndPage16( HDC16 hdc )
  47 {
  48   INT16 retVal;
  49   retVal =  Escape16(hdc, NEWFRAME, 0, 0, 0);
  50   TRACE(print,"Escape16 returned %d\n",retVal);
  51   return retVal;
  52 }
  53
  54 /******************************************************************
  55  *                  StartDoc32A  [GDI32.347]
  56  *
  57  */
  58 INT WINAPI StartDocA(HDC hdc ,const DOCINFOA* doc)
  59 {
  60   FIXME(gdi,"stub\n");
  61   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  62   return 0; /* failure*/
  63 }
  64
  65 /*************************************************************************
  66  *                  StartDoc32W [GDI32.348]
  67  *
  68  */
  69 INT WINAPI StartDocW(HDC hdc, const DOCINFOW* doc) {
  70   FIXME(gdi,"stub\n");
  71   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  72   return 0; /* failure*/
  73 }
  74
  75 /******************************************************************
  76  *                  StartPage32  [GDI32.349]
  77  *
  78  */
  79 INT WINAPI StartPage(HDC hdc)
  80 {
  81   FIXME(gdi,"stub\n");
  82   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  83   return 0; /* failure*/
  84 }
  85
  86 /******************************************************************
  87  *                  EndPage32  [GDI32.77]
  88  *
  89  */
  90 INT WINAPI EndPage(HDC hdc)
  91 {
  92   FIXME(gdi,"stub\n");
  93   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  94   return 0; /* failure*/
  95 }
  96
  97 /******************************************************************
  98  *                  EndDoc16  [GDI.378]
  99  *
 100  */
 101 INT16 WINAPI EndDoc16(HDC16 hdc)
 102 {
 103   return  Escape16(hdc, ENDDOC, 0, 0, 0);
 104 }
 105
 106 /******************************************************************
 107  *                  EndDoc32  [GDI32.76]
 108  *
 109  */
 110 INT WINAPI EndDoc(HDC hdc)
 111 {
 112   FIXME(gdi,"stub\n");
 113   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 114   return 0; /* failure*/
 115 }
 116
 117 /******************************************************************************
 118  *                 AbortDoc16  [GDI.382]
 119  */
 120 INT16 WINAPI AbortDoc16(HDC16 hdc)
 121 {
 122   return Escape16(hdc, ABORTDOC, 0, 0, 0);
 123 }
 124
 125 /******************************************************************************
 126  *                 AbortDoc32  [GDI32.0]
 127  */
 128 INT WINAPI AbortDoc(HDC hdc)
 129 {
 130     FIXME(gdi, "(%d): stub\n", hdc);
 131     return 1;
 132 }
 133
 134 /******************************************************************
 135  *                  DrvGetPrinterDataInternal
 136  *
 137  * Helper for DrvGetPrinterData
 138  */
 139 static DWORD DrvGetPrinterDataInternal(LPSTR RegStr_Printer,
 140 LPBYTE lpPrinterData, int cbData, int what)
 141 {
 142     DWORD res = -1;
 143     HKEY hkey;
 144     DWORD dwType, cbQueryData;
 145
 146     if (!(RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey))) {
 147         if (what == INT_PD_DEFAULT_DEVMODE) { /* "Default DevMode" */
 148             if (!(RegQueryValueExA(hkey, DefaultDevMode, 0, &dwType, 0, &cbQueryData))) {
 149                 if (!lpPrinterData)
 150                     res = cbQueryData;
 151                 else if ((cbQueryData) && (cbQueryData <= cbData)) {
 152                     cbQueryData = cbData;
 153                     if (RegQueryValueExA(hkey, DefaultDevMode, 0,
 154                                 &dwType, lpPrinterData, &cbQueryData))
 155                         res = cbQueryData;
 156                 }
 157             }
 158         } else { /* "Printer Driver" */
 159             cbQueryData = 32;
 160             RegQueryValueExA(hkey, "Printer Driver", 0,
 161                         &dwType, lpPrinterData, &cbQueryData);
 162             res = cbQueryData;
 163         }
 164     }
 165     if (hkey) RegCloseKey(hkey);
 166     return res;
 167 }
 168
 169 /******************************************************************
 170  *                DrvGetPrinterData     [GDI.282]
 171  *
 172  */
 173 DWORD WINAPI DrvGetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
 174                                LPDWORD lpType, LPBYTE lpPrinterData,
 175                                int cbData, LPDWORD lpNeeded)
 176 {
 177     LPSTR RegStr_Printer;
 178     HKEY hkey = 0, hkey2 = 0;
 179     DWORD res = 0;
 180     DWORD dwType, PrinterAttr, cbPrinterAttr, SetData, size;
 181
 182     if (HIWORD(lpPrinter))
 183             TRACE(print,"printer %s\n",lpPrinter);
 184     else
 185             TRACE(print,"printer %p\n",lpPrinter);
 186     if (HIWORD(lpProfile))
 187             TRACE(print,"profile %s\n",lpProfile);
 188     else
 189             TRACE(print,"profile %p\n",lpProfile);
 190     TRACE(print,"lpType %p\n",lpType);
 191
 192     if ((!lpPrinter) || (!lpProfile) || (!lpNeeded))
 193         return ERROR_INVALID_PARAMETER;
 194
 195     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
 196                                strlen(Printers) + strlen(lpPrinter) + 2);
 197     strcpy(RegStr_Printer, Printers);
 198     strcat(RegStr_Printer, lpPrinter);
 199
 200     if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
 201     (!strcmp(lpProfile, DefaultDevMode)))) {
 202         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
 203                                          INT_PD_DEFAULT_DEVMODE);
 204         if (size+1) {
 205             *lpNeeded = size;
 206             if ((lpPrinterData) && (*lpNeeded > cbData))
 207                 res = ERROR_MORE_DATA;
 208         }
 209         else res = ERROR_INVALID_PRINTER_NAME;
 210     }
 211     else
 212     if (((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
 213     (!strcmp(lpProfile, PrinterModel)))) {
 214         *lpNeeded = 32;
 215         if (!lpPrinterData) goto failed;
 216         if (cbData < 32) {
 217             res = ERROR_MORE_DATA;
 218             goto failed;
 219         }
 220         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
 221                                          INT_PD_DEFAULT_MODEL);
 222         if ((size+1) && (lpType))
 223             *lpType = REG_SZ;
 224         else
 225             res = ERROR_INVALID_PRINTER_NAME;
 226     }
 227     else
 228     {
 229         if ((res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)))
 230             goto failed;
 231         cbPrinterAttr = 4;
 232         if ((res = RegQueryValueExA(hkey, "Attributes", 0,
 233                         &dwType, (LPBYTE)&PrinterAttr, &cbPrinterAttr)))
 234             goto failed;
 235         if ((res = RegOpenKeyA(hkey, PrinterDriverData, &hkey2)))
 236             goto failed;
 237         *lpNeeded = cbData;
 238         res = RegQueryValueExA(hkey2, lpProfile, 0,
 239                 lpType, lpPrinterData, lpNeeded);
 240         if ((res != ERROR_CANTREAD) &&
 241          ((PrinterAttr &
 242         (PRINTER_ATTRIBUTE_ENABLE_BIDI|PRINTER_ATTRIBUTE_NETWORK))
 243         == PRINTER_ATTRIBUTE_NETWORK))
 244         {
 245             if (!(res) && (*lpType == REG_DWORD) && (*(LPDWORD)lpPrinterData == -1))
 246                 res = ERROR_INVALID_DATA;
 247         }
 248         else
 249         {
 250             SetData = -1;
 251             RegSetValueExA(hkey2, lpProfile, 0, REG_DWORD, (LPBYTE)&SetData, 4); /* no result returned */
 252         }
 253     }
 254
 255 failed:
 256     if (hkey2) RegCloseKey(hkey2);
 257     if (hkey) RegCloseKey(hkey);
 258     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
 259     return res;
 260 }
 261
 262
 263 /******************************************************************
 264  *                 DrvSetPrinterData     [GDI.281]
 265  *
 266  */
 267 DWORD WINAPI DrvSetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
 268                                DWORD lpType, LPBYTE lpPrinterData,
 269                                DWORD dwSize)
 270 {
 271     LPSTR RegStr_Printer;
 272     HKEY hkey = 0;
 273     DWORD res = 0;
 274
 275     if (HIWORD(lpPrinter))
 276             TRACE(print,"printer %s\n",lpPrinter);
 277     else
 278             TRACE(print,"printer %p\n",lpPrinter);
 279     if (HIWORD(lpProfile))
 280             TRACE(print,"profile %s\n",lpProfile);
 281     else
 282             TRACE(print,"profile %p\n",lpProfile);
 283     TRACE(print,"lpType %08lx\n",lpType);
 284
 285     if ((!lpPrinter) || (!lpProfile) ||
 286     ((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
 287     (!strcmp(lpProfile, PrinterModel))))
 288         return ERROR_INVALID_PARAMETER;
 289
 290     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
 291                         strlen(Printers) + strlen(lpPrinter) + 2);
 292     strcpy(RegStr_Printer, Printers);
 293     strcat(RegStr_Printer, lpPrinter);
 294
 295     if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
 296     (!strcmp(lpProfile, DefaultDevMode)))) {
 297         if ( RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)
 298              != ERROR_SUCCESS ||
 299              RegSetValueExA(hkey, DefaultDevMode, 0, REG_BINARY,
 300                               lpPrinterData, dwSize) != ERROR_SUCCESS )
 301                 res = ERROR_INVALID_PRINTER_NAME;
 302     }
 303     else
 304     {
 305         strcat(RegStr_Printer, "\\");
 306
 307         if( (res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)) ==
 308             ERROR_SUCCESS ) {
 309
 310             if (!lpPrinterData)
 311                 res = RegDeleteValueA(hkey, lpProfile);
 312             else
 313                 res = RegSetValueExA(hkey, lpProfile, 0, lpType,
 314                                        lpPrinterData, dwSize);
 315         }
 316     }
 317
 318     if (hkey) RegCloseKey(hkey);
 319     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
 320     return res;
 321 }
 322
 323
 324 /******************************************************************
 325  *              DeviceCapabilities32A    [WINSPOOL.151]
 326  *
 327  */
 328 INT WINAPI DeviceCapabilitiesA(LPCSTR printer,LPCSTR target,WORD z,
 329                                    LPSTR a,LPDEVMODEA b)
 330 {
 331     FIXME(print,"(%s,%s,%d,%p,%p):stub.\n",printer,target,z,a,b);
 332     return 1;
 333 }
 334
 335
 336 /*****************************************************************************
 337  *          DeviceCapabilities32W
 338  */
 339 INT WINAPI DeviceCapabilitiesW(LPCWSTR pDevice, LPCWSTR pPort,
 340                                    WORD fwCapability, LPWSTR pOutput,
 341                                    const DEVMODEW *pDevMode)
 342 {
 343     FIXME(print,"(%p,%p,%d,%p,%p): stub\n",
 344           pDevice, pPort, fwCapability, pOutput, pDevMode);
 345     return -1;
 346 }
 347
 348 /******************************************************************
 349  *              DocumentProperties32A   [WINSPOOL.155]
 350  *
 351  */
 352 LONG WINAPI DocumentPropertiesA(HWND hWnd,HANDLE hPrinter,
 353                                 LPSTR pDeviceName, LPDEVMODEA pDevModeOutput,
 354                                   LPDEVMODEA pDevModeInput,DWORD fMode )
 355 {
 356     FIXME(print,"(%d,%d,%s,%p,%p,%ld):stub.\n",
 357         hWnd,hPrinter,pDeviceName,pDevModeOutput,pDevModeInput,fMode
 358     );
 359     return 1;
 360 }
 361
 362
 363 /*****************************************************************************
 364  *          DocumentProperties32W
 365  */
 366 LONG WINAPI DocumentPropertiesW(HWND hWnd, HANDLE hPrinter,
 367                                   LPWSTR pDeviceName,
 368                                   LPDEVMODEW pDevModeOutput,
 369                                   LPDEVMODEW pDevModeInput, DWORD fMode)
 370 {
 371     FIXME(print,"(%d,%d,%s,%p,%p,%ld): stub\n",
 372           hWnd,hPrinter,debugstr_w(pDeviceName),pDevModeOutput,pDevModeInput,
 373           fMode);
 374     return -1;
 375 }
 376
 377
 378 /******************************************************************
 379  *              OpenPrinter32A        [WINSPOOL.196]
 380  *
 381  */
 382 BOOL WINAPI OpenPrinterA(LPSTR lpPrinterName,HANDLE *phPrinter,
 383                              LPPRINTER_DEFAULTSA pDefault)
 384 {
 385     FIXME(print,"(%s,%p,%p):stub\n",debugstr_a(lpPrinterName), phPrinter,
 386           pDefault);
 387     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 388     return FALSE;
 389 }
 390
 391 /******************************************************************
 392  *              OpenPrinter32W        [WINSPOOL.197]
 393  *
 394  */
 395 BOOL WINAPI OpenPrinterW(LPWSTR lpPrinterName,HANDLE *phPrinter,
 396                              LPPRINTER_DEFAULTSW pDefault)
 397 {
 398     FIXME(print,"(%s,%p,%p):stub\n",debugstr_w(lpPrinterName), phPrinter,
 399           pDefault);
 400     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 401     return FALSE;
 402 }
 403
 404
 405 /******************************************************************
 406  *              ENUMPRINTERS_AddInfo4A        internal
 407  *
 408  *    Creates a PRINTER_INFO_4A structure at:  lpbPrinters[dwNextStructPos]
 409  *    for printer PrinterNameKey.
 410  *    Note that there is no check whether the information really fits!
 411  *
 412  * RETURNS
 413  *    FALSE if there is still space left in the buffer.
 414  *
 415  * BUGS:
 416  *    This function should not exist in Win95 mode, but does anyway.
 417  */
 418 BOOL ENUMPRINTERS_AddInfo4A(
 419                    LPSTR lpszPrinterName,/* name of printer to fill struct for*/
 420                    LPBYTE lpbPrinters,   /* buffer which receives info*/
 421                    DWORD  dwNextStructPos,  /* pos in buffer for struct */
 422                    LPDWORD dwNextStringPos, /* pos in buffer for next string */
 423                                    DWORD  dwBufSize,        /* max size of buffer in bytes */
 424                    BOOL   bCalcSpaceOnly    /* TRUE if out-of-space in buffer */
 425 ){
 426  HKEY  hPrinterSettings;
 427  DWORD DataType;
 428  DWORD DataSize=8;
 429  char  Data[8];
 430  DWORD* DataPointer= (DWORD*) Data;
 431  LPSTR lpszPrinterSettings = (LPSTR) malloc(strlen(Printers)+
 432                                                                                            strlen(lpszPrinterName)+2);
 433  LPPRINTER_INFO_4A lpPInfo4 = (LPPRINTER_INFO_4A) &lpbPrinters[dwNextStructPos];
 434
 435  lpPInfo4->pPrinterName = &lpbPrinters[*dwNextStringPos];
 436  *dwNextStringPos += strlen(lpszPrinterName)+1;
 437  if (*dwNextStringPos > dwBufSize)
 438         bCalcSpaceOnly=TRUE;
 439  if (bCalcSpaceOnly==FALSE)
 440      strcpy(lpPInfo4->pPrinterName, lpszPrinterName);
 441  lpPInfo4->pServerName = NULL;
 442
 443  /* open the registry to find the attributes of the printer */
 444  if (lpszPrinterSettings!=NULL)
 445         {
 446      strcpy(lpszPrinterSettings,Printers);
 447      strcat(lpszPrinterSettings,lpszPrinterName);
 448     }
 449  if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, lpszPrinterSettings, 0,
 450                                                 KEY_READ, &hPrinterSettings) != ERROR_SUCCESS)
 451         {
 452      FIXME(print, "The registry did not contain my printer anymore?\n");
 453      lpPInfo4->Attributes = 0;
 454     }
 455  else
 456     {
 457          RegQueryValueExA(hPrinterSettings, "Attributes", NULL, &DataType,
 458                                         Data, &DataSize);
 459          if (DataType==REG_DWORD)
 460          lpPInfo4->Attributes = PRINTER_ATTRIBUTE_LOCAL + *DataPointer;
 461     }
 462  if (lpszPrinterSettings)
 463          free(lpszPrinterSettings);
 464
 465  return(bCalcSpaceOnly);
 466 }
 467
 468 /******************************************************************
 469  *              ENUMPRINTERS_AddInfo5A        internal
 470  *
 471  *    Creates a PRINTER_INFO_5A structure at:  lpbPrinters[dwNextStructPos]
 472  *    for printer PrinterNameKey.
 473  *    Settings are read from the registry.
 474  *    Note that there is no check whether the information really fits!
 475  * RETURNS
 476  *    FALSE if there is still space left in the buffer.
 477  */
 478 BOOL ENUMPRINTERS_AddInfo5A(
 479                    LPSTR lpszPrinterName,/* name of printer to fill struct for*/
 480                    LPBYTE lpbPrinters,   /* buffer which receives info*/
 481                    DWORD  dwNextStructPos,  /* pos in buffer for struct */
 482                    LPDWORD dwNextStringPos, /* pos in buffer for next string */
 483                                    DWORD  dwBufSize,        /* max size of buffer in bytes */
 484                    BOOL   bCalcSpaceOnly    /* TRUE if out-of-space in buffer */
 485 ){
 486  HKEY  hPrinterSettings;
 487  DWORD DataType;
 488  DWORD DataSize=255;
 489  char  Data[255];
 490  DWORD* DataPointer= (DWORD*) Data;
 491  LPSTR lpszPrinterSettings = (LPSTR) malloc(strlen(Printers)+
 492                                                                                            strlen(lpszPrinterName)+2);
 493  LPPRINTER_INFO_5A lpPInfo5 = (LPPRINTER_INFO_5A) &lpbPrinters[dwNextStructPos];
 494
 495  /* copy the PrinterName into the structure */
 496  lpPInfo5->pPrinterName = &lpbPrinters[*dwNextStringPos];
 497  *dwNextStringPos += strlen(lpszPrinterName)+1;
 498  if (*dwNextStringPos > dwBufSize)
 499         bCalcSpaceOnly=TRUE;
 500  if (bCalcSpaceOnly==FALSE)
 501      strcpy(lpPInfo5->pPrinterName, lpszPrinterName);
 502
 503  /* open the registry to find the attributes, etc of the printer */
 504  if (lpszPrinterSettings!=NULL)
 505         {
 506      strcpy(lpszPrinterSettings,Printers);
 507      strcat(lpszPrinterSettings,lpszPrinterName);
 508     }
 509  if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, lpszPrinterSettings, 0,
 510                                                 KEY_READ, &hPrinterSettings) != ERROR_SUCCESS)
 511         {
 512      FIXME(print, "The registry did not contain my printer anymore?\n");
 513      lpPInfo5->Attributes = 0;
 514      lpPInfo5->pPortName = NULL;
 515      lpPInfo5->Attributes = 0;
 516      lpPInfo5->DeviceNotSelectedTimeOut =0;
 517      lpPInfo5->TransmissionRetryTimeout = 0;
 518     }
 519  else
 520     {
 521          RegQueryValueExA(hPrinterSettings, "Attributes", NULL, &DataType,
 522                                         Data, &DataSize);
 523          if (DataType==REG_DWORD)
 524                 lpPInfo5->Attributes = PRINTER_ATTRIBUTE_LOCAL + *DataPointer;
 525
 526      DataSize=255;
 527          RegQueryValueExA(hPrinterSettings, "txTimeout", NULL, &DataType,
 528                                         Data, &DataSize);
 529          if (DataType==REG_DWORD)
 530                 lpPInfo5->DeviceNotSelectedTimeOut = *DataPointer;
 531
 532      DataSize=255;
 533          RegQueryValueExA(hPrinterSettings, "dnsTimeout", NULL, &DataType,
 534                                         Data, &DataSize);
 535          if (DataType==REG_DWORD)
 536                  lpPInfo5->TransmissionRetryTimeout = *DataPointer;
 537
 538      DataSize=255;
 539          RegQueryValueExA(hPrinterSettings, "Port", NULL, &DataType,
 540                                         Data, &DataSize);
 541          lpPInfo5->pPortName = &lpbPrinters[*dwNextStringPos];
 542      *dwNextStringPos += DataSize+1;
 543          if (*dwNextStringPos > dwBufSize)
 544                 bCalcSpaceOnly=TRUE;
 545          if (bCalcSpaceOnly==FALSE)
 546          strcpy(lpPInfo5->pPortName, Data);
 547     }
 548
 549  if (lpszPrinterSettings)
 550          free(lpszPrinterSettings);
 551
 552  return(bCalcSpaceOnly);
 553 }
 554
 555
 556 /******************************************************************
 557  *              EnumPrintersA        [WINSPOOL.174]
 558  *
 559  *    Enumerates the available printers, print servers and print
 560  *    providers, depending on the specified flags, name and level.
 561  *
 562  * RETURNS:
 563  *
 564  *    If level is set to 1:
 565  *    If level is set to 2:
 566  *      Not implemented yet!
 567  *      Returns TRUE with an empty list.
 568  *
 569  *    If level is set to 4 (officially WinNT only):
 570  *              Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL).
 571  *      Fast: Only the registry is queried to retrieve printer names,
 572  *      no connection to the driver is made.
 573  *      Returns an array of PRINTER_INFO_4 data structures in the
 574  *      lpbPrinters buffer.
 575  *
 576  *    If level is set to 5 (officially WinNT4/Win9x only):
 577  *      Fast: Only the registry is queried to retrieve printer names,
 578  *      no connection to the driver is made.
 579  *      Returns an array of PRINTER_INFO_5 data structures in the
 580  *      lpbPrinters buffer.
 581  *
 582  *    If level set to 3 or 6+:
 583  *          returns zero (faillure!)
 584  *
 585  *    Returns nonzero (TRUE) on succes, or zero on faillure, use GetLastError
 586  *    for information.
 587  *
 588  * BUGS:
 589  *    - Only PRINTER_ENUM_LOCAL and PRINTER_ENUM_NAME are implemented.
 590  *    - Only level 4 and 5 are implemented at the moment.
 591  *    - 16-bit printer drivers are not enumerated.
 592  *    - returned bytes used/needed do not match the real Windoze implementation
 593  *
 594  * NOTE:
 595  *    - In a regular Wine installation, no registry settings for printers
 596  *      exist, which makes this function return an empty list.
 597  */
 598 BOOL  WINAPI EnumPrintersA(
 599                                         DWORD dwType,      /* Types of print objects to enumerate */
 600                     LPSTR lpszName,    /* name of objects to enumerate */
 601                                 DWORD dwLevel,     /* type of printer info structure */
 602                     LPBYTE lpbPrinters,/* buffer which receives info*/
 603                                 DWORD cbBuf,       /* max size of buffer in bytes */
 604                     LPDWORD lpdwNeeded,/* pointer to var: # bytes used/needed */
 605                                 LPDWORD lpdwReturned/* number of entries returned */
 606                    )
 607 {
 608  HKEY  hPrinterListKey;
 609  DWORD dwIndex=0;
 610  char  PrinterName[255];
 611  DWORD PrinterNameLength=255;
 612  FILETIME FileTime;
 613  DWORD dwNextStringPos;   /* position of next space for a string in the buffer*/
 614  DWORD dwStructPrinterInfoSize; /* size of a Printer_Info_X structure */
 615  BOOL  bCalcSpaceOnly=FALSE;/* if TRUE: don't store data, just calculate space*/
 616
 617  TRACE(print, "EnumPrintersA\n");
 618
 619  /* check for valid Flags */
 620  if (dwType != PRINTER_ENUM_LOCAL && dwType != PRINTER_ENUM_NAME)
 621         {
 622      SetLastError(ERROR_INVALID_FLAGS);
 623      return(0);
 624     }
 625  if (dwLevel == 1 || dwLevel == 2)
 626      return(TRUE);
 627  if (dwLevel != 4 && dwLevel != 5)
 628         {
 629      SetLastError(ERROR_INVALID_PARAMETER);
 630      return(0);
 631     }
 632
 633  /* zero out the data area, and initialise some returns to zero,
 634   * to prevent problems
 635  */
 636 {
 637   int i;
 638   for (i=0; i<cbBuf; i++)
 639           lpbPrinters[i]=0;
 640  }
 641     *lpdwReturned=0;
 642     *lpdwNeeded = 0;
 643
 644  /* get a pointer to a list of all printer names in the registry */
 645  if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, Printers, 0, KEY_READ,
 646                                   &hPrinterListKey) !=ERROR_SUCCESS)
 647         {
 648      /* Oh no! An empty list of printers!
 649       * (which is a valid configuration anyway)
 650       */
 651      TRACE(print, "No entries in the Printers part of the registry\n");
 652      return(TRUE);
 653     }
 654
 655  /* count the number of entries and check if it fits in the buffer
 656   */
 657  while(RegEnumKeyExA(hPrinterListKey, dwIndex, PrinterName, &PrinterNameLength,
 658                    NULL, NULL, NULL, &FileTime)==ERROR_SUCCESS)
 659     {
 660      PrinterNameLength=255;
 661      dwIndex++;
 662     }
 663  *lpdwReturned = dwIndex;
 664  switch(dwLevel)
 665         {
 666      case 1:
 667         dwStructPrinterInfoSize = sizeof(PRINTER_INFO_1A);
 668         break;
 669      case 2:
 670         dwStructPrinterInfoSize = sizeof(PRINTER_INFO_2A);
 671         break;
 672      case 4:
 673         dwStructPrinterInfoSize = sizeof(PRINTER_INFO_4A);
 674         break;
 675      case 5:
 676         dwStructPrinterInfoSize = sizeof(PRINTER_INFO_5A);
 677         break;
 678      default:
 679         dwStructPrinterInfoSize = 0;
 680         break;
 681     }
 682  if (dwIndex*dwStructPrinterInfoSize+1 > cbBuf)
 683         bCalcSpaceOnly = TRUE;
 684
 685  /* the strings which contain e.g. PrinterName, PortName, etc,
 686   * are also stored in lpbPrinters, but after the regular structs.
 687   * dwNextStringPos will always point to the next free place for a
 688   * string.
 689   */
 690  dwNextStringPos=(dwIndex+1)*dwStructPrinterInfoSize;
 691
 692  /* check each entry: if OK, add to list in corresponding INFO .
 693   */
 694  for(dwIndex=0; dwIndex < *lpdwReturned; dwIndex++)
 695     {
 696      PrinterNameLength=255;
 697      if (RegEnumKeyExA(hPrinterListKey, dwIndex, PrinterName, &PrinterNameLength,
 698                    NULL, NULL, NULL, &FileTime)!=ERROR_SUCCESS)
 699         break;  /* exit for loop*/
 700
 701      /* check whether this printer is allowed in the list
 702       * by comparing name to lpszName
 703       */
 704      if (dwType == PRINTER_ENUM_NAME)
 705         if (strcmp(PrinterName,lpszName)!=0)
 706                 continue;
 707
 708      switch(dwLevel)
 709         {
 710          case 1:
 711                 /* FIXME: unimplemented */
 712             break;
 713          case 2:
 714             /* FIXME: unimplemented */
 715             break;
 716          case 4:
 717             bCalcSpaceOnly = ENUMPRINTERS_AddInfo4A(PrinterName, lpbPrinters,
 718                                                 dwIndex*dwStructPrinterInfoSize,
 719                                 &dwNextStringPos, cbBuf, bCalcSpaceOnly);
 720             break;
 721          case 5:
 722             bCalcSpaceOnly = ENUMPRINTERS_AddInfo5A(PrinterName, lpbPrinters,
 723                                                 dwIndex*dwStructPrinterInfoSize,
 724                                 &dwNextStringPos, cbBuf, bCalcSpaceOnly);
 725             break;
 726         }
 727     }
 728  RegCloseKey(hPrinterListKey);
 729  *lpdwNeeded = dwNextStringPos;
 730
 731  if (bCalcSpaceOnly==TRUE)
 732         {
 733           int i;
 734           for (i=0; i<cbBuf; i++)
 735                   lpbPrinters[i]=0;
 736      *lpdwReturned=0;
 737     }
 738
 739  return(TRUE);
 740 }
 741
 742 /******************************************************************
 743  *              EnumPrinters32W        [WINSPOOL.175]
 744  *
 745  */
 746 BOOL  WINAPI EnumPrintersW(DWORD dwType, LPWSTR lpszName,
 747                                DWORD dwLevel, LPBYTE lpbPrinters,
 748                                DWORD cbBuf, LPDWORD lpdwNeeded,
 749                                LPDWORD lpdwReturned)
 750 {
 751     FIXME(print,"Nearly empty stub\n");
 752     *lpdwReturned=0;
 753     *lpdwNeeded = 0;
 754     return TRUE;
 755 }
 756
 757 /******************************************************************
 758  *              AddMonitor32A        [WINSPOOL.107]
 759  *
 760  */
 761 BOOL WINAPI AddMonitorA(LPCSTR pName, DWORD Level, LPBYTE pMonitors)
 762 {
 763     FIXME(print, "(%s,%lx,%p):stub!\n", pName, Level, pMonitors);
 764     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 765     return FALSE;
 766 }
 767
 768 /******************************************************************
 769  *              DeletePrinterDriver32A        [WINSPOOL.146]
 770  *
 771  */
 772 BOOL WINAPI
 773 DeletePrinterDriverA (LPSTR pName, LPSTR pEnvironment, LPSTR pDriverName)
 774 {
 775     FIXME(print,"(%s,%s,%s):stub\n",debugstr_a(pName),debugstr_a(pEnvironment),
 776           debugstr_a(pDriverName));
 777     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 778     return FALSE;
 779 }
 780
 781
 782 /******************************************************************
 783  *              DeleteMonitor32A        [WINSPOOL.135]
 784  *
 785  */
 786 BOOL WINAPI
 787 DeleteMonitorA (LPSTR pName, LPSTR pEnvironment, LPSTR pMonitorName)
 788 {
 789     FIXME(print,"(%s,%s,%s):stub\n",debugstr_a(pName),debugstr_a(pEnvironment),
 790           debugstr_a(pMonitorName));
 791     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 792     return FALSE;
 793 }
 794
 795
 796 /******************************************************************
 797  *              DeletePort32A        [WINSPOOL.137]
 798  *
 799  */
 800 BOOL WINAPI
 801 DeletePortA (LPSTR pName, HWND hWnd, LPSTR pPortName)
 802 {
 803     FIXME(print,"(%s,0x%08x,%s):stub\n",debugstr_a(pName),hWnd,
 804           debugstr_a(pPortName));
 805     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 806     return FALSE;
 807 }
 808
 809 /******************************************************************************
 810  *    SetPrinter32W  [WINSPOOL.214]
 811  */
 812 BOOL WINAPI
 813 SetPrinterW(
 814   HANDLE  hPrinter,
 815   DWORD     Level,
 816   LPBYTE    pPrinter,
 817   DWORD     Command) {
 818
 819        FIXME(print,"():stub\n");
 820   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 821        return FALSE;
 822 }
 823
 824 /******************************************************************************
 825  *    WritePrinter32  [WINSPOOL.223]
 826  */
 827 BOOL WINAPI
 828 WritePrinter(
 829   HANDLE  hPrinter,
 830   LPVOID  pBuf,
 831   DWORD   cbBuf,
 832   LPDWORD pcWritten) {
 833
 834        FIXME(print,"():stub\n");
 835   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 836        return FALSE;
 837 }
 838
 839 /*****************************************************************************
 840  *          AddForm32A  [WINSPOOL.103]
 841  */
 842 BOOL WINAPI AddFormA(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
 843 {
 844     FIXME(print, "(%d,%ld,%p): stub\n", hPrinter, Level, pForm);
 845     return 1;
 846 }
 847
 848 /*****************************************************************************
 849  *          AddForm32W  [WINSPOOL.104]
 850  */
 851 BOOL WINAPI AddFormW(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
 852 {
 853     FIXME(print, "(%d,%ld,%p): stub\n", hPrinter, Level, pForm);
 854     return 1;
 855 }
 856
 857 /*****************************************************************************
 858  *          AddJob32A  [WINSPOOL.105]
 859  */
 860 BOOL WINAPI AddJobA(HANDLE hPrinter, DWORD Level, LPBYTE pData,
 861                         DWORD cbBuf, LPDWORD pcbNeeded)
 862 {
 863     FIXME(print, "(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pData, cbBuf,
 864           pcbNeeded);
 865     return 1;
 866 }
 867
 868 /*****************************************************************************
 869  *          AddJob32W  [WINSPOOL.106]
 870  */
 871 BOOL WINAPI AddJobW(HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf,
 872                         LPDWORD pcbNeeded)
 873 {
 874     FIXME(print, "(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pData, cbBuf,
 875           pcbNeeded);
 876     return 1;
 877 }
 878
 879 /*****************************************************************************
 880  *          AddPrinter32A  [WINSPOOL.117]
 881  */
 882 HANDLE WINAPI AddPrinterA(LPSTR pName, DWORD Level, LPBYTE pPrinter)
 883 {
 884     FIXME(print, "(%s,%ld,%p): stub\n", pName, Level, pPrinter);
 885     return 0;
 886 }
 887
 888 /*****************************************************************************
 889  *          AddPrinter32W  [WINSPOOL.122]
 890  */
 891 HANDLE WINAPI AddPrinterW(LPWSTR pName, DWORD Level, LPBYTE pPrinter)
 892 {
 893     FIXME(print, "(%p,%ld,%p): stub\n", pName, Level, pPrinter);
 894     return 0;
 895 }
 896
 897
 898 /*****************************************************************************
 899  *          ClosePrinter32  [WINSPOOL.126]
 900  */
 901 BOOL WINAPI ClosePrinter(HANDLE hPrinter)
 902 {
 903     FIXME(print, "(%d): stub\n", hPrinter);
 904     return 1;
 905 }
 906
 907 /*****************************************************************************
 908  *          DeleteForm32A  [WINSPOOL.133]
 909  */
 910 BOOL WINAPI DeleteFormA(HANDLE hPrinter, LPSTR pFormName)
 911 {
 912     FIXME(print, "(%d,%s): stub\n", hPrinter, pFormName);
 913     return 1;
 914 }
 915
 916 /*****************************************************************************
 917  *          DeleteForm32W  [WINSPOOL.134]
 918  */
 919 BOOL WINAPI DeleteFormW(HANDLE hPrinter, LPWSTR pFormName)
 920 {
 921     FIXME(print, "(%d,%s): stub\n", hPrinter, debugstr_w(pFormName));
 922     return 1;
 923 }
 924
 925 /*****************************************************************************
 926  *          DeletePrinter32  [WINSPOOL.143]
 927  */
 928 BOOL WINAPI DeletePrinter(HANDLE hPrinter)
 929 {
 930     FIXME(print, "(%d): stub\n", hPrinter);
 931     return 1;
 932 }
 933
 934 /*****************************************************************************
 935  *          SetPrinter32A  [WINSPOOL.211]
 936  */
 937 BOOL WINAPI SetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
 938                            DWORD Command)
 939 {
 940     FIXME(print, "(%d,%ld,%p,%ld): stub\n",hPrinter,Level,pPrinter,Command);
 941     return FALSE;
 942 }
 943
 944 /*****************************************************************************
 945  *          SetJob32A  [WINSPOOL.209]
 946  */
 947 BOOL WINAPI SetJobA(HANDLE hPrinter, DWORD JobId, DWORD Level,
 948                        LPBYTE pJob, DWORD Command)
 949 {
 950     FIXME(print, "(%d,%ld,%ld,%p,%ld): stub\n",hPrinter,JobId,Level,pJob,
 951          Command);
 952     return FALSE;
 953 }
 954
 955 /*****************************************************************************
 956  *          SetJob32W  [WINSPOOL.210]
 957  */
 958 BOOL WINAPI SetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level,
 959                        LPBYTE pJob, DWORD Command)
 960 {
 961     FIXME(print, "(%d,%ld,%ld,%p,%ld): stub\n",hPrinter,JobId,Level,pJob,
 962          Command);
 963     return FALSE;
 964 }
 965
 966 /*****************************************************************************
 967  *          GetForm32A  [WINSPOOL.181]
 968  */
 969 BOOL WINAPI GetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
 970                  LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
 971 {
 972     FIXME(print, "(%d,%s,%ld,%p,%ld,%p): stub\n",hPrinter,pFormName,
 973          Level,pForm,cbBuf,pcbNeeded);
 974     return FALSE;
 975 }
 976
 977 /*****************************************************************************
 978  *          GetForm32W  [WINSPOOL.182]
 979  */
 980 BOOL WINAPI GetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
 981                  LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
 982 {
 983     FIXME(print, "(%d,%s,%ld,%p,%ld,%p): stub\n",hPrinter,
 984           debugstr_w(pFormName),Level,pForm,cbBuf,pcbNeeded);
 985     return FALSE;
 986 }
 987
 988 /*****************************************************************************
 989  *          SetForm32A  [WINSPOOL.207]
 990  */
 991 BOOL WINAPI SetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
 992                         LPBYTE pForm)
 993 {
 994     FIXME(print, "(%d,%s,%ld,%p): stub\n",hPrinter,pFormName,Level,pForm);
 995     return FALSE;
 996 }
 997
 998 /*****************************************************************************
 999  *          SetForm32W  [WINSPOOL.208]
1000  */
1001 BOOL WINAPI SetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
1002                         LPBYTE pForm)
1003 {
1004     FIXME(print, "(%d,%p,%ld,%p): stub\n",hPrinter,pFormName,Level,pForm);
1005     return FALSE;
1006 }
1007
1008 /*****************************************************************************
1009  *          ReadPrinter32  [WINSPOOL.202]
1010  */
1011 BOOL WINAPI ReadPrinter(HANDLE hPrinter, LPVOID pBuf, DWORD cbBuf,
1012                            LPDWORD pNoBytesRead)
1013 {
1014     FIXME(print, "(%d,%p,%ld,%p): stub\n",hPrinter,pBuf,cbBuf,pNoBytesRead);
1015     return FALSE;
1016 }
1017
1018 /*****************************************************************************
1019  *          ResetPrinter32A  [WINSPOOL.203]
1020  */
1021 BOOL WINAPI ResetPrinterA(HANDLE hPrinter, LPPRINTER_DEFAULTSA pDefault)
1022 {
1023     FIXME(print, "(%d, %p): stub\n", hPrinter, pDefault);
1024     return FALSE;
1025 }
1026
1027 /*****************************************************************************
1028  *          ResetPrinter32W  [WINSPOOL.204]
1029  */
1030 BOOL WINAPI ResetPrinterW(HANDLE hPrinter, LPPRINTER_DEFAULTSW pDefault)
1031 {
1032     FIXME(print, "(%d, %p): stub\n", hPrinter, pDefault);
1033     return FALSE;
1034 }
1035
1036 /*****************************************************************************
1037  *          GetPrinter32A  [WINSPOOL.187]
1038  */
1039 BOOL WINAPI GetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1040                     DWORD cbBuf, LPDWORD pcbNeeded)
1041 {
1042     FIXME(print, "(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pPrinter,
1043          cbBuf, pcbNeeded);
1044     return FALSE;
1045 }
1046
1047 /*****************************************************************************
1048  *          GetPrinter32W  [WINSPOOL.194]
1049  */
1050 BOOL WINAPI GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1051                     DWORD cbBuf, LPDWORD pcbNeeded)
1052 {
1053     FIXME(print, "(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pPrinter,
1054           cbBuf, pcbNeeded);
1055     return FALSE;
1056 }
1057
1058 /*****************************************************************************
1059  *          GetPrinterDriver32A  [WINSPOOL.190]
1060  */
1061 BOOL WINAPI GetPrinterDriverA(HANDLE hPrinter, LPSTR pEnvironment,
1062                                  DWORD Level, LPBYTE pDriverInfo,
1063                                  DWORD cbBuf, LPDWORD pcbNeeded)
1064 {
1065     FIXME(print, "(%d,%s,%ld,%p,%ld,%p): stub\n",hPrinter,pEnvironment,
1066          Level,pDriverInfo,cbBuf, pcbNeeded);
1067     return FALSE;
1068 }
1069
1070 /*****************************************************************************
1071  *          GetPrinterDriver32W  [WINSPOOL.193]
1072  */
1073 BOOL WINAPI GetPrinterDriverW(HANDLE hPrinter, LPWSTR pEnvironment,
1074                                   DWORD Level, LPBYTE pDriverInfo,
1075                                   DWORD cbBuf, LPDWORD pcbNeeded)
1076 {
1077     FIXME(print, "(%d,%p,%ld,%p,%ld,%p): stub\n",hPrinter,pEnvironment,
1078           Level,pDriverInfo,cbBuf, pcbNeeded);
1079     return FALSE;
1080 }
1081 /*****************************************************************************
1082  *          AddPrinterDriver32A  [WINSPOOL.120]
1083  */
1084 BOOL WINAPI AddPrinterDriverA(LPSTR printerName,DWORD level,
1085                                    LPBYTE pDriverInfo)
1086 {
1087     FIXME(print, "(%s,%ld,%p): stub\n",printerName,level,pDriverInfo);
1088     return FALSE;
1089 }
1090 /*****************************************************************************
1091  *          AddPrinterDriver32W  [WINSPOOL.121]
1092  */
1093 BOOL WINAPI AddPrinterDriverW(LPWSTR printerName,DWORD level,
1094                                    LPBYTE pDriverInfo)
1095 {
1096     FIXME(print, "(%s,%ld,%p): stub\n",debugstr_w(printerName),
1097           level,pDriverInfo);
1098     return FALSE;
1099 }
1100
1101
1102