dlls/winprint/printproc.c

   1 /*
   2  * Print processor implementation.
   3  *
   4  * Copyright 2022 Piotr Caban for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /* Missing datatypes support:
  22  *  RAW [FF appended]
  23  *  RAW [FF auto]
  24  *  NT EMF 1.003
  25  *  NT EMF 1.006
  26  *  NT EMF 1.007
  27  *  NT EMF 1.008
  28  *  TEXT
  29  *  XPS2GDI
  30  *
  31  * Implement print processor features like e.g. printing multiple copies. */
  32
  33 #include <stdlib.h>
  34
  35 #include "windows.h"
  36 #include "winspool.h"
  37 #include "ddk/winsplp.h"
  38
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(winprint);
  42
  43 #define PP_MAGIC 0x952173fd
  44
  45 struct pp_data
  46 {
  47     DWORD magic;
  48     HANDLE hport;
  49     WCHAR *doc_name;
  50     WCHAR *out_file;
  51 };
  52
  53 static struct pp_data* get_handle_data(HANDLE pp)
  54 {
  55     struct pp_data *ret = (struct pp_data *)pp;
  56
  57     if (!ret || ret->magic != PP_MAGIC)
  58     {
  59         SetLastError(ERROR_INVALID_HANDLE);
  60         return NULL;
  61     }
  62     return ret;
  63 }
  64
  65 BOOL WINAPI EnumPrintProcessorDatatypesW(WCHAR *server, WCHAR *name, DWORD level,
  66         BYTE *datatypes, DWORD size, DWORD *needed, DWORD *no)
  67 {
  68     static const WCHAR raw[] = L"RAW";
  69
  70     DATATYPES_INFO_1W *info = (DATATYPES_INFO_1W *)datatypes;
  71
  72     TRACE("%s, %s, %ld, %p, %ld, %p, %p\n", debugstr_w(server), debugstr_w(name),
  73             level, datatypes, size, needed, no);
  74
  75     if (!needed || !no)
  76     {
  77         SetLastError(ERROR_INVALID_PARAMETER);
  78         return FALSE;
  79     }
  80
  81     *no = 0;
  82     *needed = sizeof(*info) + sizeof(raw);
  83
  84     if (level != 1 || (size && !datatypes))
  85     {
  86         SetLastError(ERROR_INVALID_PARAMETER);
  87         return FALSE;
  88     }
  89
  90     if (size < *needed)
  91     {
  92         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  93         return FALSE;
  94     }
  95
  96     *no = 1;
  97     info->pName = (WCHAR*)(info + 1);
  98     memcpy(info + 1, raw, sizeof(raw));
  99     return TRUE;
 100 }
 101
 102 HANDLE WINAPI OpenPrintProcessor(WCHAR *port, PRINTPROCESSOROPENDATA *open_data)
 103 {
 104     struct pp_data *data;
 105     HANDLE hport;
 106
 107     TRACE("%s, %p\n", debugstr_w(port), open_data);
 108
 109     if (!port || !open_data || !open_data->pDatatype)
 110     {
 111         SetLastError(ERROR_INVALID_PARAMETER);
 112         return NULL;
 113     }
 114     if (wcscmp(open_data->pDatatype, L"RAW"))
 115     {
 116         SetLastError(ERROR_INVALID_DATATYPE);
 117         return NULL;
 118     }
 119
 120     if (!OpenPrinterW(port, &hport, NULL))
 121         return NULL;
 122
 123     data = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(*data));
 124     if (!data)
 125         return NULL;
 126     data->magic = PP_MAGIC;
 127     data->hport = hport;
 128     data->doc_name = wcsdup(open_data->pDocumentName);
 129     data->out_file = wcsdup(open_data->pOutputFile);
 130     return (HANDLE)data;
 131 }
 132
 133 BOOL WINAPI PrintDocumentOnPrintProcessor(HANDLE pp, WCHAR *doc_name)
 134 {
 135     struct pp_data *data = get_handle_data(pp);
 136     HANDLE spool_data;
 137     DOC_INFO_1W info;
 138     BYTE buf[0x1000];
 139     DWORD r, w;
 140
 141     TRACE("%p, %s\n", pp, debugstr_w(doc_name));
 142
 143     if (!data)
 144         return FALSE;
 145
 146     if (!OpenPrinterW(doc_name, &spool_data, NULL))
 147         return FALSE;
 148
 149     info.pDocName = data->doc_name;
 150     info.pOutputFile = data->out_file;
 151     info.pDatatype = (WCHAR *)L"RAW";
 152     if (!StartDocPrinterW(data->hport, 1, (BYTE *)&info))
 153     {
 154         ClosePrinter(spool_data);
 155         return FALSE;
 156     }
 157
 158     while (ReadPrinter(spool_data, buf, sizeof(buf), &r) && r)
 159     {
 160         if (!WritePrinter(data->hport, buf, r, &w) || r != w)
 161         {
 162             ClosePrinter(spool_data);
 163             EndDocPrinter(data->hport);
 164             return FALSE;
 165         }
 166     }
 167     ClosePrinter(spool_data);
 168
 169     return EndDocPrinter(data->hport);
 170 }
 171
 172 BOOL WINAPI ControlPrintProcessor(HANDLE pp, DWORD cmd)
 173 {
 174     FIXME("%p, %ld\n", pp, cmd);
 175     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 176     return FALSE;
 177 }
 178
 179 BOOL WINAPI ClosePrintProcessor(HANDLE pp)
 180 {
 181     struct pp_data *data = get_handle_data(pp);
 182
 183     TRACE("%p\n", pp);
 184
 185     if (!data)
 186         return FALSE;
 187
 188     ClosePrinter(data->hport);
 189     free(data->doc_name);
 190     free(data->out_file);
 191
 192     memset(data, 0, sizeof(*data));
 193     LocalFree(data);
 194     return TRUE;
 195 }
 196
 197 HRESULT WINAPI DllRegisterServer(void)
 198 {
 199     AddPrintProcessorW(NULL, (WCHAR *)L"Windows 4.0", (WCHAR *)L"winprint.dll", (WCHAR *)L"winprint");
 200     AddPrintProcessorW(NULL, NULL, (WCHAR *)L"winprint.dll", (WCHAR *)L"winprint");
 201     return S_OK;
 202 }