dll/shellext/shellbtrfs/main.cpp

   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));
 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 }