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