?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Authors: Chris Morgan <cmorgan@wpi.edu>, James Abbatiello <abbeyj@wpi.edu>
[wine.git] / dlls / winspool / info.c
blob183d877a1037629e7563a9b6e5da6a55731ae948
1 /*
2 * WINSPOOL functions
3 *
4 * Copyright 1996 John Harvey
5 * Copyright 1998 Andreas Mohr
6 * Copyright 1999 Klaas van Gend
7 */
8
9 #include <stdlib.h>
10 #include <string.h>
11 #include <ctype.h>
12 #include "winspool.h"
13 #include "winbase.h"
14 #include "winerror.h"
15 #include "winreg.h"
16 #include "debugtools.h"
17 #include "heap.h"
18
19 DEFAULT_DEBUG_CHANNEL(winspool)
20
21 CRITICAL_SECTION PRINT32_RegistryBlocker;
22
23 #define NUM_PRINTER_MAX 10
24
25 typedef struct _OPENEDPRINTERA
26 {
27 LPSTR lpsPrinterName;
28 HANDLE hPrinter;
29 LPPRINTER_DEFAULTSA lpDefault;
30 } OPENEDPRINTERA, *LPOPENEDPRINTERA;
31
32
33 /* Initialize the structure OpenedPrinter Table */
34 static OPENEDPRINTERA OpenedPrinterTableA[NUM_PRINTER_MAX] =
35 {
36 {NULL, -1, NULL},
37 {NULL, -1, NULL},
38 {NULL, -1, NULL},
39 {NULL, -1, NULL},
40 {NULL, -1, NULL},
41 {NULL, -1, NULL},
42 {NULL, -1, NULL},
43 {NULL, -1, NULL},
44 {NULL, -1, NULL},
45 {NULL, -1, NULL}
46 };
47
48 static char Printers[] =
49 "System\\CurrentControlSet\\control\\Print\\Printers\\";
50 static char Drivers[] =
51 "System\\CurrentControlSet\\control\\Print\\Environments\\Wine\\Drivers\\";
52
53
54 /******************************************************************
55 * WINSPOOL_GetOpenedPrinterEntryA
56 * Get the first place empty in the opened printer table
57 */
58 static LPOPENEDPRINTERA WINSPOOL_GetOpenedPrinterEntryA()
59 {
60 int i;
61 for( i=0; i< NUM_PRINTER_MAX; i++)
62 if (OpenedPrinterTableA[i].hPrinter == -1)
63 {
64 OpenedPrinterTableA[i].hPrinter = i + 1;
65 return &OpenedPrinterTableA[i];
66 }
67 return NULL;
68 }
69
70 /******************************************************************
71 * WINSPOOL_GetOpenedPrinterA
72 * Get the pointer to the opened printer referred by the handle
73 */
74 static LPOPENEDPRINTERA WINSPOOL_GetOpenedPrinterA(int printerHandle)
75 {
76 if((printerHandle <=0) || (printerHandle > (NUM_PRINTER_MAX + 1)))
77 return NULL;
78 return &OpenedPrinterTableA[printerHandle -1];
79 }
80
81 /******************************************************************
82 * DeviceCapabilities32A [WINSPOOL.151]
83 *
84 */
85 INT WINAPI DeviceCapabilitiesA(LPCSTR pDeivce,LPCSTR pPort, WORD cap,
86 LPSTR pOutput, LPDEVMODEA lpdm)
87 {
88 return GDI_CallDeviceCapabilities16(pDeivce, pPort, cap, pOutput, lpdm);
89
90 }
91
92
93 /*****************************************************************************
94 * DeviceCapabilities32W
95 */
96 INT WINAPI DeviceCapabilitiesW(LPCWSTR pDevice, LPCWSTR pPort,
97 WORD fwCapability, LPWSTR pOutput,
98 const DEVMODEW *pDevMode)
99 {
100 FIXME("(%p,%p,%d,%p,%p): stub\n",
101 pDevice, pPort, fwCapability, pOutput, pDevMode);
102 return -1;
103 }
104
105 /******************************************************************
106 * DocumentProperties32A [WINSPOOL.155]
107 *
108 */
109 LONG WINAPI DocumentPropertiesA(HWND hWnd,HANDLE hPrinter,
110 LPSTR pDeviceName, LPDEVMODEA pDevModeOutput,
111 LPDEVMODEA pDevModeInput,DWORD fMode )
112 {
113 LPOPENEDPRINTERA lpOpenedPrinter;
114 LPSTR lpName = pDeviceName;
115
116 TRACE("(%d,%d,%s,%p,%p,%ld)\n",
117 hWnd,hPrinter,pDeviceName,pDevModeOutput,pDevModeInput,fMode
118 );
119
120 if(!pDeviceName) {
121 lpOpenedPrinter = WINSPOOL_GetOpenedPrinterA(hPrinter);
122 if(!lpOpenedPrinter) {
123 SetLastError(ERROR_INVALID_HANDLE);
124 return -1;
125 }
126 lpName = lpOpenedPrinter->lpsPrinterName;
127 }
128
129 return GDI_CallExtDeviceMode16(hWnd, pDevModeOutput, lpName, NULL,
130 pDevModeInput, NULL, fMode);
131
132 }
133
134
135 /*****************************************************************************
136 * DocumentProperties32W
137 */
138 LONG WINAPI DocumentPropertiesW(HWND hWnd, HANDLE hPrinter,
139 LPWSTR pDeviceName,
140 LPDEVMODEW pDevModeOutput,
141 LPDEVMODEW pDevModeInput, DWORD fMode)
142 {
143 FIXME("(%d,%d,%s,%p,%p,%ld): stub\n",
144 hWnd,hPrinter,debugstr_w(pDeviceName),pDevModeOutput,pDevModeInput,
145 fMode);
146 return -1;
147 }
148
149
150 /******************************************************************
151 * OpenPrinter32A [WINSPOOL.196]
152 *
153 */
154 BOOL WINAPI OpenPrinterA(LPSTR lpPrinterName,HANDLE *phPrinter,
155 LPPRINTER_DEFAULTSA pDefault)
156 {
157 /* Not implemented: use the DesiredAccess of pDefault to set
158 the access rights to the printer */
159
160 LPOPENEDPRINTERA lpOpenedPrinter;
161
162 TRACE("(printerName: %s, pDefault %p\n", lpPrinterName, pDefault);
163
164 /* Get a place in the opened printer buffer*/
165 lpOpenedPrinter = WINSPOOL_GetOpenedPrinterEntryA();
166
167 if((lpOpenedPrinter != NULL) && (lpPrinterName !=NULL) &&
168 (phPrinter != NULL))
169 {
170 /* Get the name of the printer */
171 lpOpenedPrinter->lpsPrinterName =
172 HeapAlloc(GetProcessHeap(), 0, lstrlenA(lpPrinterName));
173 lstrcpyA(lpOpenedPrinter->lpsPrinterName, lpPrinterName);
174
175 /* Get the unique handle of the printer*/
176 *phPrinter = lpOpenedPrinter->hPrinter;
177
178 if (pDefault != NULL)
179 {
180 /* Allocate enough memory for the lpDefault structure */
181 lpOpenedPrinter->lpDefault =
182 HeapAlloc(GetProcessHeap(), 0, sizeof(PRINTER_DEFAULTSA));
183 lpOpenedPrinter->lpDefault->pDevMode =
184 HeapAlloc(GetProcessHeap(), 0, sizeof(DEVMODEA));
185 lpOpenedPrinter->lpDefault->pDatatype =
186 HeapAlloc(GetProcessHeap(), 0, lstrlenA(pDefault->pDatatype));
187
188 /*Copy the information from incoming parameter*/
189 memcpy(lpOpenedPrinter->lpDefault->pDevMode, pDefault->pDevMode,
190 sizeof(DEVMODEA));
191 lstrcpyA(lpOpenedPrinter->lpDefault->pDatatype,
192 pDefault->pDatatype);
193 lpOpenedPrinter->lpDefault->DesiredAccess =
194 pDefault->DesiredAccess;
195 }
196
197 return TRUE;
198 }
199
200 if(lpOpenedPrinter == NULL)
201 FIXME("Reach the OpenedPrinterTable maximum, augment this max.\n");
202 return FALSE;
203 }
204
205 /******************************************************************
206 * OpenPrinter32W [WINSPOOL.197]
207 *
208 */
209 BOOL WINAPI OpenPrinterW(LPWSTR lpPrinterName,HANDLE *phPrinter,
210 LPPRINTER_DEFAULTSW pDefault)
211 {
212 FIXME("(%s,%p,%p):stub\n",debugstr_w(lpPrinterName), phPrinter,
213 pDefault);
214 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
215 return FALSE;
216 }
217
218
219
220
221 /******************************************************************
222 * ENUMPRINTERS_GetDWORDFromRegistryA internal
223 *
224 * Reads a DWORD from registry KeyName
225 *
226 * RETURNS
227 * value on OK or NULL on error
228 */
229 DWORD ENUMPRINTERS_GetDWORDFromRegistryA(
230 HKEY hPrinterSettings, /* handle to registry key */
231 LPSTR KeyName /* name key to retrieve string from*/
232 ){
233 DWORD DataSize=8;
234 DWORD DataType;
235 BYTE Data[8];
236 DWORD Result=684;
237
238 if (RegQueryValueExA(hPrinterSettings, KeyName, NULL, &DataType,
239 Data, &DataSize)!=ERROR_SUCCESS)
240 FIXME("Query of register didn't succeed?\n");
241 if (DataType == REG_DWORD_LITTLE_ENDIAN)
242 Result = Data[0] + (Data[1]<<8) + (Data[2]<<16) + (Data[3]<<24);
243 if (DataType == REG_DWORD_BIG_ENDIAN)
244 Result = Data[3] + (Data[2]<<8) + (Data[1]<<16) + (Data[0]<<24);
245 return(Result);
246 }
247
248
249 /******************************************************************
250 * ENUMPRINTERS_AddStringFromRegistryA internal
251 *
252 * Reads a string from registry KeyName and writes it at
253 * lpbPrinters[dwNextStringPos]. Store reference to string in Dest.
254 *
255 * RETURNS
256 * FALSE if there is still space left in the buffer.
257 */
258 BOOL ENUMPRINTERS_AddStringFromRegistryA(
259 HKEY hPrinterSettings, /* handle to registry key */
260 LPSTR KeyName, /* name key to retrieve string from*/
261 LPSTR* Dest, /* pointer to write string addres to */
262 LPBYTE lpbPrinters, /* buffer which receives info*/
263 LPDWORD dwNextStringPos, /* pos in buffer for next string */
264 DWORD dwBufSize, /* max size of buffer in bytes */
265 BOOL bCalcSpaceOnly /* TRUE if out-of-space in buffer */
266 ){
267 DWORD DataSize=34;
268 DWORD DataType;
269 LPSTR Data = (LPSTR) malloc(DataSize*sizeof(char));
270
271 while(RegQueryValueExA(hPrinterSettings, KeyName, NULL, &DataType,
272 Data, &DataSize)==ERROR_MORE_DATA)
273 {
274 Data = (LPSTR) realloc(Data, DataSize+2);
275 }
276
277 if (DataType == REG_SZ)
278 {
279 if (bCalcSpaceOnly==FALSE)
280 *Dest = &lpbPrinters[*dwNextStringPos];
281 *dwNextStringPos += DataSize+1;
282 if (*dwNextStringPos > dwBufSize)
283 bCalcSpaceOnly=TRUE;
284 if (bCalcSpaceOnly==FALSE)
285 {
286 if (DataSize==0) /* DataSize = 0 means empty string, even though*/
287 *Dest[0]=0; /* the data itself needs not to be empty */
288 else
289 strcpy(*Dest, Data);
290 }
291 }
292 else
293 WARN("Expected string setting, got something else from registry");
294
295 if (Data)
296 free(Data);
297 return(bCalcSpaceOnly);
298 }
299
300
301
302 /******************************************************************
303 * ENUMPRINTERS_AddInfo2A internal
304 *
305 * Creates a PRINTER_INFO_2A structure at: lpbPrinters[dwNextStructPos]
306 * for printer PrinterNameKey.
307 * Note that there is no check whether the information really fits!
308 *
309 * RETURNS
310 * FALSE if there is still space left in the buffer.
311 *
312 * BUGS:
313 * This function should not only read the registry but also ask the driver
314 * for information.
315 */
316 BOOL ENUMPRINTERS_AddInfo2A(
317 LPSTR lpszPrinterName,/* name of printer to fill struct for*/
318 LPBYTE lpbPrinters, /* buffer which receives info*/
319 DWORD dwNextStructPos, /* pos in buffer for struct */
320 LPDWORD dwNextStringPos, /* pos in buffer for next string */
321 DWORD dwBufSize, /* max size of buffer in bytes */
322 BOOL bCalcSpaceOnly /* TRUE if out-of-space in buffer */
323 ){
324 HKEY hPrinterSettings;
325 DWORD DevSize=0;
326 DWORD DataType;
327 LPSTR lpszPrinterSettings = (LPSTR) malloc(strlen(Printers)+
328 strlen(lpszPrinterName)+2);
329 LPPRINTER_INFO_2A lpPInfo2 = (LPPRINTER_INFO_2A) &lpbPrinters[dwNextStructPos];
330
331 /* open the registry to find the attributes, etc of the printer */
332 if (lpszPrinterSettings!=NULL)
333 {
334 strcpy(lpszPrinterSettings,Printers);
335 strcat(lpszPrinterSettings,lpszPrinterName);
336 }
337 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, lpszPrinterSettings, 0,
338 KEY_READ, &hPrinterSettings) != ERROR_SUCCESS)
339 {
340 WARN("The registry did not contain my printer anymore?\n");
341 }
342 else
343 {
344 if (bCalcSpaceOnly==FALSE)
345 lpPInfo2->pServerName = NULL;
346 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
347 "Name", &(lpPInfo2->pPrinterName),
348 lpbPrinters, dwNextStringPos,
349 dwBufSize, bCalcSpaceOnly);
350 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
351 "Share Name", &(lpPInfo2->pShareName),
352 lpbPrinters, dwNextStringPos,
353 dwBufSize, bCalcSpaceOnly);
354 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
355 "Port", &(lpPInfo2->pPortName),
356 lpbPrinters, dwNextStringPos,
357 dwBufSize, bCalcSpaceOnly);
358 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
359 "Printer Driver", &(lpPInfo2->pDriverName),
360 lpbPrinters, dwNextStringPos,
361 dwBufSize, bCalcSpaceOnly);
362 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
363 "Description", &(lpPInfo2->pComment),
364 lpbPrinters, dwNextStringPos,
365 dwBufSize, bCalcSpaceOnly);
366 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
367 "Location", &(lpPInfo2->pLocation),
368 lpbPrinters, dwNextStringPos,
369 dwBufSize, bCalcSpaceOnly);
370
371 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
372 "Separator File", &(lpPInfo2->pSepFile),
373 lpbPrinters, dwNextStringPos,
374 dwBufSize, bCalcSpaceOnly);
375 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
376 "Print Processor", &(lpPInfo2->pPrintProcessor),
377 lpbPrinters, dwNextStringPos,
378 dwBufSize, bCalcSpaceOnly);
379 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
380 "Datatype", &(lpPInfo2->pDatatype),
381 lpbPrinters, dwNextStringPos,
382 dwBufSize, bCalcSpaceOnly);
383 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
384 "Parameters", &(lpPInfo2->pParameters),
385 lpbPrinters, dwNextStringPos,
386 dwBufSize, bCalcSpaceOnly);
387 if (bCalcSpaceOnly == FALSE)
388 {
389 lpPInfo2->pSecurityDescriptor = NULL; /* EnumPrinters doesn't return this*/
390
391 /* FIXME: Attributes gets LOCAL as no REMOTE exists*/
392 lpPInfo2->Attributes = ENUMPRINTERS_GetDWORDFromRegistryA(hPrinterSettings,
393 "Attributes") +PRINTER_ATTRIBUTE_LOCAL;
394 lpPInfo2->Priority = ENUMPRINTERS_GetDWORDFromRegistryA(hPrinterSettings,
395 "Priority");
396 lpPInfo2->DefaultPriority = ENUMPRINTERS_GetDWORDFromRegistryA(
397 hPrinterSettings, "Default Priority");
398 lpPInfo2->StartTime = ENUMPRINTERS_GetDWORDFromRegistryA(hPrinterSettings,
399 "StartTime");
400 lpPInfo2->UntilTime = ENUMPRINTERS_GetDWORDFromRegistryA(hPrinterSettings,
401 "UntilTime");
402 lpPInfo2->Status = ENUMPRINTERS_GetDWORDFromRegistryA(hPrinterSettings,
403 "Status");
404 lpPInfo2->cJobs = 0; /* FIXME: according to MSDN, this does not
405 * reflect the TotalJobs Key ??? */
406 lpPInfo2->AveragePPM = 0; /* FIXME: according to MSDN, this does not
407 * reflect the TotalPages Key ??? */
408
409 /* and read the devModes structure... */
410 RegQueryValueExA(hPrinterSettings, "pDevMode", NULL, &DataType,
411 NULL, &DevSize); /* should return ERROR_MORE_DATA */
412 lpPInfo2->pDevMode = (LPDEVMODEA) &lpbPrinters[*dwNextStringPos];
413 *dwNextStringPos += DevSize + 1;
414 }
415 if (*dwNextStringPos > dwBufSize)
416 bCalcSpaceOnly=TRUE;
417 if (bCalcSpaceOnly==FALSE)
418 RegQueryValueExA(hPrinterSettings, "pDevMode", NULL, &DataType,
419 (LPBYTE)lpPInfo2->pDevMode, &DevSize);
420 }
421
422 if (lpszPrinterSettings)
423 free(lpszPrinterSettings);
424
425 return(bCalcSpaceOnly);
426 }
427
428 /******************************************************************
429 * ENUMPRINTERS_AddInfo4A internal
430 *
431 * Creates a PRINTER_INFO_4A structure at: lpbPrinters[dwNextStructPos]
432 * for printer PrinterNameKey.
433 * Note that there is no check whether the information really fits!
434 *
435 * RETURNS
436 * FALSE if there is still space left in the buffer.
437 *
438 * BUGS:
439 * This function should not exist in Win95 mode, but does anyway.
440 */
441 BOOL ENUMPRINTERS_AddInfo4A(
442 LPSTR lpszPrinterName,/* name of printer to fill struct for*/
443 LPBYTE lpbPrinters, /* buffer which receives info*/
444 DWORD dwNextStructPos, /* pos in buffer for struct */
445 LPDWORD dwNextStringPos, /* pos in buffer for next string */
446 DWORD dwBufSize, /* max size of buffer in bytes */
447 BOOL bCalcSpaceOnly /* TRUE if out-of-space in buffer */
448 ){
449 HKEY hPrinterSettings;
450 LPSTR lpszPrinterSettings = (LPSTR) malloc(strlen(Printers)+
451 strlen(lpszPrinterName)+2);
452 LPPRINTER_INFO_4A lpPInfo4 = (LPPRINTER_INFO_4A) &lpbPrinters[dwNextStructPos];
453
454 /* open the registry to find the attributes of the printer */
455 if (lpszPrinterSettings!=NULL)
456 {
457 strcpy(lpszPrinterSettings,Printers);
458 strcat(lpszPrinterSettings,lpszPrinterName);
459 }
460 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, lpszPrinterSettings, 0,
461 KEY_READ, &hPrinterSettings) != ERROR_SUCCESS)
462 {
463 WARN("The registry did not contain my printer anymore?\n");
464 }
465 else
466 {
467 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
468 "Name", &(lpPInfo4->pPrinterName),
469 lpbPrinters, dwNextStringPos,
470 dwBufSize, bCalcSpaceOnly);
471 /* FIXME: Attributes gets LOCAL as no REMOTE exists*/
472 if (bCalcSpaceOnly==FALSE)
473 lpPInfo4->Attributes = ENUMPRINTERS_GetDWORDFromRegistryA(hPrinterSettings,
474 "Attributes") +PRINTER_ATTRIBUTE_LOCAL;
475 }
476 if (lpszPrinterSettings)
477 free(lpszPrinterSettings);
478
479 return(bCalcSpaceOnly);
480 }
481
482 /******************************************************************
483 * ENUMPRINTERS_AddInfo5A internal
484 *
485 * Creates a PRINTER_INFO_5A structure at: lpbPrinters[dwNextStructPos]
486 * for printer PrinterNameKey.
487 * Settings are read from the registry.
488 * Note that there is no check whether the information really fits!
489 * RETURNS
490 * FALSE if there is still space left in the buffer.
491 */
492 BOOL ENUMPRINTERS_AddInfo5A(
493 LPSTR lpszPrinterName,/* name of printer to fill struct for*/
494 LPBYTE lpbPrinters, /* buffer which receives info*/
495 DWORD dwNextStructPos, /* pos in buffer for struct */
496 LPDWORD dwNextStringPos, /* pos in buffer for next string */
497 DWORD dwBufSize, /* max size of buffer in bytes */
498 BOOL bCalcSpaceOnly /* TRUE if out-of-space in buffer */
499 ){
500 HKEY hPrinterSettings;
501 LPSTR lpszPrinterSettings = (LPSTR) malloc(strlen(Printers)+
502 strlen(lpszPrinterName)+2);
503 LPPRINTER_INFO_5A lpPInfo5 = (LPPRINTER_INFO_5A) &lpbPrinters[dwNextStructPos];
504
505 /* open the registry to find the attributes, etc of the printer */
506 if (lpszPrinterSettings!=NULL)
507 {
508 strcpy(lpszPrinterSettings,Printers);
509 strcat(lpszPrinterSettings,lpszPrinterName);
510 }
511 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, lpszPrinterSettings, 0,
512 KEY_READ, &hPrinterSettings) != ERROR_SUCCESS)
513 {
514 WARN("The registry did not contain my printer anymore?\n");
515 }
516 else
517 {
518 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
519 "Name", &(lpPInfo5->pPrinterName),
520 lpbPrinters, dwNextStringPos,
521 dwBufSize, bCalcSpaceOnly);
522 bCalcSpaceOnly = ENUMPRINTERS_AddStringFromRegistryA(hPrinterSettings,
523 "Port", &(lpPInfo5->pPortName), lpbPrinters,
524 dwNextStringPos, dwBufSize, bCalcSpaceOnly);
525 /* FIXME: Attributes gets LOCAL as no REMOTE exists*/
526 if (bCalcSpaceOnly == FALSE)
527 {
528 lpPInfo5->Attributes = ENUMPRINTERS_GetDWORDFromRegistryA(hPrinterSettings,
529 "Attributes") +PRINTER_ATTRIBUTE_LOCAL;
530 lpPInfo5->DeviceNotSelectedTimeOut
531 = ENUMPRINTERS_GetDWORDFromRegistryA(hPrinterSettings,
532 "txTimeout");
533 lpPInfo5->TransmissionRetryTimeout
534 = ENUMPRINTERS_GetDWORDFromRegistryA(hPrinterSettings,
535 "dnsTimeout");
536 }
537 }
538
539 if (lpszPrinterSettings)
540 free(lpszPrinterSettings);
541
542 return(bCalcSpaceOnly);
543 }
544
545
546 /******************************************************************
547 * EnumPrintersA [WINSPOOL.174]
548 *
549 * Enumerates the available printers, print servers and print
550 * providers, depending on the specified flags, name and level.
551 *
552 * RETURNS:
553 *
554 * If level is set to 1:
555 * Not implemented yet!
556 * Returns TRUE with an empty list.
557 *
558 * If level is set to 2:
559 * Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
560 * Returns an array of PRINTER_INFO_2 data structures in the
561 * lpbPrinters buffer. Note that according to MSDN also an
562 * OpenPrinter should be performed on every remote printer.
563 *
564 * If level is set to 4 (officially WinNT only):
565 * Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
566 * Fast: Only the registry is queried to retrieve printer names,
567 * no connection to the driver is made.
568 * Returns an array of PRINTER_INFO_4 data structures in the
569 * lpbPrinters buffer.
570 *
571 * If level is set to 5 (officially WinNT4/Win9x only):
572 * Fast: Only the registry is queried to retrieve printer names,
573 * no connection to the driver is made.
574 * Returns an array of PRINTER_INFO_5 data structures in the
575 * lpbPrinters buffer.
576 *
577 * If level set to 3 or 6+:
578 * returns zero (faillure!)
579 *
580 * Returns nonzero (TRUE) on succes, or zero on faillure, use GetLastError
581 * for information.
582 *
583 * BUGS:
584 * - Only PRINTER_ENUM_LOCAL and PRINTER_ENUM_NAME are implemented.
585 * - Only levels 2, 4 and 5 are implemented at the moment.
586 * - 16-bit printer drivers are not enumerated.
587 * - Returned amount of bytes used/needed does not match the real Windoze
588 * implementation (as in this implementation, all strings are part
589 * of the buffer, whereas Win32 keeps them somewhere else)
590 * - At level 2, EnumPrinters should also call OpenPrinter for remote printers.
591 *
592 * NOTE:
593 * - In a regular Wine installation, no registry settings for printers
594 * exist, which makes this function return an empty list.
595 */
596 BOOL WINAPI EnumPrintersA(
597 DWORD dwType, /* Types of print objects to enumerate */
598 LPSTR lpszName, /* name of objects to enumerate */
599 DWORD dwLevel, /* type of printer info structure */
600 LPBYTE lpbPrinters,/* buffer which receives info*/
601 DWORD cbBuf, /* max size of buffer in bytes */
602 LPDWORD lpdwNeeded,/* pointer to var: # bytes used/needed */
603 LPDWORD lpdwReturned/* number of entries returned */
604 )
605 {
606 HKEY hPrinterListKey;
607 DWORD dwIndex=0;
608 char PrinterName[255];
609 DWORD PrinterNameLength=255;
610 FILETIME FileTime;
611 DWORD dwNextStringPos; /* position of next space for a string in the buffer*/
612 DWORD dwStructPrinterInfoSize; /* size of a Printer_Info_X structure */
613 BOOL bCalcSpaceOnly=FALSE;/* if TRUE: don't store data, just calculate space*/
614
615 TRACE("entered.\n");
616
617 /* test whether we're requested to really fill in. If so,
618 * zero out the data area, and initialise some returns to zero,
619 * to prevent problems
620 */
621 if (lpbPrinters==NULL || cbBuf==0)
622 bCalcSpaceOnly=TRUE;
623 else
624 {
625 int i;
626 for (i=0; i<cbBuf; i++)
627 lpbPrinters[i]=0;
628 }
629 *lpdwReturned=0;
630 *lpdwNeeded = 0;
631
632 /* check for valid Flags */
633 if (dwType != PRINTER_ENUM_LOCAL && dwType != PRINTER_ENUM_NAME)
634 {
635 SetLastError(ERROR_INVALID_FLAGS);
636 return(0);
637 }
638 switch(dwLevel)
639 {
640 case 1:
641 return(TRUE);
642 case 2:
643 case 4:
644 case 5:
645 break;
646 default:
647 SetLastError(ERROR_INVALID_PARAMETER);
648 return(FALSE);
649 }
650
651 /* Enter critical section to prevent AddPrinters() et al. to
652 * modify whilst we're reading in the registry
653 */
654 InitializeCriticalSection(&PRINT32_RegistryBlocker);
655 EnterCriticalSection(&PRINT32_RegistryBlocker);
656
657 /* get a pointer to a list of all printer names in the registry */
658 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, Printers, 0, KEY_READ,
659 &hPrinterListKey) !=ERROR_SUCCESS)
660 {
661 /* Oh no! An empty list of printers!
662 * (which is a valid configuration anyway)
663 */
664 TRACE("No entries in the Printers part of the registry\n");
665 }
666
667 /* count the number of entries and check if it fits in the buffer
668 */
669 while(RegEnumKeyExA(hPrinterListKey, dwIndex, PrinterName, &PrinterNameLength,
670 NULL, NULL, NULL, &FileTime)==ERROR_SUCCESS)
671 {
672 PrinterNameLength=255;
673 dwIndex++;
674 }
675 *lpdwReturned = dwIndex;
676 switch(dwLevel)
677 {
678 case 1:
679 dwStructPrinterInfoSize = sizeof(PRINTER_INFO_1A);
680 break;
681 case 2:
682 dwStructPrinterInfoSize = sizeof(PRINTER_INFO_2A);
683 break;
684 case 4:
685 dwStructPrinterInfoSize = sizeof(PRINTER_INFO_4A);
686 break;
687 case 5:
688 dwStructPrinterInfoSize = sizeof(PRINTER_INFO_5A);
689 break;
690 default:
691 dwStructPrinterInfoSize = 0;
692 break;
693 }
694 if (dwIndex*dwStructPrinterInfoSize+1 > cbBuf)
695 bCalcSpaceOnly = TRUE;
696
697 /* the strings which contain e.g. PrinterName, PortName, etc,
698 * are also stored in lpbPrinters, but after the regular structs.
699 * dwNextStringPos will always point to the next free place for a
700 * string.
701 */
702 dwNextStringPos=(dwIndex+1)*dwStructPrinterInfoSize;
703
704 /* check each entry: if OK, add to list in corresponding INFO .
705 */
706 for(dwIndex=0; dwIndex < *lpdwReturned; dwIndex++)
707 {
708 PrinterNameLength=255;
709 if (RegEnumKeyExA(hPrinterListKey, dwIndex, PrinterName, &PrinterNameLength,
710 NULL, NULL, NULL, &FileTime)!=ERROR_SUCCESS)
711 break; /* exit for loop*/
712
713 /* check whether this printer is allowed in the list
714 * by comparing name to lpszName
715 */
716 if (dwType == PRINTER_ENUM_NAME)
717 if (strcmp(PrinterName,lpszName)!=0)
718 continue;
719
720 switch(dwLevel)
721 {
722 case 1:
723 /* FIXME: unimplemented */
724 break;
725 case 2:
726 bCalcSpaceOnly = ENUMPRINTERS_AddInfo2A(PrinterName, lpbPrinters,
727 dwIndex*dwStructPrinterInfoSize,
728 &dwNextStringPos, cbBuf, bCalcSpaceOnly);
729 break;
730 case 4:
731 bCalcSpaceOnly = ENUMPRINTERS_AddInfo4A(PrinterName, lpbPrinters,
732 dwIndex*dwStructPrinterInfoSize,
733 &dwNextStringPos, cbBuf, bCalcSpaceOnly);
734 break;
735 case 5:
736 bCalcSpaceOnly = ENUMPRINTERS_AddInfo5A(PrinterName, lpbPrinters,
737 dwIndex*dwStructPrinterInfoSize,
738 &dwNextStringPos, cbBuf, bCalcSpaceOnly);
739 break;
740 }
741 }
742 RegCloseKey(hPrinterListKey);
743 *lpdwNeeded = dwNextStringPos;
744
745 if (bCalcSpaceOnly==TRUE)
746 {
747 if (lpbPrinters!=NULL)
748 {
749 int i;
750 for (i=0; i<cbBuf; i++)
751 lpbPrinters[i]=0;
752 }
753 *lpdwReturned=0;
754 }
755 LeaveCriticalSection(&PRINT32_RegistryBlocker);
756 return(TRUE);
757 }
758
759 /******************************************************************
760 * EnumPrinters32W [WINSPOOL.175]
761 *
762 */
763 BOOL WINAPI EnumPrintersW(DWORD dwType, LPWSTR lpszName,
764 DWORD dwLevel, LPBYTE lpbPrinters,
765 DWORD cbBuf, LPDWORD lpdwNeeded,
766 LPDWORD lpdwReturned)
767 {
768 FIXME("Nearly empty stub\n");
769 *lpdwReturned=0;
770 *lpdwNeeded = 0;
771 return TRUE;
772 }
773
774 /******************************************************************
775 * AddMonitor32A [WINSPOOL.107]
776 *
777 */
778 BOOL WINAPI AddMonitorA(LPCSTR pName, DWORD Level, LPBYTE pMonitors)
779 {
780 FIXME("(%s,%lx,%p):stub!\n", pName, Level, pMonitors);
781 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
782 return FALSE;
783 }
784
785 /******************************************************************
786 * DeletePrinterDriver32A [WINSPOOL.146]
787 *
788 */
789 BOOL WINAPI
790 DeletePrinterDriverA (LPSTR pName, LPSTR pEnvironment, LPSTR pDriverName)
791 {
792 FIXME("(%s,%s,%s):stub\n",debugstr_a(pName),debugstr_a(pEnvironment),
793 debugstr_a(pDriverName));
794 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
795 return FALSE;
796 }
797
798
799 /******************************************************************
800 * DeleteMonitor32A [WINSPOOL.135]
801 *
802 */
803 BOOL WINAPI
804 DeleteMonitorA (LPSTR pName, LPSTR pEnvironment, LPSTR pMonitorName)
805 {
806 FIXME("(%s,%s,%s):stub\n",debugstr_a(pName),debugstr_a(pEnvironment),
807 debugstr_a(pMonitorName));
808 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
809 return FALSE;
810 }
811
812
813 /******************************************************************
814 * DeletePort32A [WINSPOOL.137]
815 *
816 */
817 BOOL WINAPI
818 DeletePortA (LPSTR pName, HWND hWnd, LPSTR pPortName)
819 {
820 FIXME("(%s,0x%08x,%s):stub\n",debugstr_a(pName),hWnd,
821 debugstr_a(pPortName));
822 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
823 return FALSE;
824 }
825
826 /******************************************************************************
827 * SetPrinter32W [WINSPOOL.214]
828 */
829 BOOL WINAPI
830 SetPrinterW(
831 HANDLE hPrinter,
832 DWORD Level,
833 LPBYTE pPrinter,
834 DWORD Command) {
835
836 FIXME("():stub\n");
837 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
838 return FALSE;
839 }
840
841 /******************************************************************************
842 * WritePrinter32 [WINSPOOL.223]
843 */
844 BOOL WINAPI
845 WritePrinter(
846 HANDLE hPrinter,
847 LPVOID pBuf,
848 DWORD cbBuf,
849 LPDWORD pcWritten) {
850
851 FIXME("():stub\n");
852 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
853 return FALSE;
854 }
855
856 /*****************************************************************************
857 * AddForm32A [WINSPOOL.103]
858 */
859 BOOL WINAPI AddFormA(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
860 {
861 FIXME("(%d,%ld,%p): stub\n", hPrinter, Level, pForm);
862 return 1;
863 }
864
865 /*****************************************************************************
866 * AddForm32W [WINSPOOL.104]
867 */
868 BOOL WINAPI AddFormW(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
869 {
870 FIXME("(%d,%ld,%p): stub\n", hPrinter, Level, pForm);
871 return 1;
872 }
873
874 /*****************************************************************************
875 * AddJob32A [WINSPOOL.105]
876 */
877 BOOL WINAPI AddJobA(HANDLE hPrinter, DWORD Level, LPBYTE pData,
878 DWORD cbBuf, LPDWORD pcbNeeded)
879 {
880 FIXME("(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pData, cbBuf,
881 pcbNeeded);
882 return 1;
883 }
884
885 /*****************************************************************************
886 * AddJob32W [WINSPOOL.106]
887 */
888 BOOL WINAPI AddJobW(HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf,
889 LPDWORD pcbNeeded)
890 {
891 FIXME("(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pData, cbBuf,
892 pcbNeeded);
893 return 1;
894 }
895
896 /*****************************************************************************
897 * AddPrinter32A [WINSPOOL.117]
898 */
899 HANDLE WINAPI AddPrinterA(LPSTR pName, DWORD Level, LPBYTE pPrinter)
900 {
901 PRINTER_INFO_2A *pi = (PRINTER_INFO_2A *) pPrinter;
902
903 HANDLE retval;
904 HKEY hkeyPrinter, hkeyPrinters, hkeyDriver, hkeyDrivers;
905
906 TRACE("(%s,%ld,%p)\n", pName, Level, pPrinter);
907
908 if(pName != NULL) {
909 FIXME("pName = `%s' - unsupported\n", pName);
910 SetLastError(ERROR_INVALID_PARAMETER);
911 return 0;
912 }
913 if(Level != 2) {
914 WARN("Level = %ld\n", Level);
915 SetLastError(ERROR_INVALID_LEVEL);
916 return 0;
917 }
918 if(!pPrinter) {
919 SetLastError(ERROR_INVALID_PARAMETER);
920 return 0;
921 }
922 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
923 ERROR_SUCCESS) {
924 ERR("Can't create Printers key\n");
925 return 0;
926 }
927 if(RegOpenKeyA(hkeyPrinters, pi->pPrinterName, &hkeyPrinter) ==
928 ERROR_SUCCESS) {
929 SetLastError(ERROR_PRINTER_ALREADY_EXISTS);
930 RegCloseKey(hkeyPrinter);
931 RegCloseKey(hkeyPrinters);
932 return 0;
933 }
934 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Drivers, &hkeyDrivers) !=
935 ERROR_SUCCESS) {
936 ERR("Can't create Drivers key\n");
937 RegCloseKey(hkeyPrinters);
938 return 0;
939 }
940 if(RegOpenKeyA(hkeyDrivers, pi->pDriverName, &hkeyDriver) !=
941 ERROR_SUCCESS) {
942 WARN("Can't find driver `%s'\n", pi->pDriverName);
943 RegCloseKey(hkeyPrinters);
944 RegCloseKey(hkeyDrivers);
945 SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER);
946 return 0;
947 }
948 RegCloseKey(hkeyDriver);
949 RegCloseKey(hkeyDrivers);
950 if(strcasecmp(pi->pPrintProcessor, "WinPrint")) { /* FIXME */
951 WARN("Can't find processor `%s'\n", pi->pPrintProcessor);
952 SetLastError(ERROR_UNKNOWN_PRINTPROCESSOR);
953 RegCloseKey(hkeyPrinters);
954 return 0;
955 }
956 if(RegCreateKeyA(hkeyPrinters, pi->pPrinterName, &hkeyPrinter) !=
957 ERROR_SUCCESS) {
958 WARN("Can't create printer `%s'\n", pi->pPrinterName);
959 SetLastError(ERROR_INVALID_PRINTER_NAME);
960 RegCloseKey(hkeyPrinters);
961 return 0;
962 }
963 RegSetValueExA(hkeyPrinter, "Attributes", 0, REG_DWORD,
964 (LPSTR)&pi->Attributes, sizeof(DWORD));
965 RegSetValueExA(hkeyPrinter, "Default DevMode", 0, REG_BINARY,
966 (LPSTR)&pi->pDevMode,
967 pi->pDevMode ? pi->pDevMode->dmSize : 0);
968 RegSetValueExA(hkeyPrinter, "Description", 0, REG_SZ, pi->pComment, 0);
969 RegSetValueExA(hkeyPrinter, "Location", 0, REG_SZ, pi->pLocation, 0);
970 RegSetValueExA(hkeyPrinter, "Name", 0, REG_SZ, pi->pPrinterName, 0);
971 RegSetValueExA(hkeyPrinter, "Parameters", 0, REG_SZ, pi->pParameters, 0);
972 RegSetValueExA(hkeyPrinter, "Port", 0, REG_SZ, pi->pPortName, 0);
973 RegSetValueExA(hkeyPrinter, "Print Processor", 0, REG_SZ,
974 pi->pPrintProcessor, 0);
975 RegSetValueExA(hkeyPrinter, "Printer Driver", 0, REG_SZ, pi->pDriverName,
976 0);
977 RegSetValueExA(hkeyPrinter, "Priority", 0, REG_DWORD,
978 (LPSTR)&pi->Priority, sizeof(DWORD));
979 RegSetValueExA(hkeyPrinter, "Separator File", 0, REG_SZ, pi->pSepFile, 0);
980 RegSetValueExA(hkeyPrinter, "Share Name", 0, REG_SZ, pi->pShareName, 0);
981 RegSetValueExA(hkeyPrinter, "Start Time", 0, REG_DWORD,
982 (LPSTR)&pi->StartTime, sizeof(DWORD));
983 RegSetValueExA(hkeyPrinter, "Status", 0, REG_DWORD,
984 (LPSTR)&pi->Status, sizeof(DWORD));
985 RegSetValueExA(hkeyPrinter, "Until Time", 0, REG_DWORD,
986 (LPSTR)&pi->UntilTime, sizeof(DWORD));
987
988 RegCloseKey(hkeyPrinter);
989 RegCloseKey(hkeyPrinters);
990 if(!OpenPrinterA(pi->pPrinterName, &retval, NULL)) {
991 ERR("OpenPrinter failing\n");
992 return 0;
993 }
994 return retval;
995 }
996
997 /*****************************************************************************
998 * AddPrinter32W [WINSPOOL.122]
999 */
1000 HANDLE WINAPI AddPrinterW(LPWSTR pName, DWORD Level, LPBYTE pPrinter)
1001 {
1002 FIXME("(%p,%ld,%p): stub\n", pName, Level, pPrinter);
1003 return 0;
1004 }
1005
1006
1007 /*****************************************************************************
1008 * ClosePrinter32 [WINSPOOL.126]
1009 */
1010 BOOL WINAPI ClosePrinter(HANDLE hPrinter)
1011 {
1012 LPOPENEDPRINTERA lpOpenedPrinter;
1013
1014 if ((hPrinter != -1) && (hPrinter < NUM_PRINTER_MAX + 1))
1015 {
1016 lpOpenedPrinter = WINSPOOL_GetOpenedPrinterA(hPrinter);
1017 HeapFree(GetProcessHeap(), 0, lpOpenedPrinter->lpsPrinterName);
1018 lpOpenedPrinter->lpsPrinterName = NULL;
1019
1020 /* Free the memory of lpDefault if it has been initialized*/
1021 if(lpOpenedPrinter->lpDefault != NULL)
1022 {
1023 HeapFree(GetProcessHeap(), 0,
1024 lpOpenedPrinter->lpDefault->pDevMode);
1025 HeapFree(GetProcessHeap(), 0,
1026 lpOpenedPrinter->lpDefault->pDatatype);
1027 HeapFree(GetProcessHeap(), 0,
1028 lpOpenedPrinter->lpDefault);
1029 lpOpenedPrinter->lpDefault = NULL;
1030 }
1031
1032 lpOpenedPrinter->hPrinter = -1;
1033
1034 return TRUE;
1035 }
1036 return FALSE;
1037 }
1038
1039 /*****************************************************************************
1040 * DeleteForm32A [WINSPOOL.133]
1041 */
1042 BOOL WINAPI DeleteFormA(HANDLE hPrinter, LPSTR pFormName)
1043 {
1044 FIXME("(%d,%s): stub\n", hPrinter, pFormName);
1045 return 1;
1046 }
1047
1048 /*****************************************************************************
1049 * DeleteForm32W [WINSPOOL.134]
1050 */
1051 BOOL WINAPI DeleteFormW(HANDLE hPrinter, LPWSTR pFormName)
1052 {
1053 FIXME("(%d,%s): stub\n", hPrinter, debugstr_w(pFormName));
1054 return 1;
1055 }
1056
1057 /*****************************************************************************
1058 * DeletePrinter32 [WINSPOOL.143]
1059 */
1060 BOOL WINAPI DeletePrinter(HANDLE hPrinter)
1061 {
1062 FIXME("(%d): stub\n", hPrinter);
1063 return 1;
1064 }
1065
1066 /*****************************************************************************
1067 * SetPrinter32A [WINSPOOL.211]
1068 */
1069 BOOL WINAPI SetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1070 DWORD Command)
1071 {
1072 FIXME("(%d,%ld,%p,%ld): stub\n",hPrinter,Level,pPrinter,Command);
1073 return FALSE;
1074 }
1075
1076 /*****************************************************************************
1077 * SetJob32A [WINSPOOL.209]
1078 */
1079 BOOL WINAPI SetJobA(HANDLE hPrinter, DWORD JobId, DWORD Level,
1080 LPBYTE pJob, DWORD Command)
1081 {
1082 FIXME("(%d,%ld,%ld,%p,%ld): stub\n",hPrinter,JobId,Level,pJob,
1083 Command);
1084 return FALSE;
1085 }
1086
1087 /*****************************************************************************
1088 * SetJob32W [WINSPOOL.210]
1089 */
1090 BOOL WINAPI SetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level,
1091 LPBYTE pJob, DWORD Command)
1092 {
1093 FIXME("(%d,%ld,%ld,%p,%ld): stub\n",hPrinter,JobId,Level,pJob,
1094 Command);
1095 return FALSE;
1096 }
1097
1098 /*****************************************************************************
1099 * GetForm32A [WINSPOOL.181]
1100 */
1101 BOOL WINAPI GetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
1102 LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
1103 {
1104 FIXME("(%d,%s,%ld,%p,%ld,%p): stub\n",hPrinter,pFormName,
1105 Level,pForm,cbBuf,pcbNeeded);
1106 return FALSE;
1107 }
1108
1109 /*****************************************************************************
1110 * GetForm32W [WINSPOOL.182]
1111 */
1112 BOOL WINAPI GetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
1113 LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
1114 {
1115 FIXME("(%d,%s,%ld,%p,%ld,%p): stub\n",hPrinter,
1116 debugstr_w(pFormName),Level,pForm,cbBuf,pcbNeeded);
1117 return FALSE;
1118 }
1119
1120 /*****************************************************************************
1121 * SetForm32A [WINSPOOL.207]
1122 */
1123 BOOL WINAPI SetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
1124 LPBYTE pForm)
1125 {
1126 FIXME("(%d,%s,%ld,%p): stub\n",hPrinter,pFormName,Level,pForm);
1127 return FALSE;
1128 }
1129
1130 /*****************************************************************************
1131 * SetForm32W [WINSPOOL.208]
1132 */
1133 BOOL WINAPI SetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
1134 LPBYTE pForm)
1135 {
1136 FIXME("(%d,%p,%ld,%p): stub\n",hPrinter,pFormName,Level,pForm);
1137 return FALSE;
1138 }
1139
1140 /*****************************************************************************
1141 * ReadPrinter32 [WINSPOOL.202]
1142 */
1143 BOOL WINAPI ReadPrinter(HANDLE hPrinter, LPVOID pBuf, DWORD cbBuf,
1144 LPDWORD pNoBytesRead)
1145 {
1146 FIXME("(%d,%p,%ld,%p): stub\n",hPrinter,pBuf,cbBuf,pNoBytesRead);
1147 return FALSE;
1148 }
1149
1150 /*****************************************************************************
1151 * ResetPrinter32A [WINSPOOL.203]
1152 */
1153 BOOL WINAPI ResetPrinterA(HANDLE hPrinter, LPPRINTER_DEFAULTSA pDefault)
1154 {
1155 FIXME("(%d, %p): stub\n", hPrinter, pDefault);
1156 return FALSE;
1157 }
1158
1159 /*****************************************************************************
1160 * ResetPrinter32W [WINSPOOL.204]
1161 */
1162 BOOL WINAPI ResetPrinterW(HANDLE hPrinter, LPPRINTER_DEFAULTSW pDefault)
1163 {
1164 FIXME("(%d, %p): stub\n", hPrinter, pDefault);
1165 return FALSE;
1166 }
1167
1168 /*****************************************************************************
1169 * GetPrinter32A [WINSPOOL.187]
1170 */
1171 BOOL WINAPI GetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1172 DWORD cbBuf, LPDWORD pcbNeeded)
1173 {
1174 FIXME("(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pPrinter,
1175 cbBuf, pcbNeeded);
1176
1177 *pcbNeeded = sizeof(PRINTER_INFO_2A);
1178
1179 if(cbBuf < *pcbNeeded) {
1180 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1181 return FALSE;
1182 }
1183 memset(pPrinter, 0, cbBuf);
1184
1185 return TRUE;
1186 }
1187
1188 /*****************************************************************************
1189 * GetPrinter32W [WINSPOOL.194]
1190 */
1191 BOOL WINAPI GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1192 DWORD cbBuf, LPDWORD pcbNeeded)
1193 {
1194 FIXME("(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pPrinter,
1195 cbBuf, pcbNeeded);
1196 return FALSE;
1197 }
1198
1199 /*****************************************************************************
1200 * GetPrinterDriver32A [WINSPOOL.190]
1201 */
1202 BOOL WINAPI GetPrinterDriverA(HANDLE hPrinter, LPSTR pEnvironment,
1203 DWORD Level, LPBYTE pDriverInfo,
1204 DWORD cbBuf, LPDWORD pcbNeeded)
1205 {
1206 OPENEDPRINTERA *lpOpenedPrinter;
1207 LPSTR lpName;
1208
1209 FIXME("(%d,%s,%ld,%p,%ld,%p): stub\n",hPrinter,pEnvironment,
1210 Level,pDriverInfo,cbBuf, pcbNeeded);
1211
1212 lpOpenedPrinter = WINSPOOL_GetOpenedPrinterA(hPrinter);
1213 if(!lpOpenedPrinter) {
1214 SetLastError(ERROR_INVALID_HANDLE);
1215 return FALSE;
1216 }
1217 lpName = lpOpenedPrinter->lpsPrinterName;
1218 if(pEnvironment) {
1219 FIXME("pEnvironment = `%s'\n", pEnvironment);
1220 SetLastError(ERROR_INVALID_ENVIRONMENT);
1221 return FALSE;
1222 }
1223
1224 return FALSE;
1225 }
1226
1227 /*****************************************************************************
1228 * GetPrinterDriver32W [WINSPOOL.193]
1229 */
1230 BOOL WINAPI GetPrinterDriverW(HANDLE hPrinter, LPWSTR pEnvironment,
1231 DWORD Level, LPBYTE pDriverInfo,
1232 DWORD cbBuf, LPDWORD pcbNeeded)
1233 {
1234 FIXME("(%d,%p,%ld,%p,%ld,%p): stub\n",hPrinter,pEnvironment,
1235 Level,pDriverInfo,cbBuf, pcbNeeded);
1236 return FALSE;
1237 }
1238
1239 /*****************************************************************************
1240 * GetPrinterDriverDirectoryA [WINSPOOL.191]
1241 */
1242 BOOL WINAPI GetPrinterDriverDirectoryA(LPSTR pName, LPSTR pEnvironment,
1243 DWORD Level, LPBYTE pDriverDirectory,
1244 DWORD cbBuf, LPDWORD pcbNeeded)
1245 {
1246 DWORD needed;
1247
1248 TRACE("(%s, %s, %ld, %p, %ld, %p)\n", pName, pEnvironment, Level,
1249 pDriverDirectory, cbBuf, pcbNeeded);
1250 if(pName != NULL) {
1251 FIXME("pName = `%s' - unsupported\n", pName);
1252 SetLastError(ERROR_INVALID_PARAMETER);
1253 return FALSE;
1254 }
1255 if(pEnvironment != NULL) {
1256 FIXME("pEnvironment = `%s' - unsupported\n", pEnvironment);
1257 SetLastError(ERROR_INVALID_ENVIRONMENT);
1258 return FALSE;
1259 }
1260 if(Level != 1) /* win95 ignores this so we just carry on */
1261 WARN("Level = %ld - assuming 1\n", Level);
1262
1263 /* FIXME should read from registry */
1264 needed = GetSystemDirectoryA(pDriverDirectory, cbBuf);
1265 needed++;
1266 if(pcbNeeded)
1267 *pcbNeeded = needed;
1268 if(needed > cbBuf) {
1269 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1270 return FALSE;
1271 }
1272 return TRUE;
1273 }
1274
1275
1276 /*****************************************************************************
1277 * GetPrinterDriverDirectoryW [WINSPOOL.192]
1278 */
1279 BOOL WINAPI GetPrinterDriverDirectoryW(LPWSTR pName, LPWSTR pEnvironment,
1280 DWORD Level, LPBYTE pDriverDirectory,
1281 DWORD cbBuf, LPDWORD pcbNeeded)
1282 {
1283 LPSTR pNameA = NULL, pEnvironmentA = NULL;
1284 BOOL ret;
1285
1286 if(pName)
1287 pNameA = HEAP_strdupWtoA( GetProcessHeap(), 0, pName );
1288 if(pEnvironment)
1289 pEnvironmentA = HEAP_strdupWtoA( GetProcessHeap(), 0, pEnvironment );
1290 ret = GetPrinterDriverDirectoryA( pNameA, pEnvironmentA, Level,
1291 pDriverDirectory, cbBuf, pcbNeeded );
1292 if(pNameA)
1293 HeapFree( GetProcessHeap(), 0, pNameA );
1294 if(pEnvironmentA)
1295 HeapFree( GetProcessHeap(), 0, pEnvironment );
1296
1297 return ret;
1298 }
1299
1300 /*****************************************************************************
1301 * AddPrinterDriver32A [WINSPOOL.120]
1302 */
1303 BOOL WINAPI AddPrinterDriverA(LPSTR pName, DWORD level, LPBYTE pDriverInfo)
1304 {
1305 DRIVER_INFO_3A di3;
1306 HKEY hkeyDrivers, hkeyName;
1307
1308 TRACE("(%s,%ld,%p)\n",pName,level,pDriverInfo);
1309
1310 if(level != 2 && level != 3) {
1311 SetLastError(ERROR_INVALID_LEVEL);
1312 return FALSE;
1313 }
1314 if(pName != NULL) {
1315 FIXME("pName= `%s' - unsupported\n", pName);
1316 SetLastError(ERROR_INVALID_PARAMETER);
1317 return FALSE;
1318 }
1319 if(!pDriverInfo) {
1320 WARN("pDriverInfo == NULL");
1321 SetLastError(ERROR_INVALID_PARAMETER);
1322 return FALSE;
1323 }
1324
1325 if(level == 3)
1326 di3 = *(DRIVER_INFO_3A *)pDriverInfo;
1327 else {
1328 memset(&di3, 0, sizeof(di3));
1329 *(DRIVER_INFO_2A *)&di3 = *(DRIVER_INFO_2A *)pDriverInfo;
1330 }
1331
1332 if(!di3.pName || !di3.pDriverPath || !di3.pConfigFile ||
1333 !di3.pDataFile) {
1334 SetLastError(ERROR_INVALID_PARAMETER);
1335 return FALSE;
1336 }
1337 if(!di3.pDefaultDataType) di3.pDefaultDataType = "";
1338 if(!di3.pDependentFiles) di3.pDependentFiles = "\0";
1339 if(!di3.pHelpFile) di3.pHelpFile = "";
1340 if(!di3.pMonitorName) di3.pMonitorName = "";
1341
1342 if(di3.pEnvironment) {
1343 FIXME("pEnvironment = `%s'\n", di3.pEnvironment);
1344 SetLastError(ERROR_INVALID_ENVIRONMENT);
1345 return FALSE;
1346 }
1347 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Drivers, &hkeyDrivers) !=
1348 ERROR_SUCCESS) {
1349 ERR("Can't create Drivers key\n");
1350 return FALSE;
1351 }
1352
1353 if(level == 2) { /* apparently can't overwrite with level2 */
1354 if(RegOpenKeyA(hkeyDrivers, di3.pName, &hkeyName) == ERROR_SUCCESS) {
1355 RegCloseKey(hkeyName);
1356 RegCloseKey(hkeyDrivers);
1357 WARN("Trying to create existing printer driver `%s'\n", di3.pName);
1358 SetLastError(ERROR_PRINTER_DRIVER_ALREADY_INSTALLED);
1359 return FALSE;
1360 }
1361 }
1362 if(RegCreateKeyA(hkeyDrivers, di3.pName, &hkeyName) != ERROR_SUCCESS) {
1363 RegCloseKey(hkeyDrivers);
1364 ERR("Can't create Name key\n");
1365 return FALSE;
1366 }
1367 RegSetValueExA(hkeyName, "Configuration File", 0, REG_SZ, di3.pConfigFile,
1368 0);
1369 RegSetValueExA(hkeyName, "Data File", 0, REG_SZ, di3.pDataFile, 0);
1370 RegSetValueExA(hkeyName, "Driver", 0, REG_SZ, di3.pDriverPath, 0);
1371 RegSetValueExA(hkeyName, "Version", 0, REG_DWORD, (LPSTR)&di3.cVersion,
1372 sizeof(DWORD));
1373 RegSetValueExA(hkeyName, "Datatype", 0, REG_SZ, di3.pDefaultDataType, 0);
1374 RegSetValueExA(hkeyName, "Dependent Files", 0, REG_MULTI_SZ,
1375 di3.pDependentFiles, 0);
1376 RegSetValueExA(hkeyName, "Help File", 0, REG_SZ, di3.pHelpFile, 0);
1377 RegSetValueExA(hkeyName, "Monitor", 0, REG_SZ, di3.pMonitorName, 0);
1378 RegCloseKey(hkeyName);
1379 RegCloseKey(hkeyDrivers);
1380
1381 return TRUE;
1382 }
1383 /*****************************************************************************
1384 * AddPrinterDriver32W [WINSPOOL.121]
1385 */
1386 BOOL WINAPI AddPrinterDriverW(LPWSTR printerName,DWORD level,
1387 LPBYTE pDriverInfo)
1388 {
1389 FIXME("(%s,%ld,%p): stub\n",debugstr_w(printerName),
1390 level,pDriverInfo);
1391 return FALSE;
1392 }
1393
1394
1395 /*****************************************************************************
1396 * PrinterProperties [WINSPOOL.201]
1397 *
1398 * Displays a dialog to set the properties of the printer.
1399 *
1400 * RETURNS
1401 * nonzero on succes or zero on faillure
1402 *
1403 * BUGS
1404 * implemented as stub only
1405 */
1406 BOOL WINAPI PrinterProperties(HWND hWnd, /* handle to parent window */
1407 HANDLE hPrinter /* handle to printer object */
1408 ){
1409 FIXME("(%d,%d): stub\n", hWnd, hPrinter);
1410 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1411 return FALSE;
1412 }
1413
1414
Windows API implementation