xref: /reactos/dll/shellext/shellbtrfs/main.cpp (revision d0ed4fdb) 
1 /* Copyright (c) Mark Harmstone 2016-17
2  *
3  * This file is part of WinBtrfs.
4  *
5  * WinBtrfs is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU Lesser General Public Licence as published by
7  * the Free Software Foundation, either version 3 of the Licence, or
8  * (at your option) any later version.
9  *
10  * WinBtrfs is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public Licence for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public Licence
16  * along with WinBtrfs.  If not, see <http://www.gnu.org/licenses/>. */
17 
18 #include "shellext.h"
19 #include <windows.h>
20 #include <commctrl.h>
21 #include <strsafe.h>
22 #include <stddef.h>
23 #include <stdexcept>
24 #include "factory.h"
25 #include "resource.h"
26 
27 static const GUID CLSID_ShellBtrfsIconHandler = { 0x2690b74f, 0xf353, 0x422d, { 0xbb, 0x12, 0x40, 0x15, 0x81, 0xee, 0xf8, 0xf0 } };
28 static const GUID CLSID_ShellBtrfsContextMenu = { 0x2690b74f, 0xf353, 0x422d, { 0xbb, 0x12, 0x40, 0x15, 0x81, 0xee, 0xf8, 0xf1 } };
29 static const GUID CLSID_ShellBtrfsPropSheet = { 0x2690b74f, 0xf353, 0x422d, { 0xbb, 0x12, 0x40, 0x15, 0x81, 0xee, 0xf8, 0xf2 } };
30 static const GUID CLSID_ShellBtrfsVolPropSheet = { 0x2690b74f, 0xf353, 0x422d, { 0xbb, 0x12, 0x40, 0x15, 0x81, 0xee, 0xf8, 0xf3 } };
31 
32 #define COM_DESCRIPTION_ICON_HANDLER L"WinBtrfs shell extension (icon handler)"
33 #define COM_DESCRIPTION_CONTEXT_MENU L"WinBtrfs shell extension (context menu)"
34 #define COM_DESCRIPTION_PROP_SHEET L"WinBtrfs shell extension (property sheet)"
35 #define COM_DESCRIPTION_VOL_PROP_SHEET L"WinBtrfs shell extension (volume property sheet)"
36 #define ICON_OVERLAY_NAME L"WinBtrfs"
37 
38 typedef enum _PROCESS_DPI_AWARENESS {
39     PROCESS_DPI_UNAWARE,
40     PROCESS_SYSTEM_DPI_AWARE,
41     PROCESS_PER_MONITOR_DPI_AWARE
42 } PROCESS_DPI_AWARENESS;
43 
44 typedef ULONG (WINAPI *_RtlNtStatusToDosError)(NTSTATUS Status);
45 typedef HRESULT (WINAPI *_SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS value);
46 
47 HMODULE module;
48 LONG objs_loaded = 0;
49 
50 void set_dpi_aware() {
51     _SetProcessDpiAwareness SetProcessDpiAwareness;
52     HMODULE shcore = LoadLibraryW(L"shcore.dll");
53 
54     if (!shcore)
55         return;
56 
57     SetProcessDpiAwareness = (_SetProcessDpiAwareness)GetProcAddress(shcore, "SetProcessDpiAwareness");
58 
59     if (!SetProcessDpiAwareness)
60         return;
61 
62     SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
63 }
64 
65 void format_size(uint64_t size, wstring& s, bool show_bytes) {
66     wstring t, bytes, kb, nb;
67     WCHAR nb2[255];
68     ULONG sr;
69     float f;
70     NUMBERFMTW fmt;
71     WCHAR dec[2], thou[4], grouping[64], *c;
72 #ifdef __REACTOS__
73     WCHAR buffer[64];
74 #endif
75 
76 #ifndef __REACTOS__
77     nb = to_wstring(size);
78 #else
79     swprintf(buffer, L"%I64d", size);
80     nb = wstring(buffer);
81 #endif
82 
83     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, thou, sizeof(thou) / sizeof(WCHAR));
84 
85     dec[0] = '.'; dec[1] = 0; // not used, but silences gcc warning
86 
87     fmt.NumDigits = 0;
88     fmt.LeadingZero = 1;
89     fmt.lpDecimalSep = dec;
90     fmt.lpThousandSep = thou;
91     fmt.NegativeOrder = 0;
92 
93     // Grouping code copied from dlls/shlwapi/string.c in Wine - thank you
94 
95     fmt.Grouping = 0;
96     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SGROUPING, grouping, sizeof(grouping) / sizeof(WCHAR));
97 
98     c = grouping;
99     while (*c) {
100         if (*c >= '0' && *c < '9') {
101             fmt.Grouping *= 10;
102             fmt.Grouping += *c - '0';
103         }
104 
105         c++;
106     }
107 
108     if (fmt.Grouping % 10 == 0)
109         fmt.Grouping /= 10;
110     else
111         fmt.Grouping *= 10;
112 
113     GetNumberFormatW(LOCALE_USER_DEFAULT, 0, nb.c_str(), &fmt, nb2, sizeof(nb2) / sizeof(WCHAR));
114 
115     if (size < 1024) {
116         if (!load_string(module, size == 1 ? IDS_SIZE_BYTE : IDS_SIZE_BYTES, t))
117             throw last_error(GetLastError());
118 
119         wstring_sprintf(s, t, nb2);
120         return;
121     }
122 
123     if (show_bytes) {
124         if (!load_string(module, IDS_SIZE_BYTES, t))
125             throw last_error(GetLastError());
126 
127         wstring_sprintf(bytes, t, nb2);
128     }
129 
130     if (size >= 1152921504606846976) {
131         sr = IDS_SIZE_EB;
132         f = (float)size / 1152921504606846976.0f;
133     } else if (size >= 1125899906842624) {
134         sr = IDS_SIZE_PB;
135         f = (float)size / 1125899906842624.0f;
136     } else if (size >= 1099511627776) {
137         sr = IDS_SIZE_TB;
138         f = (float)size / 1099511627776.0f;
139     } else if (size >= 1073741824) {
140         sr = IDS_SIZE_GB;
141         f = (float)size / 1073741824.0f;
142     } else if (size >= 1048576) {
143         sr = IDS_SIZE_MB;
144         f = (float)size / 1048576.0f;
145     } else {
146         sr = IDS_SIZE_KB;
147         f = (float)size / 1024.0f;
148     }
149 
150     if (!load_string(module, sr, t))
151         throw last_error(GetLastError());
152 
153     if (show_bytes) {
154         wstring_sprintf(kb, t, f);
155 
156         if (!load_string(module, IDS_SIZE_LARGE, t))
157             throw last_error(GetLastError());
158 
159         wstring_sprintf(s, t, kb.c_str(), bytes.c_str());
160     } else
161         wstring_sprintf(s, t, f);
162 }
163 
164 wstring format_message(ULONG last_error) {
165     WCHAR* buf;
166     wstring s;
167 
168     if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
169         last_error, 0, (WCHAR*)&buf, 0, nullptr) == 0) {
170         return L"(error retrieving message)";
171     }
172 
173     s = buf;
174 
175     LocalFree(buf);
176 
177     // remove trailing newline
178     while (s.length() > 0 && (s.substr(s.length() - 1, 1) == L"\r" || s.substr(s.length() - 1, 1) == L"\n"))
179         s = s.substr(0, s.length() - 1);
180 
181     return s;
182 }
183 
184 wstring format_ntstatus(NTSTATUS Status) {
185     _RtlNtStatusToDosError RtlNtStatusToDosError;
186     wstring s;
187     HMODULE ntdll = LoadLibraryW(L"ntdll.dll");
188 
189     if (!ntdll)
190         return L"(error loading ntdll.dll)";
191 
192     RtlNtStatusToDosError = (_RtlNtStatusToDosError)GetProcAddress(ntdll, "RtlNtStatusToDosError");
193 
194     if (!RtlNtStatusToDosError) {
195         FreeLibrary(ntdll);
196         return L"(error loading RtlNtStatusToDosError)";
197     }
198 
199     s = format_message(RtlNtStatusToDosError(Status));
200 
201     FreeLibrary(ntdll);
202 
203     return s;
204 }
205 
206 bool load_string(HMODULE module, UINT id, wstring& s) {
207     int len;
208     LPWSTR retstr = nullptr;
209 
210     len = LoadStringW(module, id, (LPWSTR)&retstr, 0);
211 
212     if (len == 0)
213         return false;
214 
215     s = wstring(retstr, len);
216 
217     return true;
218 }
219 
220 #ifdef _MSC_VER
221 #pragma warning(push)
222 #pragma warning(disable: 4996)
223 #endif
224 
225 void wstring_sprintf(wstring& s, wstring fmt, ...) {
226     int len;
227     va_list args;
228 
229     va_start(args, fmt);
230     len = _vsnwprintf(nullptr, 0, fmt.c_str(), args);
231 
232     if (len == 0)
233         s = L"";
234     else {
235         s.resize(len);
236         _vsnwprintf((wchar_t*)s.c_str(), len, fmt.c_str(), args);
237     }
238 
239     va_end(args);
240 }
241 
242 #ifdef _MSC_VER
243 #pragma warning(pop)
244 #endif
245 
246 extern "C" STDAPI DllCanUnloadNow(void) {
247     return objs_loaded == 0 ? S_OK : S_FALSE;
248 }
249 
250 extern "C" STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) {
251     if (rclsid == CLSID_ShellBtrfsIconHandler) {
252         Factory* fact = new Factory;
253         if (!fact)
254             return E_OUTOFMEMORY;
255         else {
256             fact->type = FactoryIconHandler;
257 
258             return fact->QueryInterface(riid, ppv);
259         }
260     } else if (rclsid == CLSID_ShellBtrfsContextMenu) {
261         Factory* fact = new Factory;
262         if (!fact)
263             return E_OUTOFMEMORY;
264         else {
265             fact->type = FactoryContextMenu;
266 
267             return fact->QueryInterface(riid, ppv);
268         }
269     } else if (rclsid == CLSID_ShellBtrfsPropSheet) {
270         Factory* fact = new Factory;
271         if (!fact)
272             return E_OUTOFMEMORY;
273         else {
274             fact->type = FactoryPropSheet;
275 
276             return fact->QueryInterface(riid, ppv);
277         }
278     } else if (rclsid == CLSID_ShellBtrfsVolPropSheet) {
279         Factory* fact = new Factory;
280         if (!fact)
281             return E_OUTOFMEMORY;
282         else {
283             fact->type = FactoryVolPropSheet;
284 
285             return fact->QueryInterface(riid, ppv);
286         }
287     }
288 
289     return CLASS_E_CLASSNOTAVAILABLE;
290 }
291 
292 static void write_reg_key(HKEY root, const wstring& keyname, const WCHAR* val, const wstring& data) {
293     LONG l;
294     HKEY hk;
295     DWORD dispos;
296 
297     l = RegCreateKeyExW(root, keyname.c_str(), 0, nullptr, 0, KEY_ALL_ACCESS, nullptr, &hk, &dispos);
298     if (l != ERROR_SUCCESS)
299         throw string_error(IDS_REGCREATEKEY_FAILED, l);
300 
301     l = RegSetValueExW(hk, val, 0, REG_SZ, (const BYTE*)data.c_str(), (DWORD)((data.length() + 1) * sizeof(WCHAR)));
302     if (l != ERROR_SUCCESS)
303         throw string_error(IDS_REGSETVALUEEX_FAILED, l);
304 
305     l = RegCloseKey(hk);
306     if (l != ERROR_SUCCESS)
307         throw string_error(IDS_REGCLOSEKEY_FAILED, l);
308 }
309 
310 static void register_clsid(const GUID clsid, const WCHAR* description) {
311     WCHAR* clsidstring;
312     wstring inproc, progid, clsidkeyname;
313     WCHAR dllpath[MAX_PATH];
314 
315     StringFromCLSID(clsid, &clsidstring);
316 
317     try {
318 #ifndef __REACTOS__
319         inproc = L"CLSID\\"s + clsidstring + L"\\InprocServer32"s;
320         progid = L"CLSID\\"s + clsidstring + L"\\ProgId"s;
321         clsidkeyname = L"CLSID\\"s + clsidstring;
322 #else
323         inproc = wstring(L"CLSID\\") + clsidstring + wstring(L"\\InprocServer32");
324         progid = wstring(L"CLSID\\") + clsidstring + wstring(L"\\ProgId");
325         clsidkeyname = wstring(L"CLSID\\") + clsidstring;
326 #endif
327 
328         write_reg_key(HKEY_CLASSES_ROOT, clsidkeyname, nullptr, description);
329 
330         GetModuleFileNameW(module, dllpath, sizeof(dllpath) / sizeof(WCHAR));
331 
332         write_reg_key(HKEY_CLASSES_ROOT, inproc, nullptr, dllpath);
333 
334         write_reg_key(HKEY_CLASSES_ROOT, inproc, L"ThreadingModel", L"Apartment");
335     } catch (...) {
336         CoTaskMemFree(clsidstring);
337         throw;
338     }
339 
340     CoTaskMemFree(clsidstring);
341 }
342 
343 // implementation of RegDeleteTreeW, only available from Vista on
344 static void reg_delete_tree(HKEY hkey, const wstring& keyname) {
345     HKEY k;
346     LSTATUS ret;
347 
348     ret = RegOpenKeyExW(hkey, keyname.c_str(), 0, KEY_READ, &k);
349 
350     if (ret != ERROR_SUCCESS)
351         throw last_error(ret);
352 
353     try {
354         WCHAR* buf;
355         ULONG bufsize;
356 
357         ret = RegQueryInfoKeyW(k, nullptr, nullptr, nullptr, nullptr, &bufsize, nullptr,
358                                nullptr, nullptr, nullptr, nullptr, nullptr);
359         if (ret != ERROR_SUCCESS)
360             throw last_error(ret);
361 
362         bufsize++;
363         buf = new WCHAR[bufsize];
364 
365         try {
366             do {
367                 ULONG size = bufsize;
368 
369                 ret = RegEnumKeyExW(k, 0, buf, &size, nullptr, nullptr, nullptr, nullptr);
370 
371                 if (ret == ERROR_NO_MORE_ITEMS)
372                     break;
373                 else if (ret != ERROR_SUCCESS)
374                     throw last_error(ret);
375 
376                 reg_delete_tree(k, buf);
377             } while (true);
378 
379             ret = RegDeleteKeyW(hkey, keyname.c_str());
380             if (ret != ERROR_SUCCESS)
381                 throw last_error(ret);
382         } catch (...) {
383             delete[] buf;
384             throw;
385         }
386 
387         delete[] buf;
388     } catch (...) {
389         RegCloseKey(k);
390         throw;
391     }
392 
393     RegCloseKey(k);
394 }
395 
396 static void unregister_clsid(const GUID clsid) {
397     WCHAR* clsidstring;
398 
399     StringFromCLSID(clsid, &clsidstring);
400 
401     try {
402 #ifndef __REACTOS__
403         reg_delete_tree(HKEY_CLASSES_ROOT, L"CLSID\\"s + clsidstring);
404 #else
405         wstring path = wstring(L"CLSID\\") + clsidstring;
406         reg_delete_tree(HKEY_CLASSES_ROOT, path);
407 #endif
408     } catch (...) {
409         CoTaskMemFree(clsidstring);
410         throw;
411     }
412 
413     CoTaskMemFree(clsidstring);
414 }
415 
416 static void reg_icon_overlay(const GUID clsid, const wstring& name) {
417     WCHAR* clsidstring;
418 
419     StringFromCLSID(clsid, &clsidstring);
420 
421     try {
422 #ifndef __REACTOS__
423         wstring path = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers\\"s + name;
424 #else
425         wstring path = wstring(L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers\\") + name;
426 #endif
427 
428         write_reg_key(HKEY_LOCAL_MACHINE, path, nullptr, clsidstring);
429     } catch (...) {
430         CoTaskMemFree(clsidstring);
431         throw;
432     }
433 
434     CoTaskMemFree(clsidstring);
435 }
436 
437 static void unreg_icon_overlay(const wstring& name) {
438 #ifndef __REACTOS__
439     reg_delete_tree(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers\\"s + name);
440 #else
441     wstring path = wstring(L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers\\") + name;
442     reg_delete_tree(HKEY_LOCAL_MACHINE, path);
443 #endif
444 }
445 
446 static void reg_context_menu_handler(const GUID clsid, const wstring& filetype, const wstring& name) {
447     WCHAR* clsidstring;
448 
449     StringFromCLSID(clsid, &clsidstring);
450 
451     try {
452 #ifndef __REACTOS__
453         wstring path = filetype + L"\\ShellEx\\ContextMenuHandlers\\"s + name;
454 #else
455         wstring path = filetype + wstring(L"\\ShellEx\\ContextMenuHandlers\\") + name;
456 #endif
457 
458         write_reg_key(HKEY_CLASSES_ROOT, path, nullptr, clsidstring);
459     } catch (...) {
460         CoTaskMemFree(clsidstring);
461         throw;
462     }
463 }
464 
465 static void unreg_context_menu_handler(const wstring& filetype, const wstring& name) {
466 #ifndef __REACTOS__
467     reg_delete_tree(HKEY_CLASSES_ROOT, filetype + L"\\ShellEx\\ContextMenuHandlers\\"s + name);
468 #else
469     wstring path = filetype + wstring(L"\\ShellEx\\ContextMenuHandlers\\") + name;
470     reg_delete_tree(HKEY_CLASSES_ROOT, path);
471 #endif
472 }
473 
474 static void reg_prop_sheet_handler(const GUID clsid, const wstring& filetype, const wstring& name) {
475     WCHAR* clsidstring;
476 
477     StringFromCLSID(clsid, &clsidstring);
478 
479     try {
480 #ifndef __REACTOS__
481         wstring path = filetype + L"\\ShellEx\\PropertySheetHandlers\\"s + name;
482 #else
483         wstring path = filetype + wstring(L"\\ShellEx\\PropertySheetHandlers\\") + name;
484 #endif
485 
486         write_reg_key(HKEY_CLASSES_ROOT, path, nullptr, clsidstring);
487     } catch (...) {
488         CoTaskMemFree(clsidstring);
489         throw;
490     }
491 }
492 
493 static void unreg_prop_sheet_handler(const wstring& filetype, const wstring& name) {
494 #ifndef __REACTOS__
495     reg_delete_tree(HKEY_CLASSES_ROOT, filetype + L"\\ShellEx\\PropertySheetHandlers\\"s + name);
496 #else
497     wstring path = filetype + wstring(L"\\ShellEx\\PropertySheetHandlers\\") + name;
498     reg_delete_tree(HKEY_CLASSES_ROOT, path);
499 #endif
500 }
501 
502 extern "C" STDAPI DllRegisterServer(void) {
503     try {
504         register_clsid(CLSID_ShellBtrfsIconHandler, COM_DESCRIPTION_ICON_HANDLER);
505         register_clsid(CLSID_ShellBtrfsContextMenu, COM_DESCRIPTION_CONTEXT_MENU);
506         register_clsid(CLSID_ShellBtrfsPropSheet, COM_DESCRIPTION_PROP_SHEET);
507         register_clsid(CLSID_ShellBtrfsVolPropSheet, COM_DESCRIPTION_VOL_PROP_SHEET);
508 
509         reg_icon_overlay(CLSID_ShellBtrfsIconHandler, ICON_OVERLAY_NAME);
510 
511         reg_context_menu_handler(CLSID_ShellBtrfsContextMenu, L"Directory\\Background", ICON_OVERLAY_NAME);
512         reg_context_menu_handler(CLSID_ShellBtrfsContextMenu, L"Folder", ICON_OVERLAY_NAME);
513 
514         reg_prop_sheet_handler(CLSID_ShellBtrfsPropSheet, L"Folder", ICON_OVERLAY_NAME);
515         reg_prop_sheet_handler(CLSID_ShellBtrfsPropSheet, L"*", ICON_OVERLAY_NAME);
516         reg_prop_sheet_handler(CLSID_ShellBtrfsVolPropSheet, L"Drive", ICON_OVERLAY_NAME);
517     } catch (const exception& e) {
518         error_message(nullptr, e.what());
519         return E_FAIL;
520     }
521 
522     return S_OK;
523 }
524 
525 extern "C" STDAPI DllUnregisterServer(void) {
526     try {
527         unreg_prop_sheet_handler(L"Folder", ICON_OVERLAY_NAME);
528         unreg_prop_sheet_handler(L"*", ICON_OVERLAY_NAME);
529         unreg_prop_sheet_handler(L"Drive", ICON_OVERLAY_NAME);
530         unreg_context_menu_handler(L"Folder", ICON_OVERLAY_NAME);
531         unreg_context_menu_handler(L"Directory\\Background", ICON_OVERLAY_NAME);
532         unreg_icon_overlay(ICON_OVERLAY_NAME);
533 
534         unregister_clsid(CLSID_ShellBtrfsVolPropSheet);
535         unregister_clsid(CLSID_ShellBtrfsPropSheet);
536         unregister_clsid(CLSID_ShellBtrfsContextMenu);
537         unregister_clsid(CLSID_ShellBtrfsIconHandler);
538     } catch (const exception& e) {
539         error_message(nullptr, e.what());
540         return E_FAIL;
541     }
542 
543     return S_OK;
544 }
545 
546 extern "C" STDAPI DllInstall(BOOL bInstall, LPCWSTR pszCmdLine) {
547     if (bInstall)
548         return DllRegisterServer();
549     else
550         return DllUnregisterServer();
551 }
552 
553 extern "C" BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, void* lpReserved) {
554     if (dwReason == DLL_PROCESS_ATTACH)
555         module = (HMODULE)hModule;
556 
557     return true;
558 }
559 
560 static void create_subvol(const wstring& fn) {
561     size_t found = fn.rfind(L"\\");
562     wstring path, file;
563     win_handle h;
564     btrfs_create_subvol* bcs;
565     IO_STATUS_BLOCK iosb;
566 
567     if (found == wstring::npos) {
568         path = L"";
569         file = fn;
570     } else {
571         path = fn.substr(0, found);
572         file = fn.substr(found + 1);
573     }
574     path += L"\\";
575 
576     h = CreateFileW(path.c_str(), FILE_ADD_SUBDIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
577 
578     if (h == INVALID_HANDLE_VALUE)
579         return;
580 
581     size_t bcslen = offsetof(btrfs_create_subvol, name[0]) + (file.length() * sizeof(WCHAR));
582     bcs = (btrfs_create_subvol*)malloc(bcslen);
583 
584     bcs->readonly = false;
585     bcs->posix = false;
586     bcs->namelen = (uint16_t)(file.length() * sizeof(WCHAR));
587     memcpy(bcs->name, file.c_str(), bcs->namelen);
588 
589     NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SUBVOL, bcs, (ULONG)bcslen, nullptr, 0);
590 }
591 
592 extern "C" void CALLBACK CreateSubvolW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow) {
593     vector<wstring> args;
594 
595     command_line_to_args(lpszCmdLine, args);
596 
597     if (args.size() >= 1)
598         create_subvol(args[0]);
599 }
600 
601 static void create_snapshot2(const wstring& source, const wstring& fn) {
602     size_t found = fn.rfind(L"\\");
603     wstring path, file;
604     win_handle h, src;
605     btrfs_create_snapshot* bcs;
606     IO_STATUS_BLOCK iosb;
607 
608     if (found == wstring::npos) {
609         path = L"";
610         file = fn;
611     } else {
612         path = fn.substr(0, found);
613         file = fn.substr(found + 1);
614     }
615     path += L"\\";
616 
617     src = CreateFileW(source.c_str(), FILE_TRAVERSE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
618     if (src == INVALID_HANDLE_VALUE)
619         return;
620 
621     h = CreateFileW(path.c_str(), FILE_ADD_SUBDIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
622 
623     if (h == INVALID_HANDLE_VALUE)
624         return;
625 
626     size_t bcslen = offsetof(btrfs_create_snapshot, name[0]) + (file.length() * sizeof(WCHAR));
627     bcs = (btrfs_create_snapshot*)malloc(bcslen);
628 
629     bcs->readonly = false;
630     bcs->posix = false;
631     bcs->namelen = (uint16_t)(file.length() * sizeof(WCHAR));
632     memcpy(bcs->name, file.c_str(), bcs->namelen);
633     bcs->subvol = src;
634 
635     NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SNAPSHOT, bcs, (ULONG)bcslen, nullptr, 0);
636 }
637 
638 extern "C" void CALLBACK CreateSnapshotW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow) {
639     vector<wstring> args;
640 
641     command_line_to_args(lpszCmdLine, args);
642 
643     if (args.size() >= 2)
644         create_snapshot2(args[0], args[1]);
645 }
646 
647 void command_line_to_args(LPWSTR cmdline, vector<wstring>& args) {
648     LPWSTR* l;
649     int num_args;
650 
651     args.clear();
652 
653     l = CommandLineToArgvW(cmdline, &num_args);
654 
655     if (!l)
656         return;
657 
658     try {
659         args.reserve(num_args);
660 
661         for (unsigned int i = 0; i < (unsigned int)num_args; i++) {
662             args.push_back(l[i]);
663         }
664     } catch (...) {
665         LocalFree(l);
666         throw;
667     }
668 
669     LocalFree(l);
670 }
671 
672 static string utf16_to_utf8(const wstring_view& utf16) {
673     string utf8;
674     char* buf;
675 
676     if (utf16.empty())
677         return "";
678 
679     auto utf8len = WideCharToMultiByte(CP_UTF8, 0, utf16.data(), static_cast<int>(utf16.length()), nullptr, 0, nullptr, nullptr);
680 
681     if (utf8len == 0)
682         throw last_error(GetLastError());
683 
684     buf = (char*)malloc(utf8len + sizeof(char));
685 
686     if (!buf)
687         throw string_error(IDS_OUT_OF_MEMORY);
688 
689     if (WideCharToMultiByte(CP_UTF8, 0, utf16.data(), static_cast<int>(utf16.length()), buf, utf8len, nullptr, nullptr) == 0) {
690         auto le = GetLastError();
691         free(buf);
692         throw last_error(le);
693     }
694 
695     buf[utf8len] = 0;
696 
697     utf8 = buf;
698 
699     free(buf);
700 
701     return utf8;
702 }
703 
704 #ifdef _MSC_VER
705 #pragma warning(push)
706 #pragma warning(disable: 4996)
707 #endif
708 
709 string_error::string_error(int resno, ...) {
710     wstring fmt, s;
711     int len;
712     va_list args;
713 
714     if (!load_string(module, resno, fmt))
715         throw runtime_error("LoadString failed."); // FIXME
716 
717     va_start(args, resno);
718     len = _vsnwprintf(nullptr, 0, fmt.c_str(), args);
719 
720     if (len == 0)
721         s = L"";
722     else {
723         s.resize(len);
724         _vsnwprintf((wchar_t*)s.c_str(), len, fmt.c_str(), args);
725     }
726 
727     va_end(args);
728 
729     msg = utf16_to_utf8(s);
730 }
731 
732 #ifdef _MSC_VER
733 #pragma warning(pop)
734 #endif
735 
736 wstring utf8_to_utf16(const string_view& utf8) {
737     wstring ret;
738     WCHAR* buf;
739 
740     if (utf8.empty())
741         return L"";
742 
743     auto utf16len = MultiByteToWideChar(CP_UTF8, 0, utf8.data(), (int)utf8.length(), nullptr, 0);
744 
745     if (utf16len == 0)
746         throw last_error(GetLastError());
747 
748     buf = (WCHAR*)malloc((utf16len + 1) * sizeof(WCHAR));
749 
750     if (!buf)
751         throw string_error(IDS_OUT_OF_MEMORY);
752 
753     if (MultiByteToWideChar(CP_UTF8, 0, utf8.data(), (int)utf8.length(), buf, utf16len) == 0) {
754         auto le = GetLastError();
755         free(buf);
756         throw last_error(le);
757     }
758 
759     buf[utf16len] = 0;
760 
761     ret = buf;
762 
763     free(buf);
764 
765     return ret;
766 }
767 
768 last_error::last_error(DWORD errnum) {
769     WCHAR* buf;
770 
771     if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
772         errnum, 0, (WCHAR*)&buf, 0, nullptr) == 0)
773         throw runtime_error("FormatMessage failed");
774 
775     try {
776         msg = utf16_to_utf8(buf);
777     } catch (...) {
778         LocalFree(buf);
779         throw;
780     }
781 
782     LocalFree(buf);
783 }
784 
785 void error_message(HWND hwnd, const char* msg) {
786     wstring title;
787 
788     load_string(module, IDS_ERROR, title);
789 
790     auto wmsg = utf8_to_utf16(msg);
791 
792     MessageBoxW(hwnd, wmsg.c_str(), title.c_str(), MB_ICONERROR);
793 }
794 
795 ntstatus_error::ntstatus_error(NTSTATUS Status) : Status(Status) {
796     _RtlNtStatusToDosError RtlNtStatusToDosError;
797     HMODULE ntdll = LoadLibraryW(L"ntdll.dll");
798     WCHAR* buf;
799 
800     if (!ntdll)
801         throw runtime_error("Error loading ntdll.dll.");
802 
803     try {
804         RtlNtStatusToDosError = (_RtlNtStatusToDosError)GetProcAddress(ntdll, "RtlNtStatusToDosError");
805 
806         if (!RtlNtStatusToDosError)
807             throw runtime_error("Error loading RtlNtStatusToDosError in ntdll.dll.");
808 
809         if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
810             RtlNtStatusToDosError(Status), 0, (WCHAR*)&buf, 0, nullptr) == 0)
811             throw runtime_error("FormatMessage failed");
812 
813         try {
814             msg = utf16_to_utf8(buf);
815         } catch (...) {
816             LocalFree(buf);
817             throw;
818         }
819 
820         LocalFree(buf);
821     } catch (...) {
822         FreeLibrary(ntdll);
823         throw;
824     }
825 
826     FreeLibrary(ntdll);
827 }
828