shell32: Use ShellExecuteEx to create error dialogs for the run dialog.
[wine] / dlls / shell32 / dialogs.c
1 /*
2  *      common shell dialogs
3  *
4  * Copyright 2000 Juergen Schmied
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 "config.h"
22 #include "wine/port.h"
23
24 #include <string.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include "winerror.h"
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winreg.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "commdlg.h"
34 #include "wine/debug.h"
35
36 #include "shellapi.h"
37 #include "shlobj.h"
38 #include "shell32_main.h"
39 #include "shresdef.h"
40 #include "undocshell.h"
41
42 typedef struct
43     {
44         HWND hwndOwner ;
45         HICON hIcon ;
46         LPCWSTR lpstrDirectory ;
47         LPCWSTR lpstrTitle ;
48         LPCWSTR lpstrDescription ;
49         UINT uFlags ;
50     } RUNFILEDLGPARAMS ;
51
52 typedef BOOL (WINAPI * LPFNOFN) (OPENFILENAMEW *) ;
53
54 WINE_DEFAULT_DEBUG_CHANNEL(shell);
55 static INT_PTR CALLBACK RunDlgProc (HWND, UINT, WPARAM, LPARAM) ;
56 static void FillList (HWND, char *, BOOL) ;
57
58
59 /*************************************************************************
60  * PickIconDlg                                  [SHELL32.62]
61  *
62  */
63 BOOL WINAPI PickIconDlg(
64         HWND hwndOwner,
65         LPSTR lpstrFile,
66         DWORD nMaxFile,
67         LPDWORD lpdwIconIndex)
68 {
69         FIXME("(%p,%s,%08x,%p):stub.\n",
70           hwndOwner, lpstrFile, nMaxFile,lpdwIconIndex);
71         return 0xffffffff;
72 }
73
74 /*************************************************************************
75  * RunFileDlgW                                  [internal]
76  *
77  * The Unicode function that is available as ordinal 61 on Windows NT/2000/XP/...
78  *
79  * SEE ALSO
80  *   RunFileDlgAW
81  */
82 static void RunFileDlgW(
83         HWND hwndOwner,
84         HICON hIcon,
85         LPCWSTR lpstrDirectory,
86         LPCWSTR lpstrTitle,
87         LPCWSTR lpstrDescription,
88         UINT uFlags)
89 {
90     static const WCHAR resnameW[] = {'S','H','E','L','L','_','R','U','N','_','D','L','G',0};
91     RUNFILEDLGPARAMS rfdp;
92     HRSRC hRes;
93     LPVOID template;
94     TRACE("\n");
95
96     rfdp.hwndOwner        = hwndOwner;
97     rfdp.hIcon            = hIcon;
98     rfdp.lpstrDirectory   = lpstrDirectory;
99     rfdp.lpstrTitle       = lpstrTitle;
100     rfdp.lpstrDescription = lpstrDescription;
101     rfdp.uFlags           = uFlags;
102
103     if (!(hRes = FindResourceW(shell32_hInstance, resnameW, (LPWSTR)RT_DIALOG)) ||
104         !(template = LoadResource(shell32_hInstance, hRes)))
105     {
106         ERR("Couldn't load SHELL_RUN_DLG resource\n");
107         ShellMessageBoxW(shell32_hInstance, hwndOwner, MAKEINTRESOURCEW(IDS_RUNDLG_ERROR), NULL, MB_OK | MB_ICONERROR);
108         return;
109     }
110
111     DialogBoxIndirectParamW(shell32_hInstance,
112                             template, hwndOwner, RunDlgProc, (LPARAM)&rfdp);
113
114 }
115
116 /* find the directory that contains the file being run */
117 static LPWSTR RunDlg_GetParentDir(LPCWSTR cmdline)
118 {
119     const WCHAR *src;
120     WCHAR *dest, *result, *result_end=NULL;
121     static const WCHAR dotexeW[] = {'.','e','x','e',0};
122
123     result = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(strlenW(cmdline)+5));
124
125     src = cmdline;
126     dest = result;
127
128     if (*src == '"')
129     {
130         src++;
131         while (*src && *src != '"')
132         {
133             if (*src == '\\')
134                 result_end = dest;
135             *dest++ = *src++;
136         }
137     }
138     else {
139         while (*src)
140         {
141             if (isspaceW(*src))
142             {
143                 *dest = 0;
144                 if (INVALID_FILE_ATTRIBUTES != GetFileAttributesW(result))
145                     break;
146                 strcatW(dest, dotexeW);
147                 if (INVALID_FILE_ATTRIBUTES != GetFileAttributesW(result))
148                     break;
149             }
150             else if (*src == '\\')
151                 result_end = dest;
152             *dest++ = *src++;
153         }
154     }
155
156     if (result_end)
157     {
158         *result_end = 0;
159         return result;
160     }
161     else
162     {
163         HeapFree(GetProcessHeap(), 0, result);
164         return NULL;
165     }
166 }
167
168 /* Dialog procedure for RunFileDlg */
169 static INT_PTR CALLBACK RunDlgProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
170     {
171     RUNFILEDLGPARAMS *prfdp = (RUNFILEDLGPARAMS *)GetWindowLongPtrW(hwnd, DWLP_USER);
172
173     switch (message)
174         {
175         case WM_INITDIALOG :
176             prfdp = (RUNFILEDLGPARAMS *)lParam ;
177             SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR)prfdp);
178
179             if (prfdp->lpstrTitle)
180                 SetWindowTextW(hwnd, prfdp->lpstrTitle);
181             if (prfdp->lpstrDescription)
182                 SetWindowTextW(GetDlgItem(hwnd, IDC_RUNDLG_DESCRIPTION), prfdp->lpstrDescription);
183             if (prfdp->uFlags & RFF_NOBROWSE)
184             {
185                 HWND browse = GetDlgItem(hwnd, IDC_RUNDLG_BROWSE);
186                 ShowWindow(browse, SW_HIDE);
187                 EnableWindow(browse, FALSE);
188             }
189             if (prfdp->uFlags & RFF_NOLABEL)
190                 ShowWindow(GetDlgItem(hwnd, IDC_RUNDLG_LABEL), SW_HIDE);
191             if (prfdp->uFlags & RFF_CALCDIRECTORY)
192                 FIXME("RFF_CALCDIRECTORY not supported\n");
193
194             if (prfdp->hIcon == NULL)
195                 prfdp->hIcon = LoadIconW(NULL, (LPCWSTR)IDI_WINLOGO);
196             SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)prfdp->hIcon);
197             SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)prfdp->hIcon);
198             SendMessageW(GetDlgItem(hwnd, IDC_RUNDLG_ICON), STM_SETICON, (WPARAM)prfdp->hIcon, 0);
199
200             FillList (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH), NULL, (prfdp->uFlags & RFF_NODEFAULT) == 0) ;
201             SetFocus (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH)) ;
202             return TRUE ;
203
204         case WM_COMMAND :
205             switch (LOWORD (wParam))
206                 {
207                 case IDOK :
208                     {
209                     int ic ;
210                     HWND htxt = GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH);
211                     if ((ic = GetWindowTextLengthW (htxt)))
212                         {
213                         WCHAR *psz, *parent=NULL ;
214                         SHELLEXECUTEINFOW sei ;
215
216                         ZeroMemory (&sei, sizeof(sei)) ;
217                         sei.cbSize = sizeof(sei) ;
218                         psz = HeapAlloc( GetProcessHeap(), 0, (ic + 1)*sizeof(WCHAR) );
219                         GetWindowTextW (htxt, psz, ic + 1) ;
220
221                         /* according to http://www.codeproject.com/KB/shell/runfiledlg.aspx we should send a
222                          * WM_NOTIFY before execution */
223
224                         sei.hwnd = hwnd;
225                         sei.nShow = SW_SHOWNORMAL;
226                         sei.lpFile = psz;
227
228                         if (prfdp->lpstrDirectory)
229                             sei.lpDirectory = prfdp->lpstrDirectory;
230                         else
231                             sei.lpDirectory = parent = RunDlg_GetParentDir(sei.lpFile);
232
233                         if (ShellExecuteExW( &sei ) < 33)
234                             {
235                             HeapFree(GetProcessHeap(), 0, psz);
236                             HeapFree(GetProcessHeap(), 0, parent);
237                             SendMessageA (htxt, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
238                             return TRUE ;
239                             }
240
241                         /* FillList is still ANSI */
242                         GetWindowTextA (htxt, (LPSTR)psz, ic + 1) ;
243                         FillList (htxt, (LPSTR)psz, FALSE) ;
244
245                         HeapFree(GetProcessHeap(), 0, psz);
246                         HeapFree(GetProcessHeap(), 0, parent);
247                         EndDialog (hwnd, 0) ;
248                         }
249                     }
250
251                 case IDCANCEL :
252                     EndDialog (hwnd, 0) ;
253                     return TRUE ;
254
255                 case IDC_RUNDLG_BROWSE :
256                     {
257                     HMODULE hComdlg = NULL ;
258                     LPFNOFN ofnProc = NULL ;
259                     static const WCHAR comdlg32W[] = {'c','o','m','d','l','g','3','2',0};
260                     WCHAR szFName[1024] = {0};
261                     WCHAR *pszFilter, szCaption[MAX_PATH];
262                     OPENFILENAMEW ofn;
263
264                     LoadStringW(shell32_hInstance, IDS_RUNDLG_BROWSE_FILTER, (LPWSTR)&pszFilter, 0);
265                     LoadStringW(shell32_hInstance, IDS_RUNDLG_BROWSE_CAPTION, szCaption, MAX_PATH);
266
267                     ZeroMemory(&ofn, sizeof(ofn));
268                     ofn.lStructSize = sizeof(OPENFILENAMEW);
269                     ofn.hwndOwner = hwnd;
270                     ofn.lpstrFilter = pszFilter;
271                     ofn.lpstrFile = szFName;
272                     ofn.nMaxFile = 1023;
273                     ofn.lpstrTitle = szCaption;
274                     ofn.Flags = OFN_ENABLESIZING | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
275                     ofn.lpstrInitialDir = prfdp->lpstrDirectory;
276
277                     if (NULL == (hComdlg = LoadLibraryExW (comdlg32W, NULL, 0)) ||
278                         NULL == (ofnProc = (LPFNOFN)GetProcAddress (hComdlg, "GetOpenFileNameW")))
279                     {
280                         ERR("Couldn't get GetOpenFileName function entry (lib=%p, proc=%p)\n", hComdlg, ofnProc);
281                         ShellMessageBoxW(shell32_hInstance, hwnd, MAKEINTRESOURCEW(IDS_RUNDLG_BROWSE_ERROR), NULL, MB_OK | MB_ICONERROR);
282                         return TRUE ;
283                     }
284
285                     if (ofnProc(&ofn))
286                     {
287                         SetFocus (GetDlgItem (hwnd, IDOK)) ;
288                         SetWindowTextW (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH), szFName) ;
289                         SendMessageW (GetDlgItem (hwnd, IDC_RUNDLG_EDITPATH), CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
290                         SetFocus (GetDlgItem (hwnd, IDOK)) ;
291                     }
292
293                     FreeLibrary (hComdlg) ;
294
295                     return TRUE ;
296                     }
297                 }
298             return TRUE ;
299         }
300     return FALSE ;
301     }
302
303 /* This grabs the MRU list from the registry and fills the combo for the "Run" dialog above */
304 /* fShowDefault ignored if pszLatest != NULL */
305 static void FillList (HWND hCb, char *pszLatest, BOOL fShowDefault)
306     {
307     HKEY hkey ;
308 /*    char szDbgMsg[256] = "" ; */
309     char *pszList = NULL, *pszCmd = NULL, cMatch = 0, cMax = 0x60, szIndex[2] = "-" ;
310     DWORD icList = 0, icCmd = 0 ;
311     UINT Nix ;
312
313     SendMessageA (hCb, CB_RESETCONTENT, 0, 0) ;
314
315     if (ERROR_SUCCESS != RegCreateKeyExA (
316         HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU",
317         0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL))
318         MessageBoxA (hCb, "Unable to open registry key !", "Nix", MB_OK) ;
319
320     RegQueryValueExA (hkey, "MRUList", NULL, NULL, NULL, &icList) ;
321
322     if (icList > 0)
323         {
324         pszList = HeapAlloc( GetProcessHeap(), 0, icList) ;
325         if (ERROR_SUCCESS != RegQueryValueExA (hkey, "MRUList", NULL, NULL, (LPBYTE)pszList, &icList))
326             MessageBoxA (hCb, "Unable to grab MRUList !", "Nix", MB_OK) ;
327         }
328     else
329         {
330         icList = 1 ;
331         pszList = HeapAlloc( GetProcessHeap(), 0, icList) ;
332         pszList[0] = 0 ;
333         }
334
335     for (Nix = 0 ; Nix < icList - 1 ; Nix++)
336         {
337         if (pszList[Nix] > cMax)
338             cMax = pszList[Nix] ;
339
340         szIndex[0] = pszList[Nix] ;
341
342         if (ERROR_SUCCESS != RegQueryValueExA (hkey, szIndex, NULL, NULL, NULL, &icCmd))
343             MessageBoxA (hCb, "Unable to grab size of index", "Nix", MB_OK) ;
344         if( pszCmd )
345             pszCmd = HeapReAlloc(GetProcessHeap(), 0, pszCmd, icCmd) ;
346         else
347             pszCmd = HeapAlloc(GetProcessHeap(), 0, icCmd) ;
348         if (ERROR_SUCCESS != RegQueryValueExA (hkey, szIndex, NULL, NULL, (LPBYTE)pszCmd, &icCmd))
349             MessageBoxA (hCb, "Unable to grab index", "Nix", MB_OK) ;
350
351         if (NULL != pszLatest)
352             {
353             if (!lstrcmpiA(pszCmd, pszLatest))
354                 {
355                 /*
356                 sprintf (szDbgMsg, "Found existing (%d).\n", Nix) ;
357                 MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
358                 */
359                 SendMessageA (hCb, CB_INSERTSTRING, 0, (LPARAM)pszCmd) ;
360                 SetWindowTextA (hCb, pszCmd) ;
361                 SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
362
363                 cMatch = pszList[Nix] ;
364                 memmove (&pszList[1], pszList, Nix) ;
365                 pszList[0] = cMatch ;
366                 continue ;
367                 }
368             }
369
370         if (26 != icList - 1 || icList - 2 != Nix || cMatch || NULL == pszLatest)
371             {
372             /*
373             sprintf (szDbgMsg, "Happily appending (%d).\n", Nix) ;
374             MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
375             */
376             SendMessageA (hCb, CB_ADDSTRING, 0, (LPARAM)pszCmd) ;
377             if (!Nix && fShowDefault)
378                 {
379                 SetWindowTextA (hCb, pszCmd) ;
380                 SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
381                 }
382
383             }
384         else
385             {
386             /*
387             sprintf (szDbgMsg, "Doing loop thing.\n") ;
388             MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
389             */
390             SendMessageA (hCb, CB_INSERTSTRING, 0, (LPARAM)pszLatest) ;
391             SetWindowTextA (hCb, pszLatest) ;
392             SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
393
394             cMatch = pszList[Nix] ;
395             memmove (&pszList[1], pszList, Nix) ;
396             pszList[0] = cMatch ;
397             szIndex[0] = cMatch ;
398             RegSetValueExA (hkey, szIndex, 0, REG_SZ, (LPBYTE)pszLatest, strlen (pszLatest) + 1) ;
399             }
400         }
401
402     if (!cMatch && NULL != pszLatest)
403         {
404         /*
405         sprintf (szDbgMsg, "Simply inserting (increasing list).\n") ;
406         MessageBoxA (hCb, szDbgMsg, "Nix", MB_OK) ;
407         */
408         SendMessageA (hCb, CB_INSERTSTRING, 0, (LPARAM)pszLatest) ;
409         SetWindowTextA (hCb, pszLatest) ;
410         SendMessageA (hCb, CB_SETEDITSEL, 0, MAKELPARAM (0, -1)) ;
411
412         cMatch = ++cMax ;
413         if( pszList )
414             pszList = HeapReAlloc(GetProcessHeap(), 0, pszList, ++icList) ;
415         else
416             pszList = HeapAlloc(GetProcessHeap(), 0, ++icList) ;
417         memmove (&pszList[1], pszList, icList - 1) ;
418         pszList[0] = cMatch ;
419         szIndex[0] = cMatch ;
420         RegSetValueExA (hkey, szIndex, 0, REG_SZ, (LPBYTE)pszLatest, strlen (pszLatest) + 1) ;
421         }
422
423     RegSetValueExA (hkey, "MRUList", 0, REG_SZ, (LPBYTE)pszList, strlen (pszList) + 1) ;
424
425     HeapFree( GetProcessHeap(), 0, pszCmd) ;
426     HeapFree( GetProcessHeap(), 0, pszList) ;
427     }
428
429 /*************************************************************************
430  * RunFileDlgA                                  [internal]
431  *
432  * The ANSI function that is available as ordinal 61 on Windows 9x/Me
433  *
434  * SEE ALSO
435  *   RunFileDlgAW
436  */
437 static void RunFileDlgA(
438         HWND hwndOwner,
439         HICON hIcon,
440         LPCSTR lpstrDirectory,
441         LPCSTR lpstrTitle,
442         LPCSTR lpstrDescription,
443         UINT uFlags)
444 {
445     WCHAR title[MAX_PATH];       /* longer string wouldn't be visible in the dialog anyway */
446     WCHAR description[MAX_PATH];
447     WCHAR directory[MAX_PATH];
448
449     MultiByteToWideChar(CP_ACP, 0, lpstrTitle, -1, title, MAX_PATH);
450     title[MAX_PATH - 1] = 0;
451     MultiByteToWideChar(CP_ACP, 0, lpstrDescription, -1, description, MAX_PATH);
452     description[MAX_PATH - 1] = 0;
453     if (!MultiByteToWideChar(CP_ACP, 0, lpstrDirectory, -1, directory, MAX_PATH))
454         directory[0] = 0;
455
456     RunFileDlgW(hwndOwner, hIcon,
457         lpstrDirectory ? directory : NULL,
458         lpstrTitle ? title : NULL,
459         lpstrDescription ? description : NULL,
460         uFlags);
461 }
462
463 /*************************************************************************
464  * RunFileDlgAW                                 [SHELL32.61]
465  *
466  * An undocumented way to open the Run File dialog. A documented way is to use
467  * CLSID_Shell, IID_IShellDispatch (as of Wine 1.0, not implemented under Wine)
468  *
469  * Exported by ordinal. ANSI on Windows 9x and Unicode on Windows NT/2000/XP/etc
470  *
471  */
472 void WINAPI RunFileDlgAW(
473         HWND hwndOwner,
474         HICON hIcon,
475         LPCVOID lpstrDirectory,
476         LPCVOID lpstrTitle,
477         LPCVOID lpstrDescription,
478         UINT uFlags)
479 {
480     if (SHELL_OsIsUnicode())
481         RunFileDlgW(hwndOwner, hIcon, lpstrDirectory, lpstrTitle, lpstrDescription, uFlags);
482     else
483         RunFileDlgA(hwndOwner, hIcon, lpstrDirectory, lpstrTitle, lpstrDescription, uFlags);
484 }
485
486
487 /*************************************************************************
488  * ConfirmDialog                                [internal]
489  *
490  * Put up a confirm box, return TRUE if the user confirmed
491  */
492 static BOOL ConfirmDialog(HWND hWndOwner, UINT PromptId, UINT TitleId)
493 {
494   WCHAR Prompt[256];
495   WCHAR Title[256];
496
497   LoadStringW(shell32_hInstance, PromptId, Prompt, sizeof(Prompt) / sizeof(WCHAR));
498   LoadStringW(shell32_hInstance, TitleId, Title, sizeof(Title) / sizeof(WCHAR));
499   return MessageBoxW(hWndOwner, Prompt, Title, MB_YESNO|MB_ICONQUESTION) == IDYES;
500 }
501
502
503 /*************************************************************************
504  * RestartDialogEx                              [SHELL32.730]
505  */
506
507 int WINAPI RestartDialogEx(HWND hWndOwner, LPCWSTR lpwstrReason, DWORD uFlags, DWORD uReason)
508 {
509     TRACE("(%p)\n", hWndOwner);
510
511     /* FIXME: use lpwstrReason */
512     if (ConfirmDialog(hWndOwner, IDS_RESTART_PROMPT, IDS_RESTART_TITLE))
513     {
514         HANDLE hToken;
515         TOKEN_PRIVILEGES npr;
516
517         /* enable the shutdown privilege for the current process */
518         if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
519         {
520             LookupPrivilegeValueA(0, "SeShutdownPrivilege", &npr.Privileges[0].Luid);
521             npr.PrivilegeCount = 1;
522             npr.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
523             AdjustTokenPrivileges(hToken, FALSE, &npr, 0, 0, 0);
524             CloseHandle(hToken);
525         }
526         ExitWindowsEx(EWX_REBOOT, uReason);
527     }
528
529     return 0;
530 }
531
532
533 /*************************************************************************
534  * RestartDialog                                [SHELL32.59]
535  */
536
537 int WINAPI RestartDialog(HWND hWndOwner, LPCWSTR lpstrReason, DWORD uFlags)
538 {
539     return RestartDialogEx(hWndOwner, lpstrReason, uFlags, 0);
540 }
541
542
543 /*************************************************************************
544  * ExitWindowsDialog                            [SHELL32.60]
545  *
546  * NOTES
547  *     exported by ordinal
548  */
549 void WINAPI ExitWindowsDialog (HWND hWndOwner)
550 {
551     TRACE("(%p)\n", hWndOwner);
552
553     if (ConfirmDialog(hWndOwner, IDS_SHUTDOWN_PROMPT, IDS_SHUTDOWN_TITLE))
554     {
555         HANDLE hToken;
556         TOKEN_PRIVILEGES npr;
557
558         /* enable shutdown privilege for current process */
559         if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
560         {
561             LookupPrivilegeValueA(0, "SeShutdownPrivilege", &npr.Privileges[0].Luid);
562             npr.PrivilegeCount = 1;
563             npr.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
564             AdjustTokenPrivileges(hToken, FALSE, &npr, 0, 0, 0);
565             CloseHandle(hToken);
566         }
567         ExitWindowsEx(EWX_SHUTDOWN, 0);
568     }
569 }