Avoid dumping the contents of output strings.
[wine] / dlls / gdi / printdrv.c
1 /*
2  * Implementation of some printer driver bits
3  *
4  * Copyright 1996 John Harvey
5  * Copyright 1998 Huw Davies
6  * Copyright 1998 Andreas Mohr
7  * Copyright 1999 Klaas van Gend
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <signal.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include <errno.h>
34 #ifdef HAVE_IO_H
35 # include <io.h>
36 #endif
37 #ifdef HAVE_UNISTD_H
38 # include <unistd.h>
39 #endif
40 #include <fcntl.h>
41 #include "windef.h"
42 #include "winbase.h"
43 #include "winuser.h"
44 #include "wine/winbase16.h"
45 #include "wine/wingdi16.h"
46 #include "winspool.h"
47 #include "winerror.h"
48 #include "winreg.h"
49 #include "wownt32.h"
50 #include "wine/debug.h"
51 #include "gdi.h"
52 #include "gdi_private.h"
53 #include "heap.h"
54
55 WINE_DEFAULT_DEBUG_CHANNEL(print);
56
57 static const char PrinterModel[]      = "Printer Model";
58 static const char DefaultDevMode[]    = "Default DevMode";
59 static const char PrinterDriverData[] = "PrinterDriverData";
60 static const char Printers[]          = "System\\CurrentControlSet\\Control\\Print\\Printers\\";
61
62
63 /******************************************************************
64  *                  StartDocA  [GDI32.@]
65  *
66  * StartDoc calls the STARTDOC Escape with the input data pointing to DocName
67  * and the output data (which is used as a second input parameter).pointing at
68  * the whole docinfo structure.  This seems to be an undocumented feature of
69  * the STARTDOC Escape.
70  *
71  * Note: we now do it the other way, with the STARTDOC Escape calling StartDoc.
72  */
73 INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
74 {
75     INT ret = 0;
76     DC *dc = DC_GetDCPtr( hdc );
77
78     TRACE("DocName = '%s' Output = '%s' Datatype = '%s'\n",
79           doc->lpszDocName, doc->lpszOutput, doc->lpszDatatype);
80
81     if(!dc) return SP_ERROR;
82
83     if (dc->funcs->pStartDoc) ret = dc->funcs->pStartDoc( dc->physDev, doc );
84     GDI_ReleaseObj( hdc );
85     return ret;
86 }
87
88 /*************************************************************************
89  *                  StartDocW [GDI32.@]
90  *
91  */
92 INT WINAPI StartDocW(HDC hdc, const DOCINFOW* doc)
93 {
94     DOCINFOA docA;
95     INT ret;
96
97     docA.cbSize = doc->cbSize;
98     docA.lpszDocName = doc->lpszDocName ?
99       HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDocName ) : NULL;
100     docA.lpszOutput = doc->lpszOutput ?
101       HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszOutput ) : NULL;
102     docA.lpszDatatype = doc->lpszDatatype ?
103       HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDatatype ) : NULL;
104     docA.fwType = doc->fwType;
105
106     ret = StartDocA(hdc, &docA);
107
108     HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDocName );
109     HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszOutput );
110     HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDatatype );
111
112     return ret;
113 }
114
115
116 /******************************************************************
117  *                  EndDoc  [GDI32.@]
118  *
119  */
120 INT WINAPI EndDoc(HDC hdc)
121 {
122     INT ret = 0;
123     DC *dc = DC_GetDCPtr( hdc );
124     if(!dc) return SP_ERROR;
125
126     if (dc->funcs->pEndDoc) ret = dc->funcs->pEndDoc( dc->physDev );
127     GDI_ReleaseObj( hdc );
128     return ret;
129 }
130
131
132 /******************************************************************
133  *                  StartPage  [GDI32.@]
134  *
135  */
136 INT WINAPI StartPage(HDC hdc)
137 {
138     INT ret = 1;
139     DC *dc = DC_GetDCPtr( hdc );
140     if(!dc) return SP_ERROR;
141
142     if(dc->funcs->pStartPage)
143         ret = dc->funcs->pStartPage( dc->physDev );
144     else
145         FIXME("stub\n");
146     GDI_ReleaseObj( hdc );
147     return ret;
148 }
149
150
151 /******************************************************************
152  *                  EndPage  [GDI32.@]
153  *
154  */
155 INT WINAPI EndPage(HDC hdc)
156 {
157     ABORTPROC abort_proc;
158     INT ret = 0;
159     DC *dc = DC_GetDCPtr( hdc );
160     if(!dc) return SP_ERROR;
161
162     if (dc->funcs->pEndPage) ret = dc->funcs->pEndPage( dc->physDev );
163     abort_proc = dc->pAbortProc;
164     GDI_ReleaseObj( hdc );
165     if (abort_proc && !abort_proc( hdc, 0 ))
166     {
167         EndDoc( hdc );
168         ret = 0;
169     }
170     return ret;
171 }
172
173
174 /******************************************************************************
175  *                 AbortDoc  [GDI32.@]
176  */
177 INT WINAPI AbortDoc(HDC hdc)
178 {
179     INT ret = 0;
180     DC *dc = DC_GetDCPtr( hdc );
181     if(!dc) return SP_ERROR;
182
183     if (dc->funcs->pAbortDoc) ret = dc->funcs->pAbortDoc( dc->physDev );
184     GDI_ReleaseObj( hdc );
185     return ret;
186 }
187
188 /**********************************************************************
189  *           QueryAbort   (GDI.155)
190  *
191  *  Calls the app's AbortProc function if avail.
192  *
193  * RETURNS
194  * TRUE if no AbortProc avail or AbortProc wants to continue printing.
195  * FALSE if AbortProc wants to abort printing.
196  */
197 BOOL16 WINAPI QueryAbort16(HDC16 hdc16, INT16 reserved)
198 {
199     BOOL ret = TRUE;
200     HDC hdc = HDC_32( hdc16 );
201     DC *dc = DC_GetDCPtr( hdc );
202     ABORTPROC abproc;
203
204     if(!dc) {
205         ERR("Invalid hdc %p\n", hdc);
206         return FALSE;
207     }
208
209     abproc = dc->pAbortProc;
210     GDI_ReleaseObj( hdc );
211
212     if (abproc)
213         ret = abproc(hdc, 0);
214     return ret;
215 }
216
217
218 /**********************************************************************
219  *           call_abort_proc16
220  */
221 static BOOL CALLBACK call_abort_proc16( HDC hdc, INT code )
222 {
223     ABORTPROC16 proc16;
224     DC *dc = DC_GetDCPtr( hdc );
225
226     if (!dc) return FALSE;
227     proc16 = dc->pAbortProc16;
228     GDI_ReleaseObj( hdc );
229     if (proc16)
230     {
231         WORD args[2];
232         DWORD ret;
233
234         args[1] = HDC_16(hdc);
235         args[0] = code;
236         WOWCallback16Ex( (DWORD)proc16, WCB16_PASCAL, sizeof(args), args, &ret );
237         return LOWORD(ret);
238     }
239     return TRUE;
240 }
241
242
243 /**********************************************************************
244  *           SetAbortProc   (GDI.381)
245  */
246 INT16 WINAPI SetAbortProc16(HDC16 hdc16, ABORTPROC16 abrtprc)
247 {
248     HDC hdc = HDC_32( hdc16 );
249     DC *dc = DC_GetDCPtr( hdc );
250
251     if (!dc) return FALSE;
252     dc->pAbortProc16 = abrtprc;
253     GDI_ReleaseObj( hdc );
254     return SetAbortProc( hdc, call_abort_proc16 );
255 }
256
257 /**********************************************************************
258  *           SetAbortProc   (GDI32.@)
259  *
260  */
261 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
262 {
263     DC *dc = DC_GetDCPtr( hdc );
264
265     if (!dc) return FALSE;
266     dc->pAbortProc = abrtprc;
267     GDI_ReleaseObj( hdc );
268     return TRUE;
269 }
270
271
272 /****************** misc. printer related functions */
273
274 /*
275  * The following function should implement a queing system
276  */
277 struct hpq
278 {
279     struct hpq  *next;
280     int          tag;
281     int          key;
282 };
283
284 static struct hpq *hpqueue;
285
286 /**********************************************************************
287  *           CreatePQ   (GDI.230)
288  *
289  */
290 HPQ16 WINAPI CreatePQ16(INT16 size)
291 {
292 #if 0
293     HGLOBAL16 hpq = 0;
294     WORD tmp_size;
295     LPWORD pPQ;
296
297     tmp_size = size << 2;
298     if (!(hpq = GlobalAlloc16(GMEM_SHARE|GMEM_MOVEABLE, tmp_size + 8)))
299        return 0xffff;
300     pPQ = GlobalLock16(hpq);
301     *pPQ++ = 0;
302     *pPQ++ = tmp_size;
303     *pPQ++ = 0;
304     *pPQ++ = 0;
305     GlobalUnlock16(hpq);
306
307     return (HPQ16)hpq;
308 #else
309     FIXME("(%d): stub\n",size);
310     return 1;
311 #endif
312 }
313
314 /**********************************************************************
315  *           DeletePQ   (GDI.235)
316  *
317  */
318 INT16 WINAPI DeletePQ16(HPQ16 hPQ)
319 {
320     return GlobalFree16((HGLOBAL16)hPQ);
321 }
322
323 /**********************************************************************
324  *           ExtractPQ   (GDI.232)
325  *
326  */
327 INT16 WINAPI ExtractPQ16(HPQ16 hPQ)
328 {
329     struct hpq *queue, *prev, *current, *currentPrev;
330     int key = 0, tag = -1;
331     currentPrev = prev = NULL;
332     queue = current = hpqueue;
333     if (current)
334         key = current->key;
335
336     while (current)
337     {
338         currentPrev = current;
339         current = current->next;
340         if (current)
341         {
342             if (current->key < key)
343             {
344                 queue = current;
345                 prev = currentPrev;
346             }
347         }
348     }
349     if (queue)
350     {
351         tag = queue->tag;
352
353         if (prev)
354             prev->next = queue->next;
355         else
356             hpqueue = queue->next;
357         HeapFree(GetProcessHeap(), 0, queue);
358     }
359
360     TRACE("%x got tag %d key %d\n", hPQ, tag, key);
361
362     return tag;
363 }
364
365 /**********************************************************************
366  *           InsertPQ   (GDI.233)
367  *
368  */
369 INT16 WINAPI InsertPQ16(HPQ16 hPQ, INT16 tag, INT16 key)
370 {
371     struct hpq *queueItem = HeapAlloc(GetProcessHeap(), 0, sizeof(struct hpq));
372     if(queueItem == NULL) {
373         ERR("Memory exausted!\n");
374         return FALSE;
375     }
376     queueItem->next = hpqueue;
377     hpqueue = queueItem;
378     queueItem->key = key;
379     queueItem->tag = tag;
380
381     FIXME("(%x %d %d): stub???\n", hPQ, tag, key);
382     return TRUE;
383 }
384
385 /**********************************************************************
386  *           MinPQ   (GDI.231)
387  *
388  */
389 INT16 WINAPI MinPQ16(HPQ16 hPQ)
390 {
391     FIXME("(%x): stub\n", hPQ);
392     return 0;
393 }
394
395 /**********************************************************************
396  *           SizePQ   (GDI.234)
397  *
398  */
399 INT16 WINAPI SizePQ16(HPQ16 hPQ, INT16 sizechange)
400 {
401     FIXME("(%x %d): stub\n", hPQ, sizechange);
402     return -1;
403 }
404
405
406
407 /*
408  * The following functions implement part of the spooling process to
409  * print manager.  I would like to see wine have a version of print managers
410  * that used LPR/LPD.  For simplicity print jobs will be sent to a file for
411  * now.
412  */
413 typedef struct PRINTJOB
414 {
415     char        *pszOutput;
416     char        *pszTitle;
417     HDC16       hDC;
418     HANDLE16    hHandle;
419     int         nIndex;
420     int         fd;
421 } PRINTJOB, *PPRINTJOB;
422
423 #define MAX_PRINT_JOBS 1
424 #define SP_OK 1
425
426 PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
427
428
429 static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
430 {
431     return gPrintJobsTable[0];
432 }
433
434 static int CreateSpoolFile(LPCSTR pszOutput)
435 {
436     int fd=-1;
437     char psCmd[1024];
438     char *psCmdP = psCmd;
439     HKEY hkey;
440
441     /* TTD convert the 'output device' into a spool file name */
442
443     if (pszOutput == NULL || *pszOutput == '\0')
444       return -1;
445
446     psCmd[0] = 0;
447     if (!strncmp("LPR:",pszOutput,4))
448     {
449         if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\spooler", &hkey))
450         {
451             DWORD type, count = sizeof(psCmd);
452             RegQueryValueExA(hkey, pszOutput, 0, &type, psCmd, &count);
453             RegCloseKey(hkey);
454         }
455         if(psCmd[0] == 0)
456             sprintf(psCmd,"|lpr -P%s",pszOutput+4);
457     }
458     else
459     {
460         if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\spooler", &hkey))
461         {
462             DWORD type, count = sizeof(psCmd);
463             RegQueryValueExA(hkey, pszOutput, 0, &type, psCmd, &count);
464             RegCloseKey(hkey);
465         }
466     }
467     TRACE("Got printerSpoolCommand '%s' for output device '%s'\n",
468           psCmd, pszOutput);
469     if (!*psCmd)
470         psCmdP = (char *)pszOutput;
471     else
472     {
473         while (*psCmdP && isspace(*psCmdP))
474         {
475             psCmdP++;
476         }
477         if (!*psCmdP)
478             return -1;
479     }
480     TRACE("command: '%s'\n", psCmdP);
481 #ifdef HAVE_FORK
482     if (*psCmdP == '|')
483     {
484         int fds[2];
485         if (pipe(fds)) {
486             ERR("pipe() failed!\n"); 
487             return -1;
488         }
489         if (fork() == 0)
490         {
491             psCmdP++;
492
493             TRACE("In child need to exec %s\n",psCmdP);
494             close(0);
495             dup2(fds[0],0);
496             close (fds[1]);
497
498             /* reset signals that we previously set to SIG_IGN */
499             signal( SIGPIPE, SIG_DFL );
500             signal( SIGCHLD, SIG_DFL );
501
502             system(psCmdP);
503             exit(0);
504
505         }
506         close (fds[0]);
507         fd = fds[1];
508         TRACE("Need to execute a cmnd and pipe the output to it\n");
509     }
510     else
511 #endif
512     {
513         char *buffer;
514         WCHAR psCmdPW[MAX_PATH];
515
516         TRACE("Just assume it's a file\n");
517
518         /**
519          * The file name can be dos based, we have to find its
520          * Unix correspondant file name
521          */
522         MultiByteToWideChar(CP_ACP, 0, psCmdP, -1, psCmdPW, MAX_PATH);
523         if ((buffer = wine_get_unix_file_name(psCmdPW)))
524         {
525             if ((fd = open(buffer, O_CREAT | O_TRUNC | O_WRONLY , 0600)) < 0)
526             {
527                 ERR("Failed to create spool file '%s' ('%s'). (error %s)\n",
528                     buffer, psCmdP, strerror(errno));
529             }
530             HeapFree(GetProcessHeap(), 0, buffer);
531         }
532     }
533     return fd;
534 }
535
536 static int FreePrintJob(HANDLE16 hJob)
537 {
538     int nRet = SP_ERROR;
539     PPRINTJOB pPrintJob;
540
541     pPrintJob = FindPrintJobFromHandle(hJob);
542     if (pPrintJob != NULL)
543     {
544         gPrintJobsTable[pPrintJob->nIndex] = NULL;
545         HeapFree(GetProcessHeap(), 0, pPrintJob->pszOutput);
546         HeapFree(GetProcessHeap(), 0, pPrintJob->pszTitle);
547         if (pPrintJob->fd >= 0) close(pPrintJob->fd);
548         HeapFree(GetProcessHeap(), 0, pPrintJob);
549         nRet = SP_OK;
550     }
551     return nRet;
552 }
553
554 /**********************************************************************
555  *           OpenJob   (GDI.240)
556  *
557  */
558 HPJOB16 WINAPI OpenJob16(LPCSTR lpOutput, LPCSTR lpTitle, HDC16 hDC)
559 {
560     HPJOB16 hHandle = (HPJOB16)SP_ERROR;
561     PPRINTJOB pPrintJob;
562
563     TRACE("'%s' '%s' %04x\n", lpOutput, lpTitle, hDC);
564
565     pPrintJob = gPrintJobsTable[0];
566     if (pPrintJob == NULL)
567     {
568         int fd;
569
570         /* Try and create a spool file */
571         fd = CreateSpoolFile(lpOutput);
572         if (fd >= 0)
573         {
574             pPrintJob = HeapAlloc(GetProcessHeap(), 0, sizeof(PRINTJOB));
575             if(pPrintJob == NULL) {
576                 WARN("Memory exausted!\n");
577                 return hHandle;
578             }
579
580             hHandle = 1;
581
582             pPrintJob->pszOutput = HeapAlloc(GetProcessHeap(), 0, strlen(lpOutput)+1);
583             strcpy( pPrintJob->pszOutput, lpOutput );
584             if(lpTitle)
585             {
586                 pPrintJob->pszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(lpTitle)+1);
587                 strcpy( pPrintJob->pszTitle, lpTitle );
588             }
589             pPrintJob->hDC = hDC;
590             pPrintJob->fd = fd;
591             pPrintJob->nIndex = 0;
592             pPrintJob->hHandle = hHandle;
593             gPrintJobsTable[pPrintJob->nIndex] = pPrintJob;
594         }
595     }
596     TRACE("return %04x\n", hHandle);
597     return hHandle;
598 }
599
600 /**********************************************************************
601  *           CloseJob   (GDI.243)
602  *
603  */
604 INT16 WINAPI CloseJob16(HPJOB16 hJob)
605 {
606     int nRet = SP_ERROR;
607     PPRINTJOB pPrintJob = NULL;
608
609     TRACE("%04x\n", hJob);
610
611     pPrintJob = FindPrintJobFromHandle(hJob);
612     if (pPrintJob != NULL)
613     {
614         /* Close the spool file */
615         close(pPrintJob->fd);
616         FreePrintJob(hJob);
617         nRet  = 1;
618     }
619     return nRet;
620 }
621
622 /**********************************************************************
623  *           WriteSpool   (GDI.241)
624  *
625  */
626 INT16 WINAPI WriteSpool16(HPJOB16 hJob, LPSTR lpData, INT16 cch)
627 {
628     int nRet = SP_ERROR;
629     PPRINTJOB pPrintJob = NULL;
630
631     TRACE("%04x %08lx %04x\n", hJob, (DWORD)lpData, cch);
632
633     pPrintJob = FindPrintJobFromHandle(hJob);
634     if (pPrintJob != NULL && pPrintJob->fd >= 0 && cch)
635     {
636         if (write(pPrintJob->fd, lpData, cch) != cch)
637           nRet = SP_OUTOFDISK;
638         else
639           nRet = cch;
640 #if 0
641         /* FIXME: We just cannot call 16 bit functions from here, since we
642          * have acquired several locks (DC). And we do not really need to.
643          */
644         if (pPrintJob->hDC == 0) {
645             TRACE("hDC == 0 so no QueryAbort\n");
646         }
647         else if (!(QueryAbort16(pPrintJob->hDC, (nRet == SP_OUTOFDISK) ? nRet : 0 )))
648         {
649             CloseJob16(hJob); /* printing aborted */
650             nRet = SP_APPABORT;
651         }
652 #endif
653     }
654     return nRet;
655 }
656
657 typedef INT (WINAPI *MSGBOX_PROC)( HWND, LPCSTR, LPCSTR, UINT );
658
659 /**********************************************************************
660  *           WriteDialog   (GDI.242)
661  *
662  */
663 INT16 WINAPI WriteDialog16(HPJOB16 hJob, LPSTR lpMsg, INT16 cchMsg)
664 {
665     HMODULE mod;
666     MSGBOX_PROC pMessageBoxA;
667     INT16 ret = 0;
668
669     TRACE("%04x %04x '%s'\n", hJob,  cchMsg, lpMsg);
670
671     if ((mod = GetModuleHandleA("user32.dll")))
672     {
673         if ((pMessageBoxA = (MSGBOX_PROC)GetProcAddress( mod, "MessageBoxA" )))
674             ret = pMessageBoxA(0, lpMsg, "Printing Error", MB_OKCANCEL);
675     }
676     return ret;
677 }
678
679
680 /**********************************************************************
681  *           DeleteJob  (GDI.244)
682  *
683  */
684 INT16 WINAPI DeleteJob16(HPJOB16 hJob, INT16 nNotUsed)
685 {
686     int nRet;
687
688     TRACE("%04x\n", hJob);
689
690     nRet = FreePrintJob(hJob);
691     return nRet;
692 }
693
694 /*
695  * The following two function would allow a page to be sent to the printer
696  * when it has been processed.  For simplicity they havn't been implemented.
697  * This means a whole job has to be processed before it is sent to the printer.
698  */
699
700 /**********************************************************************
701  *           StartSpoolPage   (GDI.246)
702  *
703  */
704 INT16 WINAPI StartSpoolPage16(HPJOB16 hJob)
705 {
706     FIXME("StartSpoolPage GDI.246 unimplemented\n");
707     return 1;
708
709 }
710
711
712 /**********************************************************************
713  *           EndSpoolPage   (GDI.247)
714  *
715  */
716 INT16 WINAPI EndSpoolPage16(HPJOB16 hJob)
717 {
718     FIXME("EndSpoolPage GDI.247 unimplemented\n");
719     return 1;
720 }
721
722
723 /**********************************************************************
724  *           GetSpoolJob   (GDI.245)
725  *
726  */
727 DWORD WINAPI GetSpoolJob16(int nOption, LONG param)
728 {
729     DWORD retval = 0;
730     TRACE("In GetSpoolJob param 0x%lx noption %d\n",param, nOption);
731     return retval;
732 }
733
734
735 /******************************************************************
736  *                  DrvGetPrinterDataInternal
737  *
738  * Helper for DrvGetPrinterData
739  */
740 static DWORD DrvGetPrinterDataInternal(LPSTR RegStr_Printer,
741 LPBYTE lpPrinterData, int cbData, int what)
742 {
743     DWORD res = -1;
744     HKEY hkey;
745     DWORD dwType, cbQueryData;
746
747     if (!(RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey))) {
748         if (what == INT_PD_DEFAULT_DEVMODE) { /* "Default DevMode" */
749             if (!(RegQueryValueExA(hkey, DefaultDevMode, 0, &dwType, 0, &cbQueryData))) {
750                 if (!lpPrinterData)
751                     res = cbQueryData;
752                 else if ((cbQueryData) && (cbQueryData <= cbData)) {
753                     cbQueryData = cbData;
754                     if (RegQueryValueExA(hkey, DefaultDevMode, 0,
755                                 &dwType, lpPrinterData, &cbQueryData))
756                         res = cbQueryData;
757                 }
758             }
759         } else { /* "Printer Driver" */
760             cbQueryData = 32;
761             RegQueryValueExA(hkey, "Printer Driver", 0,
762                         &dwType, lpPrinterData, &cbQueryData);
763             res = cbQueryData;
764         }
765     }
766     if (hkey) RegCloseKey(hkey);
767     return res;
768 }
769
770 /******************************************************************
771  *                DrvGetPrinterData     (GDI.282)
772  *
773  */
774 DWORD WINAPI DrvGetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
775                                LPDWORD lpType, LPBYTE lpPrinterData,
776                                int cbData, LPDWORD lpNeeded)
777 {
778     LPSTR RegStr_Printer;
779     HKEY hkey = 0, hkey2 = 0;
780     DWORD res = 0;
781     DWORD dwType, PrinterAttr, cbPrinterAttr, SetData, size;
782
783     if (HIWORD(lpPrinter))
784             TRACE("printer %s\n",lpPrinter);
785     else
786             TRACE("printer %p\n",lpPrinter);
787     if (HIWORD(lpProfile))
788             TRACE("profile %s\n",lpProfile);
789     else
790             TRACE("profile %p\n",lpProfile);
791     TRACE("lpType %p\n",lpType);
792
793     if ((!lpPrinter) || (!lpProfile) || (!lpNeeded))
794         return ERROR_INVALID_PARAMETER;
795
796     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
797                                strlen(Printers) + strlen(lpPrinter) + 2);
798     strcpy(RegStr_Printer, Printers);
799     strcat(RegStr_Printer, lpPrinter);
800
801     if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
802     (!strcmp(lpProfile, DefaultDevMode)))) {
803         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
804                                          INT_PD_DEFAULT_DEVMODE);
805         if (size+1) {
806             *lpNeeded = size;
807             if ((lpPrinterData) && (*lpNeeded > cbData))
808                 res = ERROR_MORE_DATA;
809         }
810         else res = ERROR_INVALID_PRINTER_NAME;
811     }
812     else
813     if (((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
814     (!strcmp(lpProfile, PrinterModel)))) {
815         *lpNeeded = 32;
816         if (!lpPrinterData) goto failed;
817         if (cbData < 32) {
818             res = ERROR_MORE_DATA;
819             goto failed;
820         }
821         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
822                                          INT_PD_DEFAULT_MODEL);
823         if ((size+1) && (lpType))
824             *lpType = REG_SZ;
825         else
826             res = ERROR_INVALID_PRINTER_NAME;
827     }
828     else
829     {
830         if ((res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)))
831             goto failed;
832         cbPrinterAttr = 4;
833         if ((res = RegQueryValueExA(hkey, "Attributes", 0,
834                         &dwType, (LPBYTE)&PrinterAttr, &cbPrinterAttr)))
835             goto failed;
836         if ((res = RegOpenKeyA(hkey, PrinterDriverData, &hkey2)))
837             goto failed;
838         *lpNeeded = cbData;
839         res = RegQueryValueExA(hkey2, lpProfile, 0,
840                 lpType, lpPrinterData, lpNeeded);
841         if ((res != ERROR_CANTREAD) &&
842          ((PrinterAttr &
843         (PRINTER_ATTRIBUTE_ENABLE_BIDI|PRINTER_ATTRIBUTE_NETWORK))
844         == PRINTER_ATTRIBUTE_NETWORK))
845         {
846             if (!(res) && (*lpType == REG_DWORD) && (*(LPDWORD)lpPrinterData == -1))
847                 res = ERROR_INVALID_DATA;
848         }
849         else
850         {
851             SetData = -1;
852             RegSetValueExA(hkey2, lpProfile, 0, REG_DWORD, (LPBYTE)&SetData, 4); /* no result returned */
853         }
854     }
855
856 failed:
857     if (hkey2) RegCloseKey(hkey2);
858     if (hkey) RegCloseKey(hkey);
859     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
860     return res;
861 }
862
863
864 /******************************************************************
865  *                 DrvSetPrinterData     (GDI.281)
866  *
867  */
868 DWORD WINAPI DrvSetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
869                                DWORD lpType, LPBYTE lpPrinterData,
870                                DWORD dwSize)
871 {
872     LPSTR RegStr_Printer;
873     HKEY hkey = 0;
874     DWORD res = 0;
875
876     if (HIWORD(lpPrinter))
877             TRACE("printer %s\n",lpPrinter);
878     else
879             TRACE("printer %p\n",lpPrinter);
880     if (HIWORD(lpProfile))
881             TRACE("profile %s\n",lpProfile);
882     else
883             TRACE("profile %p\n",lpProfile);
884     TRACE("lpType %08lx\n",lpType);
885
886     if ((!lpPrinter) || (!lpProfile) ||
887     ((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
888     (!strcmp(lpProfile, PrinterModel))))
889         return ERROR_INVALID_PARAMETER;
890
891     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
892                         strlen(Printers) + strlen(lpPrinter) + 2);
893     strcpy(RegStr_Printer, Printers);
894     strcat(RegStr_Printer, lpPrinter);
895
896     if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
897     (!strcmp(lpProfile, DefaultDevMode)))) {
898         if ( RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)
899              != ERROR_SUCCESS ||
900              RegSetValueExA(hkey, DefaultDevMode, 0, REG_BINARY,
901                               lpPrinterData, dwSize) != ERROR_SUCCESS )
902                 res = ERROR_INVALID_PRINTER_NAME;
903     }
904     else
905     {
906         strcat(RegStr_Printer, "\\");
907
908         if( (res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)) ==
909             ERROR_SUCCESS ) {
910
911             if (!lpPrinterData)
912                 res = RegDeleteValueA(hkey, lpProfile);
913             else
914                 res = RegSetValueExA(hkey, lpProfile, 0, lpType,
915                                        lpPrinterData, dwSize);
916         }
917     }
918
919     if (hkey) RegCloseKey(hkey);
920     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
921     return res;
922 }