[WINSPOOL.DRV]
[reactos.git] / reactos / dll / win32 / winspool / info.c
1 /*
2 * WINSPOOL functions
3 *
4 * Copyright 1996 John Harvey
5 * Copyright 1998 Andreas Mohr
6 * Copyright 1999 Klaas van Gend
7 * Copyright 1999, 2000 Huw D M Davies
8 * Copyright 2001 Marcus Meissner
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 #include "precomp.h"
26
27 #include <winreg.h>
28 #include <winnls.h>
29 #include <shlwapi.h>
30
31 /******************************************************************************
32 * GetDefaultPrinterA (WINSPOOL.@)
33 */
34 BOOL WINAPI GetDefaultPrinterA(LPSTR name, LPDWORD namesize)
35 {
36 char *ptr;
37
38 if (*namesize < 1)
39 {
40 SetLastError (ERROR_INSUFFICIENT_BUFFER);
41 return FALSE;
42 }
43
44 if (!GetProfileStringA ("windows", "device", "", name, *namesize))
45 {
46 SetLastError (ERROR_FILE_NOT_FOUND);
47 return FALSE;
48 }
49
50 if ((ptr = strchr (name, ',')) == NULL)
51 {
52 SetLastError (ERROR_FILE_NOT_FOUND);
53 return FALSE;
54 }
55
56 *ptr = '\0';
57 *namesize = strlen (name) + 1;
58 return TRUE;
59 }
60
61
62 /******************************************************************************
63 * GetDefaultPrinterW (WINSPOOL.@)
64 */
65 BOOL WINAPI GetDefaultPrinterW(LPWSTR name, LPDWORD namesize)
66 {
67 char *buf;
68 BOOL ret;
69
70 if (*namesize < 1)
71 {
72 SetLastError (ERROR_INSUFFICIENT_BUFFER);
73 return FALSE;
74 }
75
76 buf = HeapAlloc (GetProcessHeap (), 0, *namesize);
77 ret = GetDefaultPrinterA (buf, namesize);
78 if (ret)
79 {
80 DWORD len = MultiByteToWideChar (CP_ACP, 0, buf, -1, name, *namesize);
81 if (!len)
82 {
83 SetLastError (ERROR_INSUFFICIENT_BUFFER);
84 ret = FALSE;
85 }
86 else *namesize = len;
87 }
88
89 HeapFree (GetProcessHeap (), 0, buf);
90 return ret;
91 }
92
93 /******************************************************************************
94 * AddPrintProvidorA (WINSPOOL.@)
95 */
96 BOOL
97 WINAPI
98 AddPrintProvidorA(LPSTR Name, DWORD Level, PBYTE Buffer)
99 {
100 if (Name || Level > 2 || Buffer == NULL)
101 {
102 SetLastError(ERROR_INVALID_PARAMETER);
103 return FALSE;
104 }
105
106 if (Level == 1)
107 {
108 BOOL bRet;
109 PROVIDOR_INFO_1W Provider;
110 PROVIDOR_INFO_1A *Prov = (PROVIDOR_INFO_1A*)Buffer;
111
112 if (Prov->pName == NULL || Prov->pDLLName == NULL || Prov->pEnvironment == NULL)
113 {
114 return FALSE;
115 }
116
117 Provider.pDLLName = HeapAlloc(GetProcessHeap(), 0, (strlen(Prov->pDLLName)+1) * sizeof(WCHAR));
118 if (Provider.pDLLName)
119 {
120 MultiByteToWideChar(CP_ACP, 0, Prov->pDLLName, -1, Provider.pDLLName, strlen(Prov->pDLLName)+1);
121 Provider.pDLLName[strlen(Prov->pDLLName)] = L'\0';
122 }
123
124 Provider.pEnvironment = HeapAlloc(GetProcessHeap(), 0, (strlen(Prov->pEnvironment)+1) * sizeof(WCHAR));
125 if (Provider.pEnvironment)
126 {
127 MultiByteToWideChar(CP_ACP, 0, Prov->pEnvironment, -1, Provider.pEnvironment, strlen(Prov->pEnvironment)+1);
128 Provider.pEnvironment[strlen(Prov->pEnvironment)] = L'\0';
129 }
130
131 Provider.pName = HeapAlloc(GetProcessHeap(), 0, (strlen(Prov->pName)+1) * sizeof(WCHAR));
132 if (Provider.pName)
133 {
134 MultiByteToWideChar(CP_ACP, 0, Prov->pName, -1, Provider.pName, strlen(Prov->pName)+1);
135 Provider.pName[strlen(Prov->pName)] = L'\0';
136 }
137
138 bRet = AddPrintProvidorW(NULL, Level, (LPBYTE)&Provider);
139
140 if (Provider.pDLLName)
141 HeapFree(GetProcessHeap(), 0, Provider.pDLLName);
142
143 if (Provider.pEnvironment)
144 HeapFree(GetProcessHeap(), 0, Provider.pEnvironment);
145
146 if (Provider.pName)
147 HeapFree(GetProcessHeap(), 0, Provider.pName);
148
149 return bRet;
150 }
151 else
152 {
153 PROVIDOR_INFO_2W Provider;
154 PROVIDOR_INFO_2A *Prov = (PROVIDOR_INFO_2A*)Buffer;
155
156 Provider.pOrder = HeapAlloc(GetProcessHeap(), 0, (strlen(Prov->pOrder)+1) * sizeof(WCHAR));
157 if (Provider.pOrder)
158 {
159 BOOL bRet;
160 MultiByteToWideChar(CP_ACP, 0, Prov->pOrder, -1, Provider.pOrder, strlen(Prov->pOrder)+1);
161 Provider.pOrder[strlen(Prov->pOrder)] = L'\0';
162
163 bRet = AddPrintProvidorW(NULL, Level, (LPBYTE)&Provider);
164 HeapFree(GetProcessHeap(), 0, Provider.pOrder);
165 return bRet;
166 }
167 }
168
169 return FALSE;
170 }
171
172
173 /******************************************************************************
174 * AddPrintProvidorW (WINSPOOL.@)
175 */
176 BOOL
177 WINAPI
178 AddPrintProvidorW(LPWSTR Name, DWORD Level, PBYTE Buffer)
179 {
180 HKEY hKey;
181 LPWSTR pOrder;
182 DWORD dwSize, dwType;
183 BOOL bRet = FALSE;
184
185 if (Name || Level > 2 || Buffer == NULL)
186 {
187 SetLastError(ERROR_INVALID_PARAMETER);
188 return FALSE;
189 }
190
191
192 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Print\\Providers", 0, KEY_READ | KEY_WRITE, &hKey) != ERROR_SUCCESS)
193 {
194 return FALSE;
195 }
196
197 if (RegQueryValueExW(hKey, L"Order", NULL, &dwType, NULL, &dwSize) != ERROR_SUCCESS || dwType != REG_MULTI_SZ)
198 {
199 RegCloseKey(hKey);
200 return FALSE;
201 }
202
203 pOrder = HeapAlloc(GetProcessHeap(), 0, dwSize);
204 if (!pOrder)
205 {
206 RegCloseKey(hKey);
207 return FALSE;
208 }
209
210 if (RegQueryValueExW(hKey, L"Order", NULL, &dwType, (LPBYTE)pOrder, &dwSize) != ERROR_SUCCESS || dwType != REG_MULTI_SZ)
211 {
212 RegCloseKey(hKey);
213 return FALSE;
214 }
215
216 if (Level == 1)
217 {
218 LPWSTR pBuffer;
219 BOOL bFound = FALSE;
220 PROVIDOR_INFO_1W * Prov = (PROVIDOR_INFO_1W*)Buffer;
221
222 if (Prov->pName == NULL || Prov->pDLLName == NULL || Prov->pEnvironment == NULL)
223 {
224 SetLastError(ERROR_INVALID_PARAMETER);
225 RegCloseKey(hKey);
226 return FALSE;
227 }
228
229 pBuffer = pOrder;
230
231 while(pBuffer[0])
232 {
233 if (!wcsicmp(pBuffer, Prov->pName))
234 {
235 bFound = TRUE;
236 break;
237 }
238 pBuffer += wcslen(pBuffer) + 1;
239 }
240
241 if (!bFound)
242 {
243 HKEY hSubKey;
244 DWORD dwFullSize = dwSize + (wcslen(Prov->pName)+1) * sizeof(WCHAR);
245
246 if (RegCreateKeyExW(hKey, Prov->pName, 0, NULL, 0, KEY_WRITE, NULL, &hSubKey, NULL) == ERROR_SUCCESS)
247 {
248 RegSetValueExW(hSubKey, L"Name", 0, REG_SZ, (LPBYTE)Prov->pDLLName, (wcslen(Prov->pDLLName)+1) * sizeof(WCHAR));
249 RegCloseKey(hSubKey);
250 }
251
252 pBuffer = HeapAlloc(GetProcessHeap(), 0, dwFullSize);
253 if (pBuffer)
254 {
255 CopyMemory(pBuffer, pOrder, dwSize);
256 wcscpy(&pBuffer[(dwSize/sizeof(WCHAR))-1], Prov->pName);
257 pBuffer[(dwSize/sizeof(WCHAR)) + wcslen(Prov->pName)] = L'\0';
258 RegSetValueExW(hKey, L"Order", 0, REG_MULTI_SZ, (LPBYTE)pBuffer, dwFullSize);
259 HeapFree(GetProcessHeap(), 0, pBuffer);
260 }
261 bRet = TRUE;
262 }
263
264 }
265
266 RegCloseKey(hKey);
267 HeapFree(GetProcessHeap(), 0, pOrder);
268
269 return bRet;
270 }
271
272 /******************************************************************************
273 * DeletePrintProvidorA (WINSPOOL.@)
274 */
275 BOOL
276 WINAPI
277 DeletePrintProvidorA(LPSTR Name, LPSTR Environment, LPSTR PrintProvidor)
278 {
279 BOOL bRet;
280 LPWSTR Env, Prov;
281
282 if (Name || !Environment || !PrintProvidor)
283 {
284 SetLastError(ERROR_INVALID_PARAMETER);
285 return FALSE;
286 }
287
288 Env = HeapAlloc(GetProcessHeap(), 0, (strlen(Environment)+1) * sizeof(WCHAR));
289 if (!Env)
290 {
291 return FALSE;
292 }
293
294 MultiByteToWideChar(CP_ACP, 0, Environment, -1, Env, strlen(Environment)+1);
295 Env[strlen(Environment)] = L'\0';
296
297 Prov = HeapAlloc(GetProcessHeap(), 0, (strlen(PrintProvidor)+1) * sizeof(WCHAR));
298 if (!Prov)
299 {
300 HeapFree(GetProcessHeap(), 0, Env);
301 return FALSE;
302 }
303
304 MultiByteToWideChar(CP_ACP, 0, PrintProvidor, -1, Prov, strlen(PrintProvidor)+1);
305 Prov[strlen(PrintProvidor)] = L'\0';
306
307 bRet = DeletePrintProvidorW(NULL, Env, Prov);
308 HeapFree(GetProcessHeap(), 0, Env);
309 HeapFree(GetProcessHeap(), 0, Prov);
310
311 return bRet;
312 }
313
314 /*
315 * @unimplemented
316 */
317 BOOL
318 WINAPI
319 DeletePrintProvidorW(LPWSTR Name, LPWSTR Environment, LPWSTR PrintProvidor)
320 {
321 HKEY hKey;
322 BOOL bFound;
323 DWORD dwType, dwSize, dwOffset, dwLength;
324 LPWSTR pOrder, pBuffer, pNew;
325
326 if (Name || !Environment || !PrintProvidor)
327 {
328 SetLastError(ERROR_INVALID_PARAMETER);
329 return FALSE;
330 }
331
332 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Print\\Providers", 0, KEY_READ | KEY_WRITE, &hKey) != ERROR_SUCCESS)
333 {
334 return FALSE;
335 }
336
337 if (RegQueryValueExW(hKey, L"Order", NULL, &dwType, NULL, &dwSize) != ERROR_SUCCESS || dwType != REG_MULTI_SZ)
338 {
339 RegCloseKey(hKey);
340 return FALSE;
341 }
342
343 pOrder = HeapAlloc(GetProcessHeap(), 0, dwSize);
344 if (!pOrder)
345 {
346 RegCloseKey(hKey);
347 return FALSE;
348 }
349
350 if (RegQueryValueExW(hKey, L"Order", NULL, &dwType, (LPBYTE)pOrder, &dwSize) != ERROR_SUCCESS || dwType != REG_MULTI_SZ)
351 {
352 RegCloseKey(hKey);
353 return FALSE;
354 }
355
356
357 pBuffer = pOrder;
358 bFound = FALSE;
359 while(pBuffer[0])
360 {
361 if (!wcsicmp(pBuffer, PrintProvidor))
362 {
363 bFound = TRUE;
364 break;
365 }
366 pBuffer += wcslen(pBuffer) + 1;
367 }
368
369 if (!bFound)
370 {
371 RegCloseKey(hKey);
372 HeapFree(GetProcessHeap(), 0, pOrder);
373 return FALSE;
374 }
375
376 pNew = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);
377 if (!pNew)
378 {
379 RegCloseKey(hKey);
380 HeapFree(GetProcessHeap(), 0, pOrder);
381 return FALSE;
382 }
383
384 dwOffset = pBuffer - pOrder;
385 dwLength = (dwSize / sizeof(WCHAR)) - (dwOffset + wcslen(pBuffer) + 1);
386 CopyMemory(pNew, pOrder, dwOffset * sizeof(WCHAR));
387 CopyMemory(&pNew[dwOffset], pBuffer + wcslen(pBuffer) + 1, dwLength);
388
389 RegSetValueExW(hKey, L"Order", 0, REG_MULTI_SZ, (LPBYTE)pNew, (dwOffset + dwLength) * sizeof(WCHAR));
390 RegDeleteKey(hKey, PrintProvidor);
391
392 HeapFree(GetProcessHeap(), 0, pOrder);
393 HeapFree(GetProcessHeap(), 0, pNew);
394 RegCloseKey(hKey);
395
396 return TRUE;
397 }
398
399 /*
400 * @unimplemented
401 */
402 BOOL
403 WINAPI
404 AddMonitorA(LPSTR Name, DWORD Level, PBYTE Monitors)
405 {
406 LPWSTR szName = NULL;
407 MONITOR_INFO_2W Monitor;
408 MONITOR_INFO_2A *pMonitor;
409 BOOL bRet = FALSE;
410
411 if (Level != 2 || !Monitors)
412 {
413 SetLastError(ERROR_INVALID_PARAMETER);
414 return FALSE;
415 }
416
417 pMonitor = (MONITOR_INFO_2A*)Monitors;
418 if (pMonitor->pDLLName == NULL || pMonitor->pName == NULL)
419 {
420 SetLastError(ERROR_INVALID_PARAMETER);
421 return FALSE;
422 }
423
424 ZeroMemory(&Monitor, sizeof(Monitor));
425
426 if (Name)
427 {
428 szName = HeapAlloc(GetProcessHeap(), 0, (strlen(Name) + 1) * sizeof(WCHAR));
429 if (!szName)
430 {
431 return FALSE;
432 }
433 MultiByteToWideChar(CP_ACP, 0, Name, -1, szName, strlen(Name)+1);
434 szName[strlen(Name)] = L'\0';
435 }
436
437 Monitor.pDLLName = HeapAlloc(GetProcessHeap(), 0, (strlen(pMonitor->pDLLName)+1) * sizeof(WCHAR));
438 if (!Monitor.pDLLName)
439 {
440 goto cleanup;
441 }
442 MultiByteToWideChar(CP_ACP, 0, pMonitor->pDLLName, -1, Monitor.pDLLName, strlen(pMonitor->pDLLName)+1);
443 pMonitor->pDLLName[strlen(pMonitor->pDLLName)] = L'\0';
444
445 Monitor.pName = HeapAlloc(GetProcessHeap(), 0, (strlen(pMonitor->pName)+1) * sizeof(WCHAR));
446 if (!Monitor.pName)
447 {
448 goto cleanup;
449 }
450 MultiByteToWideChar(CP_ACP, 0, pMonitor->pName, -1, Monitor.pName, strlen(pMonitor->pName)+1);
451 pMonitor->pName[strlen(pMonitor->pName)] = L'\0';
452
453
454 if (pMonitor->pEnvironment)
455 {
456 Monitor.pEnvironment = HeapAlloc(GetProcessHeap(), 0, (strlen(pMonitor->pEnvironment)+1) * sizeof(WCHAR));
457 if (!Monitor.pEnvironment)
458 {
459 goto cleanup;
460 }
461 MultiByteToWideChar(CP_ACP, 0, pMonitor->pEnvironment, -1, Monitor.pEnvironment, strlen(pMonitor->pEnvironment)+1);
462 pMonitor->pEnvironment[strlen(pMonitor->pEnvironment)] = L'\0';
463 }
464
465 bRet = AddMonitorW(szName, Level, (LPBYTE)&Monitor);
466
467 cleanup:
468
469 if (szName)
470 HeapFree(GetProcessHeap(), 0, szName);
471
472 if (Monitor.pDLLName)
473 HeapFree(GetProcessHeap(), 0, Monitor.pDLLName);
474
475 if (Monitor.pEnvironment)
476 HeapFree(GetProcessHeap(), 0, Monitor.pEnvironment);
477
478 if (Monitor.pName)
479 HeapFree(GetProcessHeap(), 0, Monitor.pName);
480
481 return bRet;
482 }
483
484
485 /*
486 * @unimplemented
487 */
488 BOOL
489 WINAPI
490 AddMonitorW(LPWSTR Name, DWORD Level, PBYTE Monitors)
491 {
492 WCHAR szPath[MAX_PATH];
493 HMODULE hLibrary = NULL;
494 FARPROC InitProc;
495 HKEY hKey, hSubKey;
496 MONITOR_INFO_2W * pMonitor;
497
498
499 if (Level != 2 || !Monitors)
500 {
501 SetLastError(ERROR_INVALID_PARAMETER);
502 return FALSE;
503 }
504
505 pMonitor = (MONITOR_INFO_2W*)Monitors;
506
507 if (pMonitor->pDLLName == NULL || pMonitor->pName == NULL)
508 {
509 SetLastError(ERROR_INVALID_PARAMETER);
510 return FALSE;
511 }
512
513 if (wcschr(pMonitor->pDLLName, L'\\'))
514 {
515 hLibrary = LoadLibraryExW(pMonitor->pDLLName, NULL, 0);
516 }
517 else if (GetSystemDirectoryW(szPath, MAX_PATH) && PathAddBackslashW(szPath))
518 {
519 wcscat(szPath, pMonitor->pDLLName);
520 hLibrary = LoadLibraryExW(szPath, NULL, 0);
521 }
522
523 if (!hLibrary)
524 {
525 return FALSE;
526 }
527
528 InitProc = GetProcAddress(hLibrary, "InitializePrintMonitor");
529 if (!InitProc)
530 {
531 InitProc = GetProcAddress(hLibrary, "InitializePrintMonitor2");
532 if (!InitProc)
533 {
534 FreeLibrary(hLibrary);
535 SetLastError(ERROR_PROC_NOT_FOUND);
536 return FALSE;
537 }
538 }
539
540 // FIXME
541 // Initialize monitor
542 FreeLibrary(hLibrary);
543
544 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors", 0, KEY_WRITE, &hKey) == ERROR_SUCCESS)
545 {
546 if (RegCreateKeyExW(hKey, pMonitor->pName, 0, NULL, 0, KEY_WRITE, NULL, &hSubKey, NULL) == ERROR_SUCCESS)
547 {
548 RegSetValueExW(hSubKey, L"Driver", 0, REG_SZ, (LPBYTE)pMonitor->pDLLName, (wcslen(pMonitor->pDLLName)+1)*sizeof(WCHAR));
549 RegCloseKey(hSubKey);
550 }
551 RegCloseKey(hKey);
552 }
553 return TRUE;
554 }
555