ec3b1782ddcc5d34d040930bc6df278454b65dd8
[reactos.git] / reactos / lib / setupapi / misc.c
1 /*
2 * Setupapi miscellaneous functions
3 *
4 * Copyright 2005 Eric Kohl
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "setupapi_private.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
24
25 /**************************************************************************
26 * MyFree [SETUPAPI.@]
27 *
28 * Frees an allocated memory block from the process heap.
29 *
30 * PARAMS
31 * lpMem [I] pointer to memory block which will be freed
32 *
33 * RETURNS
34 * None
35 */
36 VOID WINAPI MyFree(LPVOID lpMem)
37 {
38 TRACE("%p\n", lpMem);
39 HeapFree(GetProcessHeap(), 0, lpMem);
40 }
41
42
43 /**************************************************************************
44 * MyMalloc [SETUPAPI.@]
45 *
46 * Allocates memory block from the process heap.
47 *
48 * PARAMS
49 * dwSize [I] size of the allocated memory block
50 *
51 * RETURNS
52 * Success: pointer to allocated memory block
53 * Failure: NULL
54 */
55 LPVOID WINAPI MyMalloc(DWORD dwSize)
56 {
57 TRACE("%lu\n", dwSize);
58 return HeapAlloc(GetProcessHeap(), 0, dwSize);
59 }
60
61
62 /**************************************************************************
63 * MyRealloc [SETUPAPI.@]
64 *
65 * Changes the size of an allocated memory block or allocates a memory
66 * block from the process heap.
67 *
68 * PARAMS
69 * lpSrc [I] pointer to memory block which will be resized
70 * dwSize [I] new size of the memory block
71 *
72 * RETURNS
73 * Success: pointer to the resized memory block
74 * Failure: NULL
75 *
76 * NOTES
77 * If lpSrc is a NULL-pointer, then MyRealloc allocates a memory
78 * block like MyMalloc.
79 */
80 LPVOID WINAPI MyRealloc(LPVOID lpSrc, DWORD dwSize)
81 {
82 TRACE("%p %lu\n", lpSrc, dwSize);
83
84 if (lpSrc == NULL)
85 return HeapAlloc(GetProcessHeap(), 0, dwSize);
86
87 return HeapReAlloc(GetProcessHeap(), 0, lpSrc, dwSize);
88 }
89
90
91 /**************************************************************************
92 * DuplicateString [SETUPAPI.@]
93 *
94 * Duplicates a unicode string.
95 *
96 * PARAMS
97 * lpSrc [I] pointer to the unicode string that will be duplicated
98 *
99 * RETURNS
100 * Success: pointer to the duplicated unicode string
101 * Failure: NULL
102 *
103 * NOTES
104 * Call MyFree() to release the duplicated string.
105 */
106 LPWSTR WINAPI DuplicateString(LPCWSTR lpSrc)
107 {
108 LPWSTR lpDst;
109
110 TRACE("%s\n", debugstr_w(lpSrc));
111
112 lpDst = MyMalloc((lstrlenW(lpSrc) + 1) * sizeof(WCHAR));
113 if (lpDst == NULL)
114 return NULL;
115
116 strcpyW(lpDst, lpSrc);
117
118 return lpDst;
119 }
120
121
122 /**************************************************************************
123 * QueryRegistryValue [SETUPAPI.@]
124 *
125 * Retrieves value data from the registry and allocates memory for the
126 * value data.
127 *
128 * PARAMS
129 * hKey [I] Handle of the key to query
130 * lpValueName [I] Name of value under hkey to query
131 * lpData [O] Destination for the values contents,
132 * lpType [O] Destination for the value type
133 * lpcbData [O] Destination for the size of data
134 *
135 * RETURNS
136 * Success: ERROR_SUCCESS
137 * Failure: Otherwise
138 *
139 * NOTES
140 * Use MyFree to release the lpData buffer.
141 */
142 LONG WINAPI QueryRegistryValue(HKEY hKey,
143 LPCWSTR lpValueName,
144 LPBYTE *lpData,
145 LPDWORD lpType,
146 LPDWORD lpcbData)
147 {
148 LONG lError;
149
150 TRACE("%p %s %p %p %p\n",
151 hKey, debugstr_w(lpValueName), lpData, lpType, lpcbData);
152
153 /* Get required buffer size */
154 *lpcbData = 0;
155 lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, NULL, lpcbData);
156 if (lError != ERROR_SUCCESS)
157 return lError;
158
159 /* Allocate buffer */
160 *lpData = MyMalloc(*lpcbData);
161 if (*lpData == NULL)
162 return ERROR_NOT_ENOUGH_MEMORY;
163
164 /* Query registry value */
165 lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, *lpData, lpcbData);
166 if (lError != ERROR_SUCCESS)
167 MyFree(*lpData);
168
169 return lError;
170 }
171
172
173 /**************************************************************************
174 * IsUserAdmin [SETUPAPI.@]
175 *
176 * Checks whether the current user is a member of the Administrators group.
177 *
178 * PARAMS
179 * None
180 *
181 * RETURNS
182 * Success: TRUE
183 * Failure: FALSE
184 */
185 BOOL WINAPI IsUserAdmin(VOID)
186 {
187 SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
188 HANDLE hToken;
189 DWORD dwSize;
190 PTOKEN_GROUPS lpGroups;
191 PSID lpSid;
192 DWORD i;
193 BOOL bResult = FALSE;
194
195 TRACE("\n");
196
197 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
198 {
199 return FALSE;
200 }
201
202 if (!GetTokenInformation(hToken, TokenGroups, NULL, 0, &dwSize))
203 {
204 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
205 {
206 CloseHandle(hToken);
207 return FALSE;
208 }
209 }
210
211 lpGroups = MyMalloc(dwSize);
212 if (lpGroups == NULL)
213 {
214 CloseHandle(hToken);
215 return FALSE;
216 }
217
218 if (!GetTokenInformation(hToken, TokenGroups, lpGroups, dwSize, &dwSize))
219 {
220 MyFree(lpGroups);
221 CloseHandle(hToken);
222 return FALSE;
223 }
224
225 CloseHandle(hToken);
226
227 if (!AllocateAndInitializeSid(&Authority, 2, SECURITY_BUILTIN_DOMAIN_RID,
228 DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
229 &lpSid))
230 {
231 MyFree(lpGroups);
232 return FALSE;
233 }
234
235 for (i = 0; i < lpGroups->GroupCount; i++)
236 {
237 if (EqualSid(lpSid, &lpGroups->Groups[i].Sid))
238 {
239 bResult = TRUE;
240 break;
241 }
242 }
243
244 FreeSid(lpSid);
245 MyFree(lpGroups);
246
247 return bResult;
248 }
249
250
251 /**************************************************************************
252 * MultiByteToUnicode [SETUPAPI.@]
253 *
254 * Converts a multi-byte string to a Unicode string.
255 *
256 * PARAMS
257 * lpMultiByteStr [I] Multi-byte string to be converted
258 * uCodePage [I] Code page
259 *
260 * RETURNS
261 * Success: pointer to the converted Unicode string
262 * Failure: NULL
263 *
264 * NOTE
265 * Use MyFree to release the returned Unicode string.
266 */
267 LPWSTR WINAPI MultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
268 {
269 LPWSTR lpUnicodeStr;
270 int nLength;
271
272 TRACE("%s %d\n", debugstr_a(lpMultiByteStr), uCodePage);
273
274 nLength = MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
275 -1, NULL, 0);
276 if (nLength == 0)
277 return NULL;
278
279 lpUnicodeStr = MyMalloc(nLength * sizeof(WCHAR));
280 if (lpUnicodeStr == NULL)
281 return NULL;
282
283 if (!MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
284 nLength, lpUnicodeStr, nLength))
285 {
286 MyFree(lpUnicodeStr);
287 return NULL;
288 }
289
290 return lpUnicodeStr;
291 }
292
293
294 /**************************************************************************
295 * UnicodeToMultiByte [SETUPAPI.@]
296 *
297 * Converts a Unicode string to a multi-byte string.
298 *
299 * PARAMS
300 * lpUnicodeStr [I] Unicode string to be converted
301 * uCodePage [I] Code page
302 *
303 * RETURNS
304 * Success: pointer to the converted multi-byte string
305 * Failure: NULL
306 *
307 * NOTE
308 * Use MyFree to release the returned multi-byte string.
309 */
310 LPSTR WINAPI UnicodeToMultiByte(LPCWSTR lpUnicodeStr, UINT uCodePage)
311 {
312 LPSTR lpMultiByteStr;
313 int nLength;
314
315 TRACE("%s %d\n", debugstr_w(lpUnicodeStr), uCodePage);
316
317 nLength = WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
318 NULL, 0, NULL, NULL);
319 if (nLength == 0)
320 return NULL;
321
322 lpMultiByteStr = MyMalloc(nLength);
323 if (lpMultiByteStr == NULL)
324 return NULL;
325
326 if (!WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
327 lpMultiByteStr, nLength, NULL, NULL))
328 {
329 MyFree(lpMultiByteStr);
330 return NULL;
331 }
332
333 return lpMultiByteStr;
334 }
335
336
337 /**************************************************************************
338 * DoesUserHavePrivilege [SETUPAPI.@]
339 *
340 * Check whether the current user has got a given privilege.
341 *
342 * PARAMS
343 * lpPrivilegeName [I] Name of the privilege to be checked
344 *
345 * RETURNS
346 * Success: TRUE
347 * Failure: FALSE
348 */
349 BOOL WINAPI DoesUserHavePrivilege(LPCWSTR lpPrivilegeName)
350 {
351 HANDLE hToken;
352 DWORD dwSize;
353 PTOKEN_PRIVILEGES lpPrivileges;
354 LUID PrivilegeLuid;
355 DWORD i;
356 BOOL bResult = FALSE;
357
358 TRACE("%s\n", debugstr_w(lpPrivilegeName));
359
360 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
361 return FALSE;
362
363 if (!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwSize))
364 {
365 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
366 {
367 CloseHandle(hToken);
368 return FALSE;
369 }
370 }
371
372 lpPrivileges = MyMalloc(dwSize);
373 if (lpPrivileges == NULL)
374 {
375 CloseHandle(hToken);
376 return FALSE;
377 }
378
379 if (!GetTokenInformation(hToken, TokenPrivileges, lpPrivileges, dwSize, &dwSize))
380 {
381 MyFree(lpPrivileges);
382 CloseHandle(hToken);
383 return FALSE;
384 }
385
386 CloseHandle(hToken);
387
388 if (!LookupPrivilegeValueW(NULL, lpPrivilegeName, &PrivilegeLuid))
389 {
390 MyFree(lpPrivileges);
391 return FALSE;
392 }
393
394 for (i = 0; i < lpPrivileges->PrivilegeCount; i++)
395 {
396 if (lpPrivileges->Privileges[i].Luid.HighPart == PrivilegeLuid.HighPart &&
397 lpPrivileges->Privileges[i].Luid.LowPart == PrivilegeLuid.LowPart)
398 {
399 bResult = TRUE;
400 }
401 }
402
403 MyFree(lpPrivileges);
404
405 return bResult;
406 }
407
408
409 /**************************************************************************
410 * EnablePrivilege [SETUPAPI.@]
411 *
412 * Enables or disables one of the current users privileges.
413 *
414 * PARAMS
415 * lpPrivilegeName [I] Name of the privilege to be changed
416 * bEnable [I] TRUE: Enables the privilege
417 * FALSE: Disables the privilege
418 *
419 * RETURNS
420 * Success: TRUE
421 * Failure: FALSE
422 */
423 BOOL WINAPI EnablePrivilege(LPCWSTR lpPrivilegeName, BOOL bEnable)
424 {
425 TOKEN_PRIVILEGES Privileges;
426 HANDLE hToken;
427 BOOL bResult;
428
429 TRACE("%s %s\n", debugstr_w(lpPrivilegeName), bEnable ? "TRUE" : "FALSE");
430
431 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
432 return FALSE;
433
434 Privileges.PrivilegeCount = 1;
435 Privileges.Privileges[0].Attributes = (bEnable) ? SE_PRIVILEGE_ENABLED : 0;
436
437 if (!LookupPrivilegeValueW(NULL, lpPrivilegeName,
438 &Privileges.Privileges[0].Luid))
439 {
440 CloseHandle(hToken);
441 return FALSE;
442 }
443
444 bResult = AdjustTokenPrivileges(hToken, FALSE, &Privileges, 0, NULL, NULL);
445
446 CloseHandle(hToken);
447
448 return bResult;
449 }
450
451
452 /**************************************************************************
453 * DelayedMove [SETUPAPI.@]
454 *
455 * Moves a file upon the next reboot.
456 *
457 * PARAMS
458 * lpExistingFileName [I] Current file name
459 * lpNewFileName [I] New file name
460 *
461 * RETURNS
462 * Success: TRUE
463 * Failure: FALSE
464 */
465 BOOL WINAPI DelayedMove(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName)
466 {
467 if (OsVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
468 {
469 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
470 return FALSE;
471 }
472
473 return MoveFileExW(lpExistingFileName, lpNewFileName,
474 MOVEFILE_REPLACE_EXISTING | MOVEFILE_DELAY_UNTIL_REBOOT);
475 }
476
477
478 /**************************************************************************
479 * FileExists [SETUPAPI.@]
480 *
481 * Checks whether a file exists.
482 *
483 * PARAMS
484 * lpFileName [I] Name of the file to check
485 * lpNewFileName [O] Optional information about the existing file
486 *
487 * RETURNS
488 * Success: TRUE
489 * Failure: FALSE
490 */
491 BOOL WINAPI FileExists(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFileFindData)
492 {
493 WIN32_FIND_DATAW FindData;
494 HANDLE hFind;
495 UINT uErrorMode;
496 DWORD dwError;
497
498 uErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
499
500 hFind = FindFirstFileW(lpFileName, &FindData);
501 if (hFind == INVALID_HANDLE_VALUE)
502 {
503 dwError = GetLastError();
504 SetErrorMode(uErrorMode);
505 SetLastError(dwError);
506 return FALSE;
507 }
508
509 FindClose(hFind);
510
511 if (lpFileFindData)
512 memcpy(lpFileFindData, &FindData, sizeof(WIN32_FIND_DATAW));
513
514 SetErrorMode(uErrorMode);
515
516 return TRUE;
517 }
518
519
520 /**************************************************************************
521 * CaptureStringArg [SETUPAPI.@]
522 *
523 * Captures a UNICODE string.
524 *
525 * PARAMS
526 * lpSrc [I] UNICODE string to be captured
527 * lpDst [O] Pointer to the captured UNICODE string
528 *
529 * RETURNS
530 * Success: ERROR_SUCCESS
531 * Failure: ERROR_INVALID_PARAMETER
532 *
533 * NOTE
534 * Call MyFree to release the captured UNICODE string.
535 */
536 DWORD WINAPI CaptureStringArg(LPCWSTR pSrc, LPWSTR *pDst)
537 {
538 if (pDst == NULL)
539 return ERROR_INVALID_PARAMETER;
540
541 *pDst = DuplicateString(pSrc);
542
543 return ERROR_SUCCESS;
544 }
545
546
547 /**************************************************************************
548 * CaptureAndConvertAnsiArg [SETUPAPI.@]
549 *
550 * Captures an ANSI string and converts it to a UNICODE string.
551 *
552 * PARAMS
553 * lpSrc [I] ANSI string to be captured
554 * lpDst [O] Pointer to the captured UNICODE string
555 *
556 * RETURNS
557 * Success: ERROR_SUCCESS
558 * Failure: ERROR_INVALID_PARAMETER
559 *
560 * NOTE
561 * Call MyFree to release the captured UNICODE string.
562 */
563 DWORD WINAPI CaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
564 {
565 if (pDst == NULL)
566 return ERROR_INVALID_PARAMETER;
567
568 *pDst = MultiByteToUnicode(pSrc, CP_ACP);
569
570 return ERROR_SUCCESS;
571 }
572
573
574 /**************************************************************************
575 * OpenAndMapFileForRead [SETUPAPI.@]
576 *
577 * Open and map a file to a buffer.
578 *
579 * PARAMS
580 * lpFileName [I] Name of the file to be opened
581 * lpSize [O] Pointer to the file size
582 * lpFile [0] Pointer to the file handle
583 * lpMapping [0] Pointer to the mapping handle
584 * lpBuffer [0] Pointer to the file buffer
585 *
586 * RETURNS
587 * Success: ERROR_SUCCESS
588 * Failure: Other
589 *
590 * NOTE
591 * Call UnmapAndCloseFile to release the file.
592 */
593 DWORD WINAPI OpenAndMapFileForRead(LPCWSTR lpFileName,
594 LPDWORD lpSize,
595 LPHANDLE lpFile,
596 LPHANDLE lpMapping,
597 LPVOID *lpBuffer)
598 {
599 DWORD dwError;
600
601 TRACE("%s %p %p %p %p\n",
602 debugstr_w(lpFileName), lpSize, lpFile, lpMapping, lpBuffer);
603
604 *lpFile = CreateFileW(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
605 OPEN_EXISTING, 0, NULL);
606 if (*lpFile == INVALID_HANDLE_VALUE)
607 return GetLastError();
608
609 *lpSize = GetFileSize(*lpFile, NULL);
610 if (*lpSize == INVALID_FILE_SIZE)
611 {
612 dwError = GetLastError();
613 CloseHandle(*lpFile);
614 return dwError;
615 }
616
617 *lpMapping = CreateFileMappingW(*lpFile, NULL, PAGE_READONLY, 0,
618 *lpSize, NULL);
619 if (*lpMapping == NULL)
620 {
621 dwError = GetLastError();
622 CloseHandle(*lpFile);
623 return dwError;
624 }
625
626 *lpBuffer = MapViewOfFile(*lpMapping, FILE_MAP_READ, 0, 0, *lpSize);
627 if (*lpBuffer == NULL)
628 {
629 dwError = GetLastError();
630 CloseHandle(*lpMapping);
631 CloseHandle(*lpFile);
632 return dwError;
633 }
634
635 return ERROR_SUCCESS;
636 }
637
638
639 /**************************************************************************
640 * UnmapAndCloseFile [SETUPAPI.@]
641 *
642 * Unmap and close a mapped file.
643 *
644 * PARAMS
645 * hFile [I] Handle to the file
646 * hMapping [I] Handle to the file mapping
647 * lpBuffer [I] Pointer to the file buffer
648 *
649 * RETURNS
650 * Success: TRUE
651 * Failure: FALSE
652 */
653 BOOL WINAPI UnmapAndCloseFile(HANDLE hFile, HANDLE hMapping, LPVOID lpBuffer)
654 {
655 TRACE("%p %p %p\n",
656 hFile, hMapping, lpBuffer);
657
658 if (!UnmapViewOfFile(lpBuffer))
659 return FALSE;
660
661 if (!CloseHandle(hMapping))
662 return FALSE;
663
664 if (!CloseHandle(hFile))
665 return FALSE;
666
667 return TRUE;
668 }
669
670
671 /**************************************************************************
672 * StampFileSecurity [SETUPAPI.@]
673 *
674 * Assign a new security descriptor to the given file.
675 *
676 * PARAMS
677 * lpFileName [I] Name of the file
678 * pSecurityDescriptor [I] New security descriptor
679 *
680 * RETURNS
681 * Success: ERROR_SUCCESS
682 * Failure: other
683 */
684 DWORD WINAPI StampFileSecurity(LPCWSTR lpFileName, PSECURITY_DESCRIPTOR pSecurityDescriptor)
685 {
686 TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
687
688 if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
689 GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
690 pSecurityDescriptor))
691 return GetLastError();
692
693 return ERROR_SUCCESS;
694 }
695
696
697 /**************************************************************************
698 * TakeOwnershipOfFile [SETUPAPI.@]
699 *
700 * Takes the ownership of the given file.
701 *
702 * PARAMS
703 * lpFileName [I] Name of the file
704 *
705 * RETURNS
706 * Success: ERROR_SUCCESS
707 * Failure: other
708 */
709 DWORD WINAPI TakeOwnershipOfFile(LPCWSTR lpFileName)
710 {
711 SECURITY_DESCRIPTOR SecDesc;
712 HANDLE hToken = NULL;
713 PTOKEN_OWNER pOwner = NULL;
714 DWORD dwError;
715 DWORD dwSize;
716
717 TRACE("%s\n", debugstr_w(lpFileName));
718
719 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
720 return GetLastError();
721
722 if (!GetTokenInformation(hToken, TokenOwner, NULL, 0, &dwSize))
723 {
724 goto fail;
725 }
726
727 pOwner = (PTOKEN_OWNER)MyMalloc(dwSize);
728 if (pOwner == NULL)
729 {
730 CloseHandle(hToken);
731 return ERROR_NOT_ENOUGH_MEMORY;
732 }
733
734 if (!GetTokenInformation(hToken, TokenOwner, pOwner, dwSize, &dwSize))
735 {
736 goto fail;
737 }
738
739 if (!InitializeSecurityDescriptor(&SecDesc, SECURITY_DESCRIPTOR_REVISION))
740 {
741 goto fail;
742 }
743
744 if (!SetSecurityDescriptorOwner(&SecDesc, pOwner->Owner, FALSE))
745 {
746 goto fail;
747 }
748
749 if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION, &SecDesc))
750 {
751 goto fail;
752 }
753
754 MyFree(pOwner);
755 CloseHandle(hToken);
756
757 return ERROR_SUCCESS;
758
759 fail:;
760 dwError = GetLastError();
761
762 if (pOwner != NULL)
763 MyFree(pOwner);
764
765 if (hToken != NULL)
766 CloseHandle(hToken);
767
768 return dwError;
769 }
770
771
772 /**************************************************************************
773 * RetreiveFileSecurity [SETUPAPI.@]
774 *
775 * Retrieve the security descriptor that is associated with the given file.
776 *
777 * PARAMS
778 * lpFileName [I] Name of the file
779 *
780 * RETURNS
781 * Success: ERROR_SUCCESS
782 * Failure: other
783 */
784 DWORD WINAPI RetreiveFileSecurity(LPCWSTR lpFileName,
785 PSECURITY_DESCRIPTOR *pSecurityDescriptor)
786 {
787 PSECURITY_DESCRIPTOR SecDesc;
788 DWORD dwSize = 0x100;
789 DWORD dwError;
790
791 TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
792
793 SecDesc = (PSECURITY_DESCRIPTOR)MyMalloc(dwSize);
794 if (SecDesc == NULL)
795 return ERROR_NOT_ENOUGH_MEMORY;
796
797 if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
798 GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
799 SecDesc, dwSize, &dwSize))
800 {
801 *pSecurityDescriptor = SecDesc;
802 return ERROR_SUCCESS;
803 }
804
805 dwError = GetLastError();
806 if (dwError != ERROR_INSUFFICIENT_BUFFER)
807 {
808 MyFree(SecDesc);
809 return dwError;
810 }
811
812 SecDesc = (PSECURITY_DESCRIPTOR)MyRealloc(SecDesc, dwSize);
813 if (SecDesc == NULL)
814 return ERROR_NOT_ENOUGH_MEMORY;
815
816 if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
817 GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
818 SecDesc, dwSize, &dwSize))
819 {
820 *pSecurityDescriptor = SecDesc;
821 return ERROR_SUCCESS;
822 }
823
824 dwError = GetLastError();
825 MyFree(SecDesc);
826
827 return dwError;
828 }
829
830
831 /**************************************************************************
832 * AssertFail [SETUPAPI.@]
833 *
834 * Display an assertion message.
835 *
836 * PARAMS
837 * lpFile [I] File name
838 * uLine [I] Line number
839 * lpMessage [I] Assertion message
840 *
841 * RETURNS
842 * Nothing
843 */
844 VOID WINAPI AssertFail(LPSTR lpFile, UINT uLine, LPSTR lpMessage)
845 {
846 CHAR szModule[MAX_PATH];
847 CHAR szBuffer[2048];
848 LPSTR lpName;
849 // LPSTR lpBuffer;
850
851 TRACE("%s %u %s\n", lpFile, uLine, lpMessage);
852
853 GetModuleFileNameA(hInstance, szModule, MAX_PATH);
854 lpName = strrchr(szModule, '\\');
855 if (lpName != NULL)
856 lpName++;
857 else
858 lpName = szModule;
859
860 wsprintfA(szBuffer,
861 "Assertion failure at line %u in file %s: %s\n\nCall DebugBreak()?",
862 uLine, lpFile, lpMessage);
863
864 if (MessageBoxA(NULL, szBuffer, lpName, MB_SETFOREGROUND |
865 MB_TASKMODAL | MB_ICONERROR | MB_YESNO) == IDYES)
866 DebugBreak();
867 }
868
869
870 /**************************************************************************
871 * GetSetFileTimestamp [SETUPAPI.@]
872 *
873 * Gets or sets a files timestamp.
874 *
875 * PARAMS
876 * lpFileName [I] File name
877 * lpCreationTime [I/O] Creation time
878 * lpLastAccessTime [I/O] Last access time
879 * lpLastWriteTime [I/O] Last write time
880 * bSetFileTime [I] TRUE: Set file times
881 * FALSE: Get file times
882 *
883 * RETURNS
884 * Success: ERROR_SUCCESS
885 * Failure: other
886 */
887 DWORD WINAPI GetSetFileTimestamp(LPCWSTR lpFileName,
888 LPFILETIME lpCreationTime,
889 LPFILETIME lpLastAccessTime,
890 LPFILETIME lpLastWriteTime,
891 BOOLEAN bSetFileTime)
892 {
893 HANDLE hFile;
894 BOOLEAN bRet;
895 DWORD dwError = ERROR_SUCCESS;
896
897 TRACE("%s %p %p %p %x\n", debugstr_w(lpFileName), lpCreationTime,
898 lpLastAccessTime, lpLastWriteTime, bSetFileTime);
899
900 hFile = CreateFileW(lpFileName,
901 bSetFileTime ? GENERIC_WRITE : GENERIC_READ,
902 FILE_SHARE_READ | FILE_SHARE_WRITE,
903 NULL,
904 OPEN_EXISTING,
905 0,
906 NULL);
907
908 if (hFile == INVALID_HANDLE_VALUE)
909 return GetLastError();
910
911 if (bSetFileTime)
912 bRet = SetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
913 else
914 bRet = GetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
915
916 if (bRet == FALSE)
917 dwError = GetLastError();
918
919 CloseHandle(hFile);
920
921 return dwError;
922 }
923
924
925 /**************************************************************************
926 * MyGetFileTitle [SETUPAPI.@]
927 *
928 * Returns a pointer to the last part of a fully qualified file name.
929 *
930 * PARAMS
931 * lpFileName [I] File name
932 *
933 * RETURNS
934 * Pointer to a files name.
935 */
936 LPWSTR WINAPI
937 MyGetFileTitle(LPCWSTR lpFileName)
938 {
939 LPWSTR ptr;
940 LPWSTR ret;
941 WCHAR c;
942
943 TRACE("%s\n", debugstr_w(lpFileName));
944
945 ptr = (LPWSTR)lpFileName;
946 ret = ptr;
947 while (TRUE)
948 {
949 c = *ptr;
950
951 if (c == 0)
952 break;
953
954 ptr++;
955 if (c == (WCHAR)'\\' || c == (WCHAR)'/' || c == (WCHAR)':')
956 ret = ptr;
957 }
958
959 return ret;
960 }
961
962
963 /**************************************************************************
964 * ConcatenatePaths [SETUPAPI.@]
965 *
966 * Concatenates two paths.
967 *
968 * PARAMS
969 * lpPath [I/O] Path to append path to
970 * lpAppend [I] Path to append
971 * dwBufferSize [I] Size of the path buffer
972 * lpRequiredSize [O] Required size for the concatenated path. Optional
973 *
974 * RETURNS
975 * Success: TRUE
976 * Failure: FALSE
977 */
978 BOOL WINAPI
979 ConcatenatePaths(LPWSTR lpPath,
980 LPCWSTR lpAppend,
981 DWORD dwBufferSize,
982 LPDWORD lpRequiredSize)
983 {
984 DWORD dwPathSize;
985 DWORD dwAppendSize;
986 DWORD dwTotalSize;
987 BOOL bBackslash = FALSE;
988
989 TRACE("%s %s %lu %p\n", debugstr_w(lpPath), debugstr_w(lpAppend),
990 dwBufferSize, lpRequiredSize);
991
992 dwPathSize = lstrlenW(lpPath);
993
994 /* Ignore trailing backslash */
995 if (lpPath[dwPathSize - 1] == (WCHAR)'\\')
996 dwPathSize--;
997
998 dwAppendSize = lstrlenW(lpAppend);
999
1000 /* Does the source string have a leading backslash? */
1001 if (lpAppend[0] == (WCHAR)'\\')
1002 {
1003 bBackslash = TRUE;
1004 dwAppendSize--;
1005 }
1006
1007 dwTotalSize = dwPathSize + dwAppendSize + 2;
1008 if (lpRequiredSize != NULL)
1009 *lpRequiredSize = dwTotalSize;
1010
1011 /* Append a backslash to the destination string */
1012 if (bBackslash == FALSE)
1013 {
1014 if (dwPathSize < dwBufferSize)
1015 {
1016 lpPath[dwPathSize - 1] = (WCHAR)'\\';
1017 dwPathSize++;
1018 }
1019 }
1020
1021 if (dwPathSize + dwAppendSize < dwBufferSize)
1022 {
1023 lstrcpynW(&lpPath[dwPathSize],
1024 lpAppend,
1025 dwAppendSize);
1026 }
1027
1028 if (dwBufferSize >= dwTotalSize)
1029 lpPath[dwTotalSize - 1] = 0;
1030
1031 return (dwBufferSize >= dwTotalSize);
1032 }
1033
1034
1035 /**************************************************************************
1036 * CenterWindowRelativeToParent [SETUPAPI.@]
1037 *
1038 * Centers a window relative to its parent.
1039 *
1040 * PARAMS
1041 * hwnd [I] Window to center.
1042 *
1043 * RETURNS
1044 * None
1045 */
1046 VOID WINAPI
1047 CenterWindowRelativeToParent(HWND hwnd)
1048 {
1049 HWND hwndOwner;
1050 POINT ptOrigin;
1051 RECT rcWindow;
1052 RECT rcOwner;
1053 INT nWindowWidth, nWindowHeight;
1054 INT nOwnerWidth, nOwnerHeight;
1055 INT posX, posY;
1056
1057 hwndOwner = GetWindow(hwnd, GW_OWNER);
1058 if (hwndOwner == NULL)
1059 return;
1060
1061 ptOrigin.x = 0;
1062 ptOrigin.y = 0;
1063 ClientToScreen(hwndOwner, &ptOrigin);
1064
1065 GetWindowRect(hwnd, &rcWindow);
1066 GetClientRect(hwndOwner, &rcOwner);
1067
1068 nWindowWidth = rcWindow.right - rcWindow.left;
1069 nWindowHeight = rcWindow.bottom - rcWindow.top;
1070
1071 nOwnerWidth = rcOwner.right - rcOwner.left;
1072 nOwnerHeight = rcOwner.bottom - rcOwner.top;
1073
1074 posX = ((nOwnerWidth - nWindowWidth) / 2) + ptOrigin.x;
1075 posY = ((nOwnerHeight - nWindowHeight) / 2) + ptOrigin.y;
1076
1077 MoveWindow(hwnd, posX, posY, nWindowHeight, nWindowWidth, 0);
1078 }
1079
1080
1081 /**************************************************************************
1082 * GetVersionInfoFromImage [SETUPAPI.@]
1083 *
1084 * Retrieves version information for a given file.
1085 *
1086 * PARAMS
1087 * lpFileName [I] File name
1088 * lpFileVersion [O] Pointer to the full file version
1089 * lpVersionVarSize [O] Pointer to the size of the variable version
1090 * information
1091 *
1092 * RETURNS
1093 * Success: TRUE
1094 * Failure: FALSE
1095 */
1096 BOOL WINAPI
1097 GetVersionInfoFromImage(LPWSTR lpFileName,
1098 PULARGE_INTEGER lpFileVersion,
1099 LPWORD lpVersionVarSize)
1100 {
1101 DWORD dwHandle;
1102 DWORD dwSize;
1103 LPVOID lpInfo;
1104 UINT uSize;
1105 VS_FIXEDFILEINFO *lpFixedInfo;
1106 LPWORD lpVarSize;
1107
1108 dwSize = GetFileVersionInfoSizeW(lpFileName, &dwHandle);
1109 if (dwSize == 0)
1110 return FALSE;
1111
1112 lpInfo = MyMalloc(dwSize);
1113 if (lpInfo == NULL)
1114 return FALSE;
1115
1116 if (!GetFileVersionInfoW(lpFileName, 0, dwSize, lpInfo))
1117 {
1118 MyFree(lpInfo);
1119 return FALSE;
1120 }
1121
1122 if (!VerQueryValueW(lpInfo, L"\\",
1123 (LPVOID*)&lpFixedInfo, &uSize))
1124 {
1125 MyFree(lpInfo);
1126 return FALSE;
1127 }
1128
1129 lpFileVersion->LowPart = lpFixedInfo->dwFileVersionLS;
1130 lpFileVersion->HighPart = lpFixedInfo->dwFileVersionMS;
1131
1132 *lpVersionVarSize = 0;
1133 if (!VerQueryValueW(lpInfo, L"\\VerFileInfo\\Translation",
1134 (LPVOID*)&lpVarSize, &uSize))
1135 {
1136 MyFree(lpInfo);
1137 return TRUE;
1138 }
1139
1140 if (uSize >= 4)
1141 {
1142 *lpVersionVarSize = *lpVarSize;
1143 }
1144
1145 MyFree(lpInfo);
1146
1147 return TRUE;
1148 }