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(), (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 static void unregister_clsid(const GUID clsid) {
 344     WCHAR* clsidstring;
 345
 346     StringFromCLSID(clsid, &clsidstring);
 347
 348     try {
 349         WCHAR clsidkeyname[MAX_PATH];
 350
 351         wsprintfW(clsidkeyname, L"CLSID\\%s", clsidstring);
 352
 353         LONG l = RegDeleteTreeW(HKEY_CLASSES_ROOT, clsidkeyname);
 354
 355         if (l != ERROR_SUCCESS)
 356             throw string_error(IDS_REGDELETETREE_FAILED, l);
 357     } catch (...) {
 358         CoTaskMemFree(clsidstring);
 359         throw;
 360     }
 361
 362     CoTaskMemFree(clsidstring);
 363 }
 364
 365 static void reg_icon_overlay(const GUID clsid, const wstring& name) {
 366     WCHAR* clsidstring;
 367
 368     StringFromCLSID(clsid, &clsidstring);
 369
 370     try {
 371 #ifndef __REACTOS__
 372         wstring path = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers\\"s + name;
 373 #else
 374         wstring path = wstring(L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers\\") + name;
 375 #endif
 376
 377         write_reg_key(HKEY_LOCAL_MACHINE, path, nullptr, clsidstring);
 378     } catch (...) {
 379         CoTaskMemFree(clsidstring);
 380         throw;
 381     }
 382
 383     CoTaskMemFree(clsidstring);
 384 }
 385
 386 static void unreg_icon_overlay(const wstring& name) {
 387 #ifndef __REACTOS__
 388     wstring path = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers\\"s + name;
 389 #else
 390     wstring path = wstring(L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers\\") + name;
 391 #endif
 392
 393     LONG l = RegDeleteTreeW(HKEY_LOCAL_MACHINE, path.c_str());
 394
 395     if (l != ERROR_SUCCESS)
 396         throw string_error(IDS_REGDELETETREE_FAILED, l);
 397 }
 398
 399 static void reg_context_menu_handler(const GUID clsid, const wstring& filetype, const wstring& name) {
 400     WCHAR* clsidstring;
 401
 402     StringFromCLSID(clsid, &clsidstring);
 403
 404     try {
 405 #ifndef __REACTOS__
 406         wstring path = filetype + L"\\ShellEx\\ContextMenuHandlers\\"s + name;
 407 #else
 408         wstring path = filetype + wstring(L"\\ShellEx\\ContextMenuHandlers\\") + name;
 409 #endif
 410
 411         write_reg_key(HKEY_CLASSES_ROOT, path, nullptr, clsidstring);
 412     } catch (...) {
 413         CoTaskMemFree(clsidstring);
 414         throw;
 415     }
 416 }
 417
 418 static void unreg_context_menu_handler(const wstring& filetype, const wstring& name) {
 419 #ifndef __REACTOS__
 420     wstring path = filetype + L"\\ShellEx\\ContextMenuHandlers\\"s + name;
 421 #else
 422     wstring path = filetype + wstring(L"\\ShellEx\\ContextMenuHandlers\\") + name;
 423 #endif
 424
 425     LONG l = RegDeleteTreeW(HKEY_CLASSES_ROOT, path.c_str());
 426
 427     if (l != ERROR_SUCCESS)
 428         throw string_error(IDS_REGDELETETREE_FAILED, l);
 429 }
 430
 431 static void reg_prop_sheet_handler(const GUID clsid, const wstring& filetype, const wstring& name) {
 432     WCHAR* clsidstring;
 433
 434     StringFromCLSID(clsid, &clsidstring);
 435
 436     try {
 437 #ifndef __REACTOS__
 438         wstring path = filetype + L"\\ShellEx\\PropertySheetHandlers\\"s + name;
 439 #else
 440         wstring path = filetype + wstring(L"\\ShellEx\\PropertySheetHandlers\\") + name;
 441 #endif
 442
 443         write_reg_key(HKEY_CLASSES_ROOT, path, nullptr, clsidstring);
 444     } catch (...) {
 445         CoTaskMemFree(clsidstring);
 446         throw;
 447     }
 448 }
 449
 450 static void unreg_prop_sheet_handler(const wstring& filetype, const wstring& name) {
 451 #ifndef __REACTOS__
 452     wstring path = filetype + L"\\ShellEx\\PropertySheetHandlers\\"s + name;
 453 #else
 454     wstring path = filetype + wstring(L"\\ShellEx\\PropertySheetHandlers\\") + name;
 455 #endif
 456
 457     LONG l = RegDeleteTreeW(HKEY_CLASSES_ROOT, path.c_str());
 458
 459     if (l != ERROR_SUCCESS)
 460         throw string_error(IDS_REGDELETETREE_FAILED, l);
 461 }
 462
 463 extern "C" STDAPI DllRegisterServer(void) {
 464     try {
 465         register_clsid(CLSID_ShellBtrfsIconHandler, COM_DESCRIPTION_ICON_HANDLER);
 466         register_clsid(CLSID_ShellBtrfsContextMenu, COM_DESCRIPTION_CONTEXT_MENU);
 467         register_clsid(CLSID_ShellBtrfsPropSheet, COM_DESCRIPTION_PROP_SHEET);
 468         register_clsid(CLSID_ShellBtrfsVolPropSheet, COM_DESCRIPTION_VOL_PROP_SHEET);
 469
 470         reg_icon_overlay(CLSID_ShellBtrfsIconHandler, ICON_OVERLAY_NAME);
 471
 472         reg_context_menu_handler(CLSID_ShellBtrfsContextMenu, L"Directory\\Background", ICON_OVERLAY_NAME);
 473         reg_context_menu_handler(CLSID_ShellBtrfsContextMenu, L"Folder", ICON_OVERLAY_NAME);
 474
 475         reg_prop_sheet_handler(CLSID_ShellBtrfsPropSheet, L"Folder", ICON_OVERLAY_NAME);
 476         reg_prop_sheet_handler(CLSID_ShellBtrfsPropSheet, L"*", ICON_OVERLAY_NAME);
 477         reg_prop_sheet_handler(CLSID_ShellBtrfsVolPropSheet, L"Drive", ICON_OVERLAY_NAME);
 478     } catch (const exception& e) {
 479         error_message(nullptr, e.what());
 480         return E_FAIL;
 481     }
 482
 483     return S_OK;
 484 }
 485
 486 extern "C" STDAPI DllUnregisterServer(void) {
 487     try {
 488         unreg_prop_sheet_handler(L"Folder", ICON_OVERLAY_NAME);
 489         unreg_prop_sheet_handler(L"*", ICON_OVERLAY_NAME);
 490         unreg_prop_sheet_handler(L"Drive", ICON_OVERLAY_NAME);
 491         unreg_context_menu_handler(L"Folder", ICON_OVERLAY_NAME);
 492         unreg_context_menu_handler(L"Directory\\Background", ICON_OVERLAY_NAME);
 493         unreg_icon_overlay(ICON_OVERLAY_NAME);
 494
 495         unregister_clsid(CLSID_ShellBtrfsVolPropSheet);
 496         unregister_clsid(CLSID_ShellBtrfsPropSheet);
 497         unregister_clsid(CLSID_ShellBtrfsContextMenu);
 498         unregister_clsid(CLSID_ShellBtrfsIconHandler);
 499     } catch (const exception& e) {
 500         error_message(nullptr, e.what());
 501         return E_FAIL;
 502     }
 503
 504     return S_OK;
 505 }
 506
 507 extern "C" STDAPI DllInstall(BOOL bInstall, LPCWSTR pszCmdLine) {
 508     if (bInstall)
 509         return DllRegisterServer();
 510     else
 511         return DllUnregisterServer();
 512 }
 513
 514 extern "C" BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, void* lpReserved) {
 515     if (dwReason == DLL_PROCESS_ATTACH)
 516         module = (HMODULE)hModule;
 517
 518     return true;
 519 }
 520
 521 static void create_subvol(const wstring& fn) {
 522     size_t found = fn.rfind(L"\\");
 523     wstring path, file;
 524     win_handle h;
 525     ULONG bcslen;
 526     btrfs_create_subvol* bcs;
 527     IO_STATUS_BLOCK iosb;
 528
 529     if (found == wstring::npos) {
 530         path = L"";
 531         file = fn;
 532     } else {
 533         path = fn.substr(0, found);
 534         file = fn.substr(found + 1);
 535     }
 536     path += L"\\";
 537
 538     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);
 539
 540     if (h == INVALID_HANDLE_VALUE)
 541         return;
 542
 543     bcslen = offsetof(btrfs_create_subvol, name[0]) + (file.length() * sizeof(WCHAR));
 544     bcs = (btrfs_create_subvol*)malloc(bcslen);
 545
 546     bcs->readonly = false;
 547     bcs->posix = false;
 548     bcs->namelen = (uint16_t)(file.length() * sizeof(WCHAR));
 549     memcpy(bcs->name, file.c_str(), bcs->namelen);
 550
 551     NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SUBVOL, bcs, bcslen, nullptr, 0);
 552 }
 553
 554 extern "C" void CALLBACK CreateSubvolW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow) {
 555     vector<wstring> args;
 556
 557     command_line_to_args(lpszCmdLine, args);
 558
 559     if (args.size() >= 1)
 560         create_subvol(args[0]);
 561 }
 562
 563 static void create_snapshot2(const wstring& source, const wstring& fn) {
 564     size_t found = fn.rfind(L"\\");
 565     wstring path, file;
 566     win_handle h, src;
 567     ULONG bcslen;
 568     btrfs_create_snapshot* bcs;
 569     IO_STATUS_BLOCK iosb;
 570
 571     if (found == wstring::npos) {
 572         path = L"";
 573         file = fn;
 574     } else {
 575         path = fn.substr(0, found);
 576         file = fn.substr(found + 1);
 577     }
 578     path += L"\\";
 579
 580     src = CreateFileW(source.c_str(), FILE_TRAVERSE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
 581     if (src == INVALID_HANDLE_VALUE)
 582         return;
 583
 584     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);
 585
 586     if (h == INVALID_HANDLE_VALUE)
 587         return;
 588
 589     bcslen = offsetof(btrfs_create_snapshot, name[0]) + (file.length() * sizeof(WCHAR));
 590     bcs = (btrfs_create_snapshot*)malloc(bcslen);
 591
 592     bcs->readonly = false;
 593     bcs->posix = false;
 594     bcs->namelen = (uint16_t)(file.length() * sizeof(WCHAR));
 595     memcpy(bcs->name, file.c_str(), bcs->namelen);
 596     bcs->subvol = src;
 597
 598     NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SNAPSHOT, bcs, bcslen, nullptr, 0);
 599 }
 600
 601 extern "C" void CALLBACK CreateSnapshotW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow) {
 602     vector<wstring> args;
 603
 604     command_line_to_args(lpszCmdLine, args);
 605
 606     if (args.size() >= 2)
 607         create_snapshot2(args[0], args[1]);
 608 }
 609
 610 void command_line_to_args(LPWSTR cmdline, vector<wstring> args) {
 611     LPWSTR* l;
 612     int num_args;
 613
 614     args.clear();
 615
 616     l = CommandLineToArgvW(cmdline, &num_args);
 617
 618     if (!l)
 619         return;
 620
 621     try {
 622         args.reserve(num_args);
 623
 624         for (unsigned int i = 0; i < (unsigned int)num_args; i++) {
 625             args.push_back(l[i]);
 626         }
 627     } catch (...) {
 628         LocalFree(l);
 629         throw;
 630     }
 631
 632     LocalFree(l);
 633 }
 634
 635 #ifdef _MSC_VER
 636 #pragma warning(push)
 637 #pragma warning(disable: 4996)
 638 #endif
 639
 640 string_error::string_error(int resno, ...) {
 641     wstring fmt, s;
 642     int len;
 643     va_list args;
 644
 645     if (!load_string(module, resno, fmt))
 646         throw runtime_error("LoadString failed."); // FIXME
 647
 648     va_start(args, resno);
 649     len = _vsnwprintf(nullptr, 0, fmt.c_str(), args);
 650
 651     if (len == 0)
 652         s = L"";
 653     else {
 654         s.resize(len);
 655         _vsnwprintf((wchar_t*)s.c_str(), len, fmt.c_str(), args);
 656     }
 657
 658     va_end(args);
 659
 660     utf16_to_utf8(s, msg);
 661 }
 662
 663 #ifdef _MSC_VER
 664 #pragma warning(pop)
 665 #endif
 666
 667 void utf8_to_utf16(const string& utf8, wstring& utf16) {
 668     NTSTATUS Status;
 669     ULONG utf16len;
 670     WCHAR* buf;
 671
 672     Status = RtlUTF8ToUnicodeN(nullptr, 0, &utf16len, utf8.c_str(), utf8.length());
 673     if (!NT_SUCCESS(Status))
 674         throw string_error(IDS_RECV_RTLUTF8TOUNICODEN_FAILED, Status, format_ntstatus(Status).c_str());
 675
 676     buf = (WCHAR*)malloc(utf16len + sizeof(WCHAR));
 677
 678     if (!buf)
 679         throw string_error(IDS_OUT_OF_MEMORY);
 680
 681     Status = RtlUTF8ToUnicodeN(buf, utf16len, &utf16len, utf8.c_str(), utf8.length());
 682     if (!NT_SUCCESS(Status)) {
 683         free(buf);
 684         throw string_error(IDS_RECV_RTLUTF8TOUNICODEN_FAILED, Status, format_ntstatus(Status).c_str());
 685     }
 686
 687     buf[utf16len / sizeof(WCHAR)] = 0;
 688
 689     utf16 = buf;
 690
 691     free(buf);
 692 }
 693
 694 void utf16_to_utf8(const wstring& utf16, string& utf8) {
 695     NTSTATUS Status;
 696     ULONG utf8len;
 697     char* buf;
 698
 699     Status = RtlUnicodeToUTF8N(nullptr, 0, &utf8len, utf16.c_str(), utf16.length() * sizeof(WCHAR));
 700     if (!NT_SUCCESS(Status))
 701         throw string_error(IDS_RECV_RTLUNICODETOUTF8N_FAILED, Status, format_ntstatus(Status).c_str());
 702
 703     buf = (char*)malloc(utf8len + sizeof(char));
 704
 705     if (!buf)
 706         throw string_error(IDS_OUT_OF_MEMORY);
 707
 708     Status = RtlUnicodeToUTF8N(buf, utf8len, &utf8len, utf16.c_str(), utf16.length() * sizeof(WCHAR));
 709     if (!NT_SUCCESS(Status)) {
 710         free(buf);
 711         throw string_error(IDS_RECV_RTLUNICODETOUTF8N_FAILED, Status, format_ntstatus(Status).c_str());
 712     }
 713
 714     buf[utf8len] = 0;
 715
 716     utf8 = buf;
 717
 718     free(buf);
 719 }
 720
 721 last_error::last_error(DWORD errnum) {
 722     WCHAR* buf;
 723
 724     if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
 725         errnum, 0, (WCHAR*)&buf, 0, nullptr) == 0)
 726         throw runtime_error("FormatMessage failed");
 727
 728     try {
 729         utf16_to_utf8(buf, msg);
 730     } catch (...) {
 731         LocalFree(buf);
 732         throw;
 733     }
 734
 735     LocalFree(buf);
 736 }
 737
 738 void error_message(HWND hwnd, const char* msg) {
 739     wstring title, wmsg;
 740
 741     load_string(module, IDS_ERROR, title);
 742
 743     utf8_to_utf16(msg, wmsg);
 744
 745     MessageBoxW(hwnd, wmsg.c_str(), title.c_str(), MB_ICONERROR);
 746 }
 747
 748 ntstatus_error::ntstatus_error(NTSTATUS Status) {
 749     _RtlNtStatusToDosError RtlNtStatusToDosError;
 750     HMODULE ntdll = LoadLibraryW(L"ntdll.dll");
 751     WCHAR* buf;
 752
 753     if (!ntdll)
 754         throw runtime_error("Error loading ntdll.dll.");
 755
 756     try {
 757         RtlNtStatusToDosError = (_RtlNtStatusToDosError)GetProcAddress(ntdll, "RtlNtStatusToDosError");
 758
 759         if (!RtlNtStatusToDosError)
 760             throw runtime_error("Error loading RtlNtStatusToDosError in ntdll.dll.");
 761
 762         if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
 763             RtlNtStatusToDosError(Status), 0, (WCHAR*)&buf, 0, nullptr) == 0)
 764             throw runtime_error("FormatMessage failed");
 765
 766         try {
 767             utf16_to_utf8(buf, msg);
 768         } catch (...) {
 769             LocalFree(buf);
 770             throw;
 771         }
 772
 773         LocalFree(buf);
 774     } catch (...) {
 775         FreeLibrary(ntdll);
 776         throw;
 777     }
 778
 779     FreeLibrary(ntdll);
 780 }
 781
 782 #ifdef __REACTOS__
 783 NTSTATUS NTAPI RtlUnicodeToUTF8N(CHAR *utf8_dest, ULONG utf8_bytes_max,
 784                                  ULONG *utf8_bytes_written,
 785                                  const WCHAR *uni_src, ULONG uni_bytes)
 786 {
 787     NTSTATUS status;
 788     ULONG i;
 789     ULONG written;
 790     ULONG ch;
 791     BYTE utf8_ch[4];
 792     ULONG utf8_ch_len;
 793
 794     if (!uni_src)
 795         return STATUS_INVALID_PARAMETER_4;
 796     if (!utf8_bytes_written)
 797         return STATUS_INVALID_PARAMETER;
 798     if (utf8_dest && uni_bytes % sizeof(WCHAR))
 799         return STATUS_INVALID_PARAMETER_5;
 800
 801     written = 0;
 802     status = STATUS_SUCCESS;
 803
 804     for (i = 0; i < uni_bytes / sizeof(WCHAR); i++)
 805     {
 806         /* decode UTF-16 into ch */
 807         ch = uni_src[i];
 808         if (ch >= 0xdc00 && ch <= 0xdfff)
 809         {
 810             ch = 0xfffd;
 811             status = STATUS_SOME_NOT_MAPPED;
 812         }
 813         else if (ch >= 0xd800 && ch <= 0xdbff)
 814         {
 815             if (i + 1 < uni_bytes / sizeof(WCHAR))
 816             {
 817                 ch -= 0xd800;
 818                 ch <<= 10;
 819                 if (uni_src[i + 1] >= 0xdc00 && uni_src[i + 1] <= 0xdfff)
 820                 {
 821                     ch |= uni_src[i + 1] - 0xdc00;
 822                     ch += 0x010000;
 823                     i++;
 824                 }
 825                 else
 826                 {
 827                     ch = 0xfffd;
 828                     status = STATUS_SOME_NOT_MAPPED;
 829                 }
 830             }
 831             else
 832             {
 833                 ch = 0xfffd;
 834                 status = STATUS_SOME_NOT_MAPPED;
 835             }
 836         }
 837
 838         /* encode ch as UTF-8 */
 839         ASSERT(ch <= 0x10ffff);
 840         if (ch < 0x80)
 841         {
 842             utf8_ch[0] = ch & 0x7f;
 843             utf8_ch_len = 1;
 844         }
 845         else if (ch < 0x800)
 846         {
 847             utf8_ch[0] = 0xc0 | (ch >>  6 & 0x1f);
 848             utf8_ch[1] = 0x80 | (ch >>  0 & 0x3f);
 849             utf8_ch_len = 2;
 850         }
 851         else if (ch < 0x10000)
 852         {
 853             utf8_ch[0] = 0xe0 | (ch >> 12 & 0x0f);
 854             utf8_ch[1] = 0x80 | (ch >>  6 & 0x3f);
 855             utf8_ch[2] = 0x80 | (ch >>  0 & 0x3f);
 856             utf8_ch_len = 3;
 857         }
 858         else if (ch < 0x200000)
 859         {
 860             utf8_ch[0] = 0xf0 | (ch >> 18 & 0x07);
 861             utf8_ch[1] = 0x80 | (ch >> 12 & 0x3f);
 862             utf8_ch[2] = 0x80 | (ch >>  6 & 0x3f);
 863             utf8_ch[3] = 0x80 | (ch >>  0 & 0x3f);
 864             utf8_ch_len = 4;
 865         }
 866
 867         if (!utf8_dest)
 868         {
 869             written += utf8_ch_len;
 870             continue;
 871         }
 872
 873         if (utf8_bytes_max >= utf8_ch_len)
 874         {
 875             memcpy(utf8_dest, utf8_ch, utf8_ch_len);
 876             utf8_dest += utf8_ch_len;
 877             utf8_bytes_max -= utf8_ch_len;
 878             written += utf8_ch_len;
 879         }
 880         else
 881         {
 882             utf8_bytes_max = 0;
 883             status = STATUS_BUFFER_TOO_SMALL;
 884         }
 885     }
 886
 887     *utf8_bytes_written = written;
 888     return status;
 889 }
 890 #endif