dlls/spoolss/spoolss_main.c

   1 /*
   2  * Implementation of the Spooler-Service helper DLL
   3  *
   4  * Copyright 2006 Detlef Riekenberg
   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 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winerror.h"
  26 #include "winreg.h"
  27
  28 #include "wingdi.h"
  29 #include "winspool.h"
  30 #include "ddk/winsplp.h"
  31 #include "spoolss.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(spoolss);
  36
  37 /* ################################ */
  38
  39 static HMODULE hwinspool;
  40
  41 static const WCHAR winspooldrvW[] = {'w','i','n','s','p','o','o','l','.','d','r','v',0};
  42
  43 /******************************************************************************
  44  *
  45  */
  46 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  47 {
  48     TRACE("(%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
  49
  50     switch (fdwReason) {
  51         case DLL_WINE_PREATTACH:
  52             return FALSE;  /* prefer native version */
  53         case DLL_PROCESS_ATTACH: {
  54             DisableThreadLibraryCalls(hinstDLL);
  55             break;
  56
  57         case DLL_PROCESS_DETACH:
  58             backend_unload_all();
  59             break;
  60         }
  61     }
  62     return TRUE;
  63 }
  64
  65 /******************************************************************
  66  *   AllocSplStr   [SPOOLSS.@]
  67  *
  68  * Create a copy from the String on the Spooler-Heap
  69  *
  70  * PARAMS
  71  *  pwstr [I] PTR to the String to copy
  72  *
  73  * RETURNS
  74  *  Failure: NULL
  75  *  Success: PTR to the copied String
  76  *
  77  */
  78 LPWSTR WINAPI AllocSplStr(LPCWSTR pwstr)
  79 {
  80     LPWSTR  res = NULL;
  81     DWORD   len;
  82
  83     TRACE("(%s)\n", debugstr_w(pwstr));
  84     if (!pwstr) return NULL;
  85
  86     len = (lstrlenW(pwstr) + 1) * sizeof(WCHAR);
  87     res = HeapAlloc(GetProcessHeap(), 0, len);
  88     if (res) lstrcpyW(res, pwstr);
  89
  90     TRACE("returning %p\n", res);
  91     return res;
  92 }
  93
  94 /******************************************************************
  95  *   BuildOtherNamesFromMachineName   [SPOOLSS.@]
  96  */
  97 BOOL WINAPI BuildOtherNamesFromMachineName(LPVOID * ptr1, LPVOID * ptr2)
  98 {
  99     FIXME("(%p, %p) stub\n", ptr1, ptr2);
 100
 101     *ptr1 = NULL;
 102     *ptr2 = NULL;
 103     return FALSE;
 104 }
 105
 106 /******************************************************************
 107  *   DllAllocSplMem   [SPOOLSS.@]
 108  *
 109  * Allocate cleared memory from the spooler heap
 110  *
 111  * PARAMS
 112  *  size [I] Number of bytes to allocate
 113  *
 114  * RETURNS
 115  *  Failure: NULL
 116  *  Success: PTR to the allocated memory
 117  *
 118  * NOTES
 119  *  We use the process heap (Windows use a separate spooler heap)
 120  *
 121  */
 122 LPVOID WINAPI DllAllocSplMem(DWORD size)
 123 {
 124     LPVOID  res;
 125
 126     res = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 127     TRACE("(%d) => %p\n", size, res);
 128     return res;
 129 }
 130
 131 /******************************************************************
 132  *   DllFreeSplMem   [SPOOLSS.@]
 133  *
 134  * Free the allocated spooler memory
 135  *
 136  * PARAMS
 137  *  memory [I] PTR to the memory allocated by DllAllocSplMem
 138  *
 139  * RETURNS
 140  *  Failure: FALSE
 141  *  Success: TRUE
 142  *
 143  * NOTES
 144  *  We use the process heap (Windows use a separate spooler heap)
 145  *
 146  */
 147
 148 BOOL WINAPI DllFreeSplMem(LPBYTE memory)
 149 {
 150     TRACE("(%p)\n", memory);
 151     return HeapFree(GetProcessHeap(), 0, memory);
 152 }
 153
 154 /******************************************************************
 155  *   DllFreeSplStr   [SPOOLSS.@]
 156  *
 157  * Free the allocated Spooler-String
 158  *
 159  * PARAMS
 160  *  pwstr [I] PTR to the WSTR, allocated by AllocSplStr
 161  *
 162  * RETURNS
 163  *  Failure: FALSE
 164  *  Success: TRUE
 165  *
 166  */
 167
 168 BOOL WINAPI DllFreeSplStr(LPWSTR pwstr)
 169 {
 170     TRACE("(%s) PTR: %p\n", debugstr_w(pwstr), pwstr);
 171     return HeapFree(GetProcessHeap(), 0, pwstr);
 172 }
 173
 174
 175 /******************************************************************
 176  *   ImpersonatePrinterClient   [SPOOLSS.@]
 177  */
 178 BOOL WINAPI ImpersonatePrinterClient(HANDLE hToken)
 179 {
 180     FIXME("(%p) stub\n", hToken);
 181     return TRUE;
 182 }
 183
 184 /******************************************************************
 185  *   InitializeRouter   [SPOOLSS.@]
 186  */
 187 BOOL WINAPI InitializeRouter(void)
 188 {
 189     TRACE("()\n");
 190     return backend_load_all();
 191 }
 192
 193 /******************************************************************
 194  *   IsLocalCall    [SPOOLSS.@]
 195  */
 196 BOOL WINAPI IsLocalCall(void)
 197 {
 198     FIXME("() stub\n");
 199     return TRUE;
 200 }
 201
 202 /******************************************************************
 203  *   RevertToPrinterSelf   [SPOOLSS.@]
 204  */
 205 HANDLE WINAPI RevertToPrinterSelf(void)
 206 {
 207     FIXME("() stub\n");
 208     return (HANDLE) 0xdead0947;
 209 }
 210
 211 /******************************************************************
 212  *   SplInitializeWinSpoolDrv   [SPOOLSS.@]
 213  *
 214  * Dynamic load "winspool.drv" and fill an array with some function-pointer
 215  *
 216  * PARAMS
 217  *  table  [I] array of function-pointer to fill
 218  *
 219  * RETURNS
 220  *  Success: TRUE
 221  *  Failure: FALSE
 222  *
 223  * NOTES
 224  *  Native "spoolss.dll" from w2k fill the table with 11 Function-Pointer.
 225  *  We implement the XP-Version (The table has only 9 Pointer)
 226  *
 227  */
 228 BOOL WINAPI SplInitializeWinSpoolDrv(LPVOID * table)
 229 {
 230     DWORD res;
 231
 232     TRACE("(%p)\n", table);
 233
 234     hwinspool = LoadLibraryW(winspooldrvW);
 235     if (!hwinspool) return FALSE;
 236
 237     table[0] = (void *) GetProcAddress(hwinspool, "OpenPrinterW");
 238     table[1] = (void *) GetProcAddress(hwinspool, "ClosePrinter");
 239     table[2] = (void *) GetProcAddress(hwinspool, "SpoolerDevQueryPrintW");
 240     table[3] = (void *) GetProcAddress(hwinspool, "SpoolerPrinterEvent");
 241     table[4] = (void *) GetProcAddress(hwinspool, "DocumentPropertiesW");
 242     table[5] = (void *) GetProcAddress(hwinspool, (LPSTR) 212);  /* LoadPrinterDriver */
 243     table[6] = (void *) GetProcAddress(hwinspool, (LPSTR) 213);  /* RefCntLoadDriver */
 244     table[7] = (void *) GetProcAddress(hwinspool, (LPSTR) 214);  /* RefCntUnloadDriver */
 245     table[8] = (void *) GetProcAddress(hwinspool, (LPSTR) 215);  /* ForceUnloadDriver */
 246
 247     for (res = 0; res < 9; res++) {
 248         if (table[res] == NULL) return FALSE;
 249     }
 250
 251     return TRUE;
 252
 253 }
 254
 255 /******************************************************************
 256  *   SplIsUpgrade   [SPOOLSS.@]
 257  */
 258 BOOL WINAPI SplIsUpgrade(void)
 259 {
 260     FIXME("() stub\n");
 261     return FALSE;
 262 }
 263
 264 /******************************************************************
 265  *   SpoolerHasInitialized  [SPOOLSS.@]
 266  */
 267 BOOL WINAPI SpoolerHasInitialized(void)
 268 {
 269     FIXME("() stub\n");
 270     return TRUE;
 271 }
 272
 273 /******************************************************************
 274  *   SpoolerInit   [SPOOLSS.@]
 275  */
 276 BOOL WINAPI SpoolerInit(void)
 277 {
 278     FIXME("() stub\n");
 279     return TRUE;
 280 }
 281
 282 /******************************************************************
 283  *   WaitForSpoolerInitialization   [SPOOLSS.@]
 284  */
 285 BOOL WINAPI WaitForSpoolerInitialization(void)
 286 {
 287     FIXME("() stub\n");
 288     return TRUE;
 289 }