1 /*
2  * PROJECT:     ReactOS Compatibility Layer Shell Extension
3  * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
4  * PURPOSE:     CLayerUIPropPage implementation
5  * COPYRIGHT:   Copyright 2015-2019 Mark Jansen (mark.jansen@reactos.org)
6  */
7 
8 #include "precomp.h"
9 
10 #include <shlwapi.h>
11 #include <shellapi.h>
12 #include <shellutils.h>
13 #include <strsafe.h>
14 #include <apphelp.h>
15 #include <windowsx.h>
16 #include <sfc.h>
17 
18 const GUID CLSID_CLayerUIPropPage = { 0x513D916F, 0x2A8E, 0x4F51, { 0xAE, 0xAB, 0x0C, 0xBC, 0x76, 0xFB, 0x1A, 0xF8 } };
19 
20 #define GPLK_USER 1
21 #define GPLK_MACHINE 2
22 #define MAX_LAYER_LENGTH 256
23 
24 static struct {
25     const PCWSTR Display;
26     const PCWSTR Name;
27 } g_CompatModes[] = {
28     { L"Windows 95", L"WIN95" },
29     { L"Windows 98/ME", L"WIN98" },
30     { L"Windows NT 4.0 (SP5)", L"NT4SP5" },
31     { L"Windows 2000", L"WIN2000" },
32     { L"Windows XP (SP3)", L"WINXPSP3" },
33     { L"Windows Server 2003 (SP1)", L"WINSRV03SP1" },
34     { L"Windows Server 2008 (SP1)", L"WINSRV08SP1" },
35     { L"Windows Vista (SP2)", L"VISTASP2" },
36     { L"Windows 7", L"WIN7RTM" },
37     { L"Windows 7 (SP1)", L"WIN7SP1" },
38     { L"Windows 8.1", L"WIN81RTM" },
39     { L"Windows 10", L"WIN10RTM" },
40     { L"Windows Server 2016", L"WINSRV16RTM" },
41     { L"Windows Server 2019", L"WINSRV19RTM" },
42     { NULL, NULL }
43 };
44 
45 static struct {
46     const PCWSTR Name;
47     DWORD Id;
48 } g_Layers[] = {
49     { L"256COLOR", IDC_CHKRUNIN256COLORS },
50     { L"640X480", IDC_CHKRUNIN640480RES },
51     { L"DISABLETHEMES", IDC_CHKDISABLEVISUALTHEMES },
52 #if 0
53     { L"DISABLEDWM", IDC_??, TRUE },
54     { L"HIGHDPIAWARE", IDC_??, TRUE },
55     { L"RUNASADMIN", IDC_??, TRUE },
56 #endif
57     { NULL, 0 }
58 };
59 
60 static const WCHAR* g_AllowedExtensions[] = {
61     L".exe",
62     L".msi",
63     L".pif",
64     L".bat",
65     L".cmd",
66     0
67 };
68 
69 BOOL IsBuiltinLayer(PCWSTR Name)
70 {
71     size_t n;
72 
73     for (n = 0; g_Layers[n].Name; ++n)
74     {
75         if (!wcsicmp(g_Layers[n].Name, Name))
76         {
77             return TRUE;
78         }
79     }
80 
81     for (n = 0; g_CompatModes[n].Name; ++n)
82     {
83         if (!wcsicmp(g_CompatModes[n].Name, Name))
84         {
85             return TRUE;
86         }
87     }
88     return FALSE;
89 }
90 
91 
92 void ACDBG_FN(PCSTR FunctionName, PCWSTR Format, ...)
93 {
94     WCHAR Buffer[512];
95     WCHAR* Current = Buffer;
96     size_t Length = _countof(Buffer);
97 
98     StringCchPrintfExW(Current, Length, &Current, &Length, STRSAFE_NULL_ON_FAILURE, L"[%-20S] ", FunctionName);
99     va_list ArgList;
100     va_start(ArgList, Format);
101     StringCchVPrintfExW(Current, Length, &Current, &Length, STRSAFE_NULL_ON_FAILURE, Format, ArgList);
102     va_end(ArgList);
103     OutputDebugStringW(Buffer);
104 }
105 
106 #define ACDBG(fmt, ...)  ACDBG_FN(__FUNCTION__, fmt, ##__VA_ARGS__ )
107 
108 
109 
110 CLayerUIPropPage::CLayerUIPropPage()
111 : m_IsSfcProtected(FALSE)
112 , m_AllowPermLayer(FALSE)
113 , m_LayerQueryFlags(GPLK_USER)  /* TODO: When do we read from HKLM? */
114 , m_RegistryOSMode(0)
115 , m_OSMode(0)
116 , m_RegistryEnabledLayers(0)
117 , m_EnabledLayers(0)
118 {
119     CComBSTR title;
120     title.LoadString(g_hModule, IDS_COMPAT_TITLE);
121     m_psp.pszTitle = title.Detach();
122     m_psp.dwFlags |= PSP_USETITLE;
123 }
124 
125 CLayerUIPropPage::~CLayerUIPropPage()
126 {
127     CComBSTR title;
128     title.Attach((BSTR)m_psp.pszTitle);
129 }
130 
131 HRESULT CLayerUIPropPage::InitFile(PCWSTR Filename)
132 {
133     CString ExpandedFilename;
134     DWORD dwRequired = ExpandEnvironmentStringsW(Filename, NULL, 0);
135     if (dwRequired > 0)
136     {
137         LPWSTR Buffer = ExpandedFilename.GetBuffer(dwRequired);
138         DWORD dwReturned = ExpandEnvironmentStringsW(Filename, Buffer, dwRequired);
139         if (dwRequired == dwReturned)
140         {
141             ExpandedFilename.ReleaseBufferSetLength(dwReturned - 1);
142             ACDBG(L"Expanded '%s' => '%s'\r\n", Filename, (PCWSTR)ExpandedFilename);
143         }
144         else
145         {
146             ExpandedFilename.ReleaseBufferSetLength(0);
147             ExpandedFilename = Filename;
148             ACDBG(L"Failed during expansion '%s'\r\n", Filename);
149         }
150     }
151     else
152     {
153         ACDBG(L"Failed to expand '%s'\r\n", Filename);
154         ExpandedFilename = Filename;
155     }
156     PCWSTR pwszExt = PathFindExtensionW(ExpandedFilename);
157     if (!pwszExt)
158     {
159         ACDBG(L"Failed to find an extension: '%s'\r\n", (PCWSTR)ExpandedFilename);
160         return E_FAIL;
161     }
162     if (!wcsicmp(pwszExt, L".lnk"))
163     {
164         WCHAR Buffer[MAX_PATH];
165         if (!GetExeFromLnk(ExpandedFilename, Buffer, _countof(Buffer)))
166         {
167             ACDBG(L"Failed to read link target from: '%s'\r\n", (PCWSTR)ExpandedFilename);
168             return E_FAIL;
169         }
170         if (!wcsicmp(Buffer, ExpandedFilename))
171         {
172             ACDBG(L"Link redirects to itself: '%s'\r\n", (PCWSTR)ExpandedFilename);
173             return E_FAIL;
174         }
175         return InitFile(Buffer);
176     }
177 
178     CString tmp;
179     if (tmp.GetEnvironmentVariable(L"SystemRoot"))
180     {
181         tmp += L"\\System32";
182         if (ExpandedFilename.GetLength() >= tmp.GetLength() &&
183             ExpandedFilename.Left(tmp.GetLength()).MakeLower() == tmp.MakeLower())
184         {
185             ACDBG(L"Ignoring System32: %s\r\n", (PCWSTR)ExpandedFilename);
186             return E_FAIL;
187         }
188         tmp.GetEnvironmentVariable(L"SystemRoot");
189         tmp += L"\\WinSxs";
190         if (ExpandedFilename.GetLength() >= tmp.GetLength() &&
191             ExpandedFilename.Left(tmp.GetLength()).MakeLower() == tmp.MakeLower())
192         {
193             ACDBG(L"Ignoring WinSxs: %s\r\n", (PCWSTR)ExpandedFilename);
194             return E_FAIL;
195         }
196     }
197 
198     for (size_t n = 0; g_AllowedExtensions[n]; ++n)
199     {
200         if (!wcsicmp(g_AllowedExtensions[n], pwszExt))
201         {
202             m_Filename = ExpandedFilename;
203             ACDBG(L"Got: %s\r\n", (PCWSTR)ExpandedFilename);
204             m_IsSfcProtected = SfcIsFileProtected(NULL, m_Filename);
205             m_AllowPermLayer = AllowPermLayer(ExpandedFilename);
206             return S_OK;
207         }
208     }
209     ACDBG(L"Extension not included: '%s'\r\n", pwszExt);
210     return E_FAIL;
211 }
212 
213 static BOOL GetLayerInfo(PCWSTR Filename, DWORD QueryFlags, PDWORD OSMode, PDWORD Enabledlayers, CSimpleArray<CString>& customLayers)
214 {
215     WCHAR wszLayers[MAX_LAYER_LENGTH] = { 0 };
216     DWORD dwBytes = sizeof(wszLayers);
217 
218     *OSMode = *Enabledlayers = 0;
219     customLayers.RemoveAll();
220     if (!SdbGetPermLayerKeys(Filename, wszLayers, &dwBytes, QueryFlags))
221         return FALSE;
222 
223     for (PWCHAR Layer = wcstok(wszLayers, L" "); Layer; Layer = wcstok(NULL, L" "))
224     {
225         size_t n;
226         for (n = 0; g_Layers[n].Name; ++n)
227         {
228             if (!wcsicmp(g_Layers[n].Name, Layer))
229             {
230                 *Enabledlayers |= (1<<n);
231                 break;
232             }
233         }
234         /* Did we find it? */
235         if (g_Layers[n].Name)
236             continue;
237 
238         for (n = 0; g_CompatModes[n].Name; ++n)
239         {
240             if (!wcsicmp(g_CompatModes[n].Name, Layer))
241             {
242                 *OSMode = n+1;
243                 break;
244             }
245         }
246         /* Did we find it? */
247         if (g_CompatModes[n].Name)
248             continue;
249 
250         /* Must be a 'custom' layer */
251         customLayers.Add(Layer);
252     }
253     return TRUE;
254 }
255 
256 int CLayerUIPropPage::OnSetActive()
257 {
258     if (!GetLayerInfo(m_Filename, m_LayerQueryFlags, &m_RegistryOSMode, &m_RegistryEnabledLayers, m_RegistryCustomLayers))
259         m_RegistryOSMode = m_RegistryEnabledLayers = 0;
260 
261     for (size_t n = 0; g_Layers[n].Name; ++n)
262         CheckDlgButton(g_Layers[n].Id, (m_RegistryEnabledLayers & (1<<n)) ? BST_CHECKED : BST_UNCHECKED);
263 
264     CheckDlgButton(IDC_CHKRUNCOMPATIBILITY, m_RegistryOSMode ? BST_CHECKED : BST_UNCHECKED);
265 
266     if (m_RegistryOSMode)
267         ComboBox_SetCurSel(GetDlgItem(IDC_COMPATIBILITYMODE), m_RegistryOSMode-1);
268 
269     m_CustomLayers = m_RegistryCustomLayers;
270 
271     UpdateControls();
272 
273     return 0;
274 }
275 
276 
277 static BOOL ArrayEquals(const CSimpleArray<CString>& lhs, const CSimpleArray<CString>& rhs)
278 {
279     if (lhs.GetSize() != rhs.GetSize())
280         return FALSE;
281 
282     for (int n = 0; n < lhs.GetSize(); ++n)
283     {
284         if (lhs[n] != rhs[n])
285             return FALSE;
286     }
287     return TRUE;
288 }
289 
290 BOOL CLayerUIPropPage::HasChanges() const
291 {
292     if (m_RegistryEnabledLayers != m_EnabledLayers)
293         return TRUE;
294 
295     if (m_RegistryOSMode != m_OSMode)
296         return TRUE;
297 
298     if (!ArrayEquals(m_RegistryCustomLayers, m_CustomLayers))
299         return TRUE;
300 
301     return FALSE;
302 }
303 
304 int CLayerUIPropPage::OnApply()
305 {
306     if (HasChanges())
307     {
308         BOOL bMachine = m_LayerQueryFlags == GPLK_MACHINE;
309 
310         for (size_t n = 0; g_CompatModes[n].Name; ++n)
311             SetPermLayerState(m_Filename, g_CompatModes[n].Name, 0, bMachine, (n+1) == m_OSMode);
312 
313         for (size_t n = 0; g_Layers[n].Name; ++n)
314         {
315             SetPermLayerState(m_Filename, g_Layers[n].Name, 0, bMachine, ((1<<n) & m_EnabledLayers) != 0);
316         }
317 
318         /* Disable all old values */
319         for (int j = 0; j < m_RegistryCustomLayers.GetSize(); j++)
320         {
321             SetPermLayerState(m_Filename, m_RegistryCustomLayers[j].GetString(), 0, bMachine, FALSE);
322         }
323 
324         /* Enable all new values */
325         for (int j = 0; j < m_CustomLayers.GetSize(); j++)
326         {
327             SetPermLayerState(m_Filename, m_CustomLayers[j].GetString(), 0, bMachine, TRUE);
328         }
329 
330         SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATHW, (PCWSTR)m_Filename, NULL);
331     }
332 
333     return PSNRET_NOERROR;
334 }
335 
336 LRESULT CLayerUIPropPage::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
337 {
338     HWND cboMode = GetDlgItem(IDC_COMPATIBILITYMODE);
339     for (size_t n = 0; g_CompatModes[n].Display; ++n)
340         ComboBox_AddString(cboMode, g_CompatModes[n].Display);
341     ComboBox_SetCurSel(cboMode, 4);
342 
343     CStringW explanation;
344     if (!m_AllowPermLayer)
345     {
346         explanation.LoadString(g_hModule, IDS_FAILED_NETWORK);
347         DisableControls();
348         ACDBG(L"AllowPermLayer returned FALSE\r\n");
349     }
350     else if (m_IsSfcProtected)
351     {
352         explanation.LoadString(g_hModule, IDS_FAILED_PROTECTED);
353         DisableControls();
354         ACDBG(L"Protected OS file\r\n");
355     }
356     else
357     {
358         return TRUE;
359     }
360     SetDlgItemTextW(IDC_EXPLANATION, explanation);
361     return TRUE;
362 }
363 
364 INT_PTR CLayerUIPropPage::DisableControls()
365 {
366     ::EnableWindow(GetDlgItem(IDC_COMPATIBILITYMODE), 0);
367     ::EnableWindow(GetDlgItem(IDC_CHKRUNCOMPATIBILITY), 0);
368     for (size_t n = 0; g_Layers[n].Name; ++n)
369         ::EnableWindow(GetDlgItem(g_Layers[n].Id), 0);
370     ::EnableWindow(GetDlgItem(IDC_EDITCOMPATIBILITYMODES), 0);
371     return TRUE;
372 }
373 
374 void CLayerUIPropPage::UpdateControls()
375 {
376     m_OSMode = 0, m_EnabledLayers = 0;
377     BOOL ModeEnabled = IsDlgButtonChecked(IDC_CHKRUNCOMPATIBILITY);
378     if (ModeEnabled)
379         m_OSMode = ComboBox_GetCurSel(GetDlgItem(IDC_COMPATIBILITYMODE))+1;
380     ::EnableWindow(GetDlgItem(IDC_COMPATIBILITYMODE), ModeEnabled);
381 
382     for (size_t n = 0; g_Layers[n].Name; ++n)
383     {
384         m_EnabledLayers |= IsDlgButtonChecked(g_Layers[n].Id) ? (1<<n) : 0;
385         ::ShowWindow(GetDlgItem(g_Layers[n].Id), SW_SHOW);
386     }
387 
388     CStringW customLayers;
389     for (int j = 0; j < m_CustomLayers.GetSize(); ++j)
390     {
391         if (j > 0)
392             customLayers += L", ";
393         customLayers += m_CustomLayers[j];
394     }
395     SetDlgItemTextW(IDC_ENABLED_LAYERS, customLayers);
396 
397     SetModified(HasChanges());
398 }
399 
400 LRESULT CLayerUIPropPage::OnCtrlCommand(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
401 {
402     UpdateControls();
403     return 0;
404 }
405 
406 LRESULT CLayerUIPropPage::OnEditModes(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
407 {
408     if (ShowEditCompatModes(m_hWnd, this))
409         UpdateControls();
410     return 0;
411 }
412 
413 LRESULT CLayerUIPropPage::OnClickNotify(INT uCode, LPNMHDR hdr, BOOL& bHandled)
414 {
415     if (hdr->idFrom == IDC_INFOLINK)
416         ShellExecute(NULL, L"open", L"https://reactos.org/forum/viewforum.php?f=4", NULL, NULL, SW_SHOW);
417     return 0;
418 }
419 
420 static BOOL DisableShellext()
421 {
422     HKEY hkey;
423     LSTATUS ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Policies\\Microsoft\\Windows\\AppCompat", 0, KEY_QUERY_VALUE, &hkey);
424     BOOL Disable = FALSE;
425     if (ret == ERROR_SUCCESS)
426     {
427         DWORD dwValue = 0;
428         DWORD type, size = sizeof(dwValue);
429         ret = RegQueryValueExW(hkey, L"DisableEngine", NULL, &type, (PBYTE)&dwValue, &size);
430         if (ret == ERROR_SUCCESS && type == REG_DWORD)
431         {
432             Disable = !!dwValue;
433         }
434         if (!Disable)
435         {
436             size = sizeof(dwValue);
437             ret = RegQueryValueExW(hkey, L"DisablePropPage", NULL, &type, (PBYTE)&dwValue, &size);
438             if (ret == ERROR_SUCCESS && type == REG_DWORD)
439             {
440                 Disable = !!dwValue;
441             }
442         }
443 
444         RegCloseKey(hkey);
445     }
446     return Disable;
447 }
448 
449 STDMETHODIMP CLayerUIPropPage::Initialize(PCIDLIST_ABSOLUTE pidlFolder, LPDATAOBJECT pDataObj, HKEY hkeyProgID)
450 {
451     FORMATETC etc = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
452     STGMEDIUM stg;
453 
454     if (DisableShellext())
455         return E_ACCESSDENIED;
456 
457     HRESULT hr = pDataObj->GetData(&etc, &stg);
458     if (FAILED(hr))
459     {
460         ACDBG(L"Failed to retrieve Data from pDataObj.\r\n");
461         return E_INVALIDARG;
462     }
463     hr = E_FAIL;
464     HDROP hdrop = (HDROP)GlobalLock(stg.hGlobal);
465     if (hdrop)
466     {
467         UINT uNumFiles = DragQueryFileW(hdrop, 0xFFFFFFFF, NULL, 0);
468         if (uNumFiles == 1)
469         {
470             WCHAR szFile[MAX_PATH * 2];
471             if (DragQueryFileW(hdrop, 0, szFile, _countof(szFile)))
472             {
473                 this->AddRef();
474                 hr = InitFile(szFile);
475             }
476             else
477             {
478                 ACDBG(L"Failed to query the file.\r\n");
479             }
480         }
481         else
482         {
483             ACDBG(L"Invalid number of files: %d\r\n", uNumFiles);
484         }
485         GlobalUnlock(stg.hGlobal);
486     }
487     else
488     {
489         ACDBG(L"Could not lock stg.hGlobal\r\n");
490     }
491     ReleaseStgMedium(&stg);
492     return hr;
493 }
494