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 #ifndef __REACTOS__ 20 #include <windows.h> 21 #include <strsafe.h> 22 #include <stddef.h> 23 #include <winternl.h> 24 #else 25 #define WIN32_NO_STATUS 26 #include <windef.h> 27 #include <winbase.h> 28 #include <strsafe.h> 29 #include <shellapi.h> 30 #include <winioctl.h> 31 #include <ndk/iofuncs.h> 32 #undef DeleteFile 33 #endif 34 #include <wincodec.h> 35 #include <sstream> 36 #include <iostream> 37 38 #define NO_SHLWAPI_STRFCNS 39 #include <shlwapi.h> 40 41 #include "contextmenu.h" 42 #include "resource.h" 43 #ifndef __REACTOS__ 44 #include "../btrfsioctl.h" 45 #else 46 #include "btrfsioctl.h" 47 #endif 48 49 #define NEW_SUBVOL_VERBA "newsubvol" 50 #define NEW_SUBVOL_VERBW L"newsubvol" 51 #define SNAPSHOT_VERBA "snapshot" 52 #define SNAPSHOT_VERBW L"snapshot" 53 #define REFLINK_VERBA "reflink" 54 #define REFLINK_VERBW L"reflink" 55 #define RECV_VERBA "recvsubvol" 56 #define RECV_VERBW L"recvsubvol" 57 #define SEND_VERBA "sendsubvol" 58 #define SEND_VERBW L"sendsubvol" 59 60 typedef struct { 61 ULONG ReparseTag; 62 USHORT ReparseDataLength; 63 USHORT Reserved; 64 } reparse_header; 65 66 static void path_remove_file(wstring& path); 67 68 // FIXME - don't assume subvol's top inode is 0x100 69 70 HRESULT __stdcall BtrfsContextMenu::QueryInterface(REFIID riid, void **ppObj) { 71 if (riid == IID_IUnknown || riid == IID_IContextMenu) { 72 *ppObj = static_cast<IContextMenu*>(this); 73 AddRef(); 74 return S_OK; 75 } else if (riid == IID_IShellExtInit) { 76 *ppObj = static_cast<IShellExtInit*>(this); 77 AddRef(); 78 return S_OK; 79 } 80 81 *ppObj = nullptr; 82 return E_NOINTERFACE; 83 } 84 85 HRESULT __stdcall BtrfsContextMenu::Initialize(PCIDLIST_ABSOLUTE pidlFolder, IDataObject* pdtobj, HKEY hkeyProgID) { 86 IO_STATUS_BLOCK iosb; 87 btrfs_get_file_ids bgfi; 88 NTSTATUS Status; 89 90 if (!pidlFolder) { 91 FORMATETC format = { CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; 92 UINT num_files, i; 93 WCHAR fn[MAX_PATH]; 94 HDROP hdrop; 95 96 if (!pdtobj) 97 return E_FAIL; 98 99 stgm.tymed = TYMED_HGLOBAL; 100 101 if (FAILED(pdtobj->GetData(&format, &stgm))) 102 return E_INVALIDARG; 103 104 stgm_set = true; 105 106 hdrop = (HDROP)GlobalLock(stgm.hGlobal); 107 108 if (!hdrop) { 109 ReleaseStgMedium(&stgm); 110 stgm_set = false; 111 return E_INVALIDARG; 112 } 113 114 num_files = DragQueryFileW((HDROP)stgm.hGlobal, 0xFFFFFFFF, nullptr, 0); 115 116 for (i = 0; i < num_files; i++) { 117 if (DragQueryFileW((HDROP)stgm.hGlobal, i, fn, sizeof(fn) / sizeof(WCHAR))) { 118 win_handle h = CreateFileW(fn, FILE_TRAVERSE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 119 120 if (h != INVALID_HANDLE_VALUE) { 121 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_FILE_IDS, nullptr, 0, &bgfi, sizeof(btrfs_get_file_ids)); 122 123 if (NT_SUCCESS(Status) && bgfi.inode == 0x100 && !bgfi.top) { 124 wstring parpath; 125 126 { 127 win_handle h2; 128 129 parpath = fn; 130 path_remove_file(parpath); 131 132 h2 = CreateFileW(parpath.c_str(), FILE_ADD_SUBDIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, 133 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 134 135 if (h2 != INVALID_HANDLE_VALUE) 136 allow_snapshot = true; 137 } 138 139 ignore = false; 140 bg = false; 141 142 GlobalUnlock(hdrop); 143 return S_OK; 144 } 145 } 146 } 147 } 148 149 GlobalUnlock(hdrop); 150 151 return S_OK; 152 } 153 154 { 155 WCHAR pathbuf[MAX_PATH]; 156 157 if (!SHGetPathFromIDListW(pidlFolder, pathbuf)) 158 return E_FAIL; 159 160 path = pathbuf; 161 } 162 163 { 164 // check we have permissions to create new subdirectory 165 166 win_handle 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); 167 168 if (h == INVALID_HANDLE_VALUE) 169 return E_FAIL; 170 171 // check is Btrfs volume 172 173 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_FILE_IDS, nullptr, 0, &bgfi, sizeof(btrfs_get_file_ids)); 174 175 if (!NT_SUCCESS(Status)) 176 return E_FAIL; 177 } 178 179 ignore = false; 180 bg = true; 181 182 return S_OK; 183 } 184 185 static bool get_volume_path_parent(const WCHAR* fn, WCHAR* volpath, ULONG volpathlen) { 186 WCHAR *f, *p; 187 bool b; 188 189 f = PathFindFileNameW(fn); 190 191 if (f == fn) 192 return GetVolumePathNameW(fn, volpath, volpathlen); 193 194 p = (WCHAR*)malloc((f - fn + 1) * sizeof(WCHAR)); 195 memcpy(p, fn, (f - fn) * sizeof(WCHAR)); 196 p[f - fn] = 0; 197 198 b = GetVolumePathNameW(p, volpath, volpathlen); 199 200 free(p); 201 202 return b; 203 } 204 205 static bool show_reflink_paste(const wstring& path) { 206 HDROP hdrop; 207 HANDLE lh; 208 ULONG num_files; 209 WCHAR fn[MAX_PATH], volpath1[255], volpath2[255]; 210 211 if (!IsClipboardFormatAvailable(CF_HDROP)) 212 return false; 213 214 if (!GetVolumePathNameW(path.c_str(), volpath1, sizeof(volpath1) / sizeof(WCHAR))) 215 return false; 216 217 if (!OpenClipboard(nullptr)) 218 return false; 219 220 hdrop = (HDROP)GetClipboardData(CF_HDROP); 221 222 if (!hdrop) { 223 CloseClipboard(); 224 return false; 225 } 226 227 lh = GlobalLock(hdrop); 228 229 if (!lh) { 230 CloseClipboard(); 231 return false; 232 } 233 234 num_files = DragQueryFileW(hdrop, 0xFFFFFFFF, nullptr, 0); 235 236 if (num_files == 0) { 237 GlobalUnlock(lh); 238 CloseClipboard(); 239 return false; 240 } 241 242 if (!DragQueryFileW(hdrop, 0, fn, sizeof(fn) / sizeof(WCHAR))) { 243 GlobalUnlock(lh); 244 CloseClipboard(); 245 return false; 246 } 247 248 if (!get_volume_path_parent(fn, volpath2, sizeof(volpath2) / sizeof(WCHAR))) { 249 GlobalUnlock(lh); 250 CloseClipboard(); 251 return false; 252 } 253 254 GlobalUnlock(lh); 255 256 CloseClipboard(); 257 258 return !wcscmp(volpath1, volpath2); 259 } 260 261 // The code for putting an icon against a menu item comes from: 262 // http://web.archive.org/web/20070208005514/http://shellrevealed.com/blogs/shellblog/archive/2007/02/06/Vista-Style-Menus_2C00_-Part-1-_2D00_-Adding-icons-to-standard-menus.aspx 263 264 static void InitBitmapInfo(BITMAPINFO* pbmi, ULONG cbInfo, LONG cx, LONG cy, WORD bpp) { 265 ZeroMemory(pbmi, cbInfo); 266 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 267 pbmi->bmiHeader.biPlanes = 1; 268 pbmi->bmiHeader.biCompression = BI_RGB; 269 270 pbmi->bmiHeader.biWidth = cx; 271 pbmi->bmiHeader.biHeight = cy; 272 pbmi->bmiHeader.biBitCount = bpp; 273 } 274 275 static HRESULT Create32BitHBITMAP(HDC hdc, const SIZE *psize, void **ppvBits, HBITMAP* phBmp) { 276 BITMAPINFO bmi; 277 HDC hdcUsed; 278 279 *phBmp = nullptr; 280 281 InitBitmapInfo(&bmi, sizeof(bmi), psize->cx, psize->cy, 32); 282 283 hdcUsed = hdc ? hdc : GetDC(nullptr); 284 285 if (hdcUsed) { 286 *phBmp = CreateDIBSection(hdcUsed, &bmi, DIB_RGB_COLORS, ppvBits, nullptr, 0); 287 if (hdc != hdcUsed) 288 ReleaseDC(nullptr, hdcUsed); 289 } 290 291 return !*phBmp ? E_OUTOFMEMORY : S_OK; 292 } 293 294 void BtrfsContextMenu::get_uac_icon() { 295 IWICImagingFactory* factory = nullptr; 296 IWICBitmap* bitmap; 297 HRESULT hr; 298 299 #ifdef __REACTOS__ 300 hr = CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (void **)&factory); 301 #else 302 hr = CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&factory)); 303 #endif 304 305 if (SUCCEEDED(hr)) { 306 HANDLE icon; 307 308 // We can't use IDI_SHIELD, as that will only give us the full-size icon 309 icon = LoadImageW(GetModuleHandleW(L"user32.dll"), MAKEINTRESOURCEW(106)/* UAC shield */, IMAGE_ICON, 310 GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR); 311 312 hr = factory->CreateBitmapFromHICON((HICON)icon, &bitmap); 313 if (SUCCEEDED(hr)) { 314 UINT cx, cy; 315 316 hr = bitmap->GetSize(&cx, &cy); 317 if (SUCCEEDED(hr)) { 318 SIZE sz; 319 BYTE* buf; 320 321 sz.cx = (int)cx; 322 sz.cy = -(int)cy; 323 324 hr = Create32BitHBITMAP(nullptr, &sz, (void**)&buf, &uacicon); 325 if (SUCCEEDED(hr)) { 326 UINT stride = (UINT)(cx * sizeof(DWORD)); 327 UINT buflen = cy * stride; 328 bitmap->CopyPixels(nullptr, stride, buflen, buf); 329 } 330 } 331 332 bitmap->Release(); 333 } 334 335 factory->Release(); 336 } 337 } 338 339 HRESULT __stdcall BtrfsContextMenu::QueryContextMenu(HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags) { 340 wstring str; 341 ULONG entries = 0; 342 343 if (ignore) 344 return E_INVALIDARG; 345 346 if (uFlags & CMF_DEFAULTONLY) 347 return S_OK; 348 349 if (!bg) { 350 if (allow_snapshot) { 351 if (load_string(module, IDS_CREATE_SNAPSHOT, str) == 0) 352 return E_FAIL; 353 354 if (!InsertMenuW(hmenu, indexMenu, MF_BYPOSITION, idCmdFirst, str.c_str())) 355 return E_FAIL; 356 357 entries = 1; 358 } 359 360 if (idCmdFirst + entries <= idCmdLast) { 361 MENUITEMINFOW mii; 362 363 if (load_string(module, IDS_SEND_SUBVOL, str) == 0) 364 return E_FAIL; 365 366 if (!uacicon) 367 get_uac_icon(); 368 369 memset(&mii, 0, sizeof(MENUITEMINFOW)); 370 mii.cbSize = sizeof(MENUITEMINFOW); 371 mii.fMask = MIIM_STRING | MIIM_ID | MIIM_BITMAP; 372 mii.dwTypeData = (WCHAR*)str.c_str(); 373 mii.wID = idCmdFirst + entries; 374 mii.hbmpItem = uacicon; 375 376 if (!InsertMenuItemW(hmenu, indexMenu + entries, true, &mii)) 377 return E_FAIL; 378 379 entries++; 380 } 381 } else { 382 if (load_string(module, IDS_NEW_SUBVOL, str) == 0) 383 return E_FAIL; 384 385 if (!InsertMenuW(hmenu, indexMenu, MF_BYPOSITION, idCmdFirst, str.c_str())) 386 return E_FAIL; 387 388 entries = 1; 389 390 if (idCmdFirst + 1 <= idCmdLast) { 391 MENUITEMINFOW mii; 392 393 if (load_string(module, IDS_RECV_SUBVOL, str) == 0) 394 return E_FAIL; 395 396 if (!uacicon) 397 get_uac_icon(); 398 399 memset(&mii, 0, sizeof(MENUITEMINFOW)); 400 mii.cbSize = sizeof(MENUITEMINFOW); 401 mii.fMask = MIIM_STRING | MIIM_ID | MIIM_BITMAP; 402 mii.dwTypeData = (WCHAR*)str.c_str(); 403 mii.wID = idCmdFirst + 1; 404 mii.hbmpItem = uacicon; 405 406 if (!InsertMenuItemW(hmenu, indexMenu + 1, true, &mii)) 407 return E_FAIL; 408 409 entries++; 410 } 411 412 if (idCmdFirst + 2 <= idCmdLast && show_reflink_paste(path)) { 413 if (load_string(module, IDS_REFLINK_PASTE, str) == 0) 414 return E_FAIL; 415 416 if (!InsertMenuW(hmenu, indexMenu + 2, MF_BYPOSITION, idCmdFirst + 2, str.c_str())) 417 return E_FAIL; 418 419 entries++; 420 } 421 } 422 423 return MAKE_HRESULT(SEVERITY_SUCCESS, 0, entries); 424 } 425 426 static void path_remove_file(wstring& path) { 427 size_t bs = path.rfind(L"\\"); 428 429 if (bs == string::npos) 430 return; 431 432 if (bs == path.find(L"\\")) { // only one backslash 433 path = path.substr(0, bs + 1); 434 return; 435 } 436 437 path = path.substr(0, bs); 438 } 439 440 static void path_strip_path(wstring& path) { 441 size_t bs = path.rfind(L"\\"); 442 443 if (bs == string::npos) { 444 path = L""; 445 return; 446 } 447 448 path = path.substr(bs + 1); 449 } 450 451 static void create_snapshot(HWND hwnd, const wstring& fn) { 452 win_handle h; 453 NTSTATUS Status; 454 IO_STATUS_BLOCK iosb; 455 btrfs_get_file_ids bgfi; 456 457 h = CreateFileW(fn.c_str(), FILE_TRAVERSE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 458 459 if (h != INVALID_HANDLE_VALUE) { 460 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_FILE_IDS, nullptr, 0, &bgfi, sizeof(btrfs_get_file_ids)); 461 462 if (NT_SUCCESS(Status) && bgfi.inode == 0x100 && !bgfi.top) { 463 wstring subvolname, parpath, searchpath, temp1, name, nameorig; 464 win_handle h2; 465 WIN32_FIND_DATAW wfd; 466 SYSTEMTIME time; 467 468 parpath = fn; 469 path_remove_file(parpath); 470 471 subvolname = fn; 472 path_strip_path(subvolname); 473 474 h2 = CreateFileW(parpath.c_str(), FILE_ADD_SUBDIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 475 476 if (h2 == INVALID_HANDLE_VALUE) 477 throw last_error(GetLastError()); 478 479 if (!load_string(module, IDS_SNAPSHOT_FILENAME, temp1)) 480 throw last_error(GetLastError()); 481 482 GetLocalTime(&time); 483 484 wstring_sprintf(name, temp1, subvolname.c_str(), time.wYear, time.wMonth, time.wDay); 485 nameorig = name; 486 487 searchpath = parpath + L"\\" + name; 488 489 fff_handle fff = FindFirstFileW(searchpath.c_str(), &wfd); 490 491 if (fff != INVALID_HANDLE_VALUE) { 492 ULONG num = 2; 493 494 do { 495 #ifndef __REACTOS__ 496 name = nameorig + L" (" + to_wstring(num) + L")"; 497 #else 498 { 499 WCHAR buffer[32]; 500 501 swprintf(buffer, L"%d", num); 502 name = nameorig + L" (" + buffer + L")"; 503 } 504 #endif 505 searchpath = parpath + L"\\" + name; 506 507 fff = FindFirstFileW(searchpath.c_str(), &wfd); 508 num++; 509 } while (fff != INVALID_HANDLE_VALUE); 510 } 511 512 size_t namelen = name.length() * sizeof(WCHAR); 513 514 auto bcs = (btrfs_create_snapshot*)malloc(sizeof(btrfs_create_snapshot) - 1 + namelen); 515 bcs->readonly = false; 516 bcs->posix = false; 517 bcs->subvol = h; 518 bcs->namelen = (uint16_t)namelen; 519 memcpy(bcs->name, name.c_str(), namelen); 520 521 Status = NtFsControlFile(h2, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SNAPSHOT, bcs, 522 (ULONG)(sizeof(btrfs_create_snapshot) - 1 + namelen), nullptr, 0); 523 524 if (!NT_SUCCESS(Status)) 525 throw ntstatus_error(Status); 526 } 527 } else 528 throw last_error(GetLastError()); 529 } 530 531 static uint64_t __inline sector_align(uint64_t n, uint64_t a) { 532 if (n & (a - 1)) 533 n = (n + a) & ~(a - 1); 534 535 return n; 536 } 537 538 void BtrfsContextMenu::reflink_copy(HWND hwnd, const WCHAR* fn, const WCHAR* dir) { 539 win_handle source, dest; 540 WCHAR* name, volpath1[255], volpath2[255]; 541 wstring dirw, newpath; 542 FILE_BASIC_INFO fbi; 543 FILETIME atime, mtime; 544 btrfs_inode_info bii; 545 btrfs_set_inode_info bsii; 546 ULONG bytesret; 547 NTSTATUS Status; 548 IO_STATUS_BLOCK iosb; 549 btrfs_set_xattr bsxa; 550 551 // Thanks to 0xbadfca11, whose version of reflink for Windows provided a few pointers on what 552 // to do here - https://github.com/0xbadfca11/reflink 553 554 name = PathFindFileNameW(fn); 555 556 dirw = dir; 557 558 if (dir[0] != 0 && dir[wcslen(dir) - 1] != '\\') 559 dirw += L"\\"; 560 561 newpath = dirw; 562 newpath += name; 563 564 if (!get_volume_path_parent(fn, volpath1, sizeof(volpath1) / sizeof(WCHAR))) 565 throw last_error(GetLastError()); 566 567 if (!GetVolumePathNameW(dir, volpath2, sizeof(volpath2) / sizeof(WCHAR))) 568 throw last_error(GetLastError()); 569 570 if (wcscmp(volpath1, volpath2)) // different filesystems 571 throw string_error(IDS_CANT_REFLINK_DIFFERENT_FS); 572 573 source = CreateFileW(fn, GENERIC_READ | FILE_TRAVERSE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_OPEN_REPARSE_POINT, nullptr); 574 if (source == INVALID_HANDLE_VALUE) 575 throw last_error(GetLastError()); 576 577 Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info)); 578 if (!NT_SUCCESS(Status)) 579 throw ntstatus_error(Status); 580 581 // if subvol, do snapshot instead 582 if (bii.inode == SUBVOL_ROOT_INODE) { 583 btrfs_create_snapshot* bcs; 584 win_handle dirh; 585 wstring destname, search; 586 WIN32_FIND_DATAW wfd; 587 int num = 2; 588 589 dirh = CreateFileW(dir, FILE_ADD_SUBDIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 590 if (dirh == INVALID_HANDLE_VALUE) 591 throw last_error(GetLastError()); 592 593 search = dirw; 594 search += name; 595 destname = name; 596 597 fff_handle fff = FindFirstFileW(search.c_str(), &wfd); 598 599 if (fff != INVALID_HANDLE_VALUE) { 600 do { 601 wstringstream ss; 602 603 ss << name; 604 ss << L" ("; 605 ss << num; 606 ss << L")"; 607 destname = ss.str(); 608 609 search = dirw + destname; 610 611 fff = FindFirstFileW(search.c_str(), &wfd); 612 num++; 613 } while (fff != INVALID_HANDLE_VALUE); 614 } 615 616 bcs = (btrfs_create_snapshot*)malloc(sizeof(btrfs_create_snapshot) - sizeof(WCHAR) + (destname.length() * sizeof(WCHAR))); 617 bcs->subvol = source; 618 bcs->namelen = (uint16_t)(destname.length() * sizeof(WCHAR)); 619 memcpy(bcs->name, destname.c_str(), destname.length() * sizeof(WCHAR)); 620 621 Status = NtFsControlFile(dirh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SNAPSHOT, bcs, 622 (ULONG)(sizeof(btrfs_create_snapshot) - sizeof(WCHAR) + bcs->namelen), nullptr, 0); 623 624 free(bcs); 625 626 if (!NT_SUCCESS(Status)) 627 throw ntstatus_error(Status); 628 629 return; 630 } 631 632 Status = NtQueryInformationFile(source, &iosb, &fbi, sizeof(FILE_BASIC_INFO), FileBasicInformation); 633 if (!NT_SUCCESS(Status)) 634 throw ntstatus_error(Status); 635 636 if (bii.type == BTRFS_TYPE_CHARDEV || bii.type == BTRFS_TYPE_BLOCKDEV || bii.type == BTRFS_TYPE_FIFO || bii.type == BTRFS_TYPE_SOCKET) { 637 win_handle dirh; 638 btrfs_mknod* bmn; 639 640 dirh = CreateFileW(dir, FILE_ADD_FILE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 641 if (dirh == INVALID_HANDLE_VALUE) 642 throw last_error(GetLastError()); 643 644 size_t bmnsize = offsetof(btrfs_mknod, name[0]) + (wcslen(name) * sizeof(WCHAR)); 645 bmn = (btrfs_mknod*)malloc(bmnsize); 646 647 bmn->inode = 0; 648 bmn->type = bii.type; 649 bmn->st_rdev = bii.st_rdev; 650 bmn->namelen = (uint16_t)(wcslen(name) * sizeof(WCHAR)); 651 memcpy(bmn->name, name, bmn->namelen); 652 653 Status = NtFsControlFile(dirh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_MKNOD, bmn, (ULONG)bmnsize, nullptr, 0); 654 if (!NT_SUCCESS(Status)) { 655 free(bmn); 656 throw ntstatus_error(Status); 657 } 658 659 free(bmn); 660 661 dest = CreateFileW(newpath.c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, OPEN_EXISTING, 0, nullptr); 662 } else if (fbi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) { 663 if (CreateDirectoryExW(fn, newpath.c_str(), nullptr)) 664 dest = CreateFileW(newpath.c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 665 nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 666 else 667 dest = INVALID_HANDLE_VALUE; 668 } else 669 dest = CreateFileW(newpath.c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, CREATE_NEW, 0, source); 670 671 if (dest == INVALID_HANDLE_VALUE) { 672 int num = 2; 673 674 if (GetLastError() != ERROR_FILE_EXISTS && GetLastError() != ERROR_ALREADY_EXISTS && wcscmp(fn, newpath.c_str())) 675 throw last_error(GetLastError()); 676 677 do { 678 WCHAR* ext; 679 wstringstream ss; 680 681 ext = PathFindExtensionW(fn); 682 683 ss << dirw; 684 685 if (*ext == 0) { 686 ss << name; 687 ss << L" ("; 688 ss << num; 689 ss << L")"; 690 } else { 691 wstring namew = name; 692 693 ss << namew.substr(0, ext - name); 694 ss << L" ("; 695 ss << num; 696 ss << L")"; 697 ss << ext; 698 } 699 700 newpath = ss.str(); 701 if (fbi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) { 702 if (CreateDirectoryExW(fn, newpath.c_str(), nullptr)) 703 dest = CreateFileW(newpath.c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 704 else 705 dest = INVALID_HANDLE_VALUE; 706 } else 707 dest = CreateFileW(newpath.c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, CREATE_NEW, 0, source); 708 709 if (dest == INVALID_HANDLE_VALUE) { 710 if (GetLastError() != ERROR_FILE_EXISTS && GetLastError() != ERROR_ALREADY_EXISTS) 711 throw last_error(GetLastError()); 712 713 num++; 714 } else 715 break; 716 } while (true); 717 } 718 719 try { 720 memset(&bsii, 0, sizeof(btrfs_set_inode_info)); 721 722 bsii.flags_changed = true; 723 bsii.flags = bii.flags; 724 725 if (bii.flags & BTRFS_INODE_COMPRESS) { 726 bsii.compression_type_changed = true; 727 bsii.compression_type = bii.compression_type; 728 } 729 730 Status = NtFsControlFile(dest, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_INODE_INFO, &bsii, sizeof(btrfs_set_inode_info), nullptr, 0); 731 if (!NT_SUCCESS(Status)) 732 throw ntstatus_error(Status); 733 734 if (fbi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) { 735 if (!(fbi.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) { 736 fff_handle h; 737 WIN32_FIND_DATAW fff; 738 wstring qs; 739 740 qs = fn; 741 qs += L"\\*"; 742 743 h = FindFirstFileW(qs.c_str(), &fff); 744 if (h != INVALID_HANDLE_VALUE) { 745 do { 746 wstring fn2; 747 748 if (fff.cFileName[0] == '.' && (fff.cFileName[1] == 0 || (fff.cFileName[1] == '.' && fff.cFileName[2] == 0))) 749 continue; 750 751 fn2 = fn; 752 fn2 += L"\\"; 753 fn2 += fff.cFileName; 754 755 reflink_copy(hwnd, fn2.c_str(), newpath.c_str()); 756 } while (FindNextFileW(h, &fff)); 757 } 758 } 759 760 // CreateDirectoryExW also copies streams, no need to do it here 761 } else { 762 if (fbi.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { 763 reparse_header rh; 764 uint8_t* rp; 765 766 if (!DeviceIoControl(source, FSCTL_GET_REPARSE_POINT, nullptr, 0, &rh, sizeof(reparse_header), &bytesret, nullptr)) { 767 if (GetLastError() != ERROR_MORE_DATA) 768 throw last_error(GetLastError()); 769 } 770 771 size_t rplen = sizeof(reparse_header) + rh.ReparseDataLength; 772 rp = (uint8_t*)malloc(rplen); 773 774 if (!DeviceIoControl(source, FSCTL_GET_REPARSE_POINT, nullptr, 0, rp, (ULONG)rplen, &bytesret, nullptr)) 775 throw last_error(GetLastError()); 776 777 if (!DeviceIoControl(dest, FSCTL_SET_REPARSE_POINT, rp, (ULONG)rplen, nullptr, 0, &bytesret, nullptr)) 778 throw last_error(GetLastError()); 779 780 free(rp); 781 } else { 782 FILE_STANDARD_INFO fsi; 783 FILE_END_OF_FILE_INFO feofi; 784 FSCTL_GET_INTEGRITY_INFORMATION_BUFFER fgiib; 785 FSCTL_SET_INTEGRITY_INFORMATION_BUFFER fsiib; 786 DUPLICATE_EXTENTS_DATA ded; 787 uint64_t offset, alloc_size; 788 ULONG maxdup; 789 790 Status = NtQueryInformationFile(source, &iosb, &fsi, sizeof(FILE_STANDARD_INFO), FileStandardInformation); 791 if (!NT_SUCCESS(Status)) 792 throw ntstatus_error(Status); 793 794 if (!DeviceIoControl(source, FSCTL_GET_INTEGRITY_INFORMATION, nullptr, 0, &fgiib, sizeof(FSCTL_GET_INTEGRITY_INFORMATION_BUFFER), &bytesret, nullptr)) 795 throw last_error(GetLastError()); 796 797 if (fbi.FileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) { 798 if (!DeviceIoControl(dest, FSCTL_SET_SPARSE, nullptr, 0, nullptr, 0, &bytesret, nullptr)) 799 throw last_error(GetLastError()); 800 } 801 802 fsiib.ChecksumAlgorithm = fgiib.ChecksumAlgorithm; 803 fsiib.Reserved = 0; 804 fsiib.Flags = fgiib.Flags; 805 if (!DeviceIoControl(dest, FSCTL_SET_INTEGRITY_INFORMATION, &fsiib, sizeof(FSCTL_SET_INTEGRITY_INFORMATION_BUFFER), nullptr, 0, &bytesret, nullptr)) 806 throw last_error(GetLastError()); 807 808 feofi.EndOfFile = fsi.EndOfFile; 809 Status = NtSetInformationFile(dest, &iosb, &feofi, sizeof(FILE_END_OF_FILE_INFO), FileEndOfFileInformation); 810 if (!NT_SUCCESS(Status)) 811 throw ntstatus_error(Status); 812 813 ded.FileHandle = source; 814 maxdup = 0xffffffff - fgiib.ClusterSizeInBytes + 1; 815 816 alloc_size = sector_align(fsi.EndOfFile.QuadPart, fgiib.ClusterSizeInBytes); 817 818 offset = 0; 819 while (offset < alloc_size) { 820 ded.SourceFileOffset.QuadPart = ded.TargetFileOffset.QuadPart = offset; 821 ded.ByteCount.QuadPart = maxdup < (alloc_size - offset) ? maxdup : (alloc_size - offset); 822 if (!DeviceIoControl(dest, FSCTL_DUPLICATE_EXTENTS_TO_FILE, &ded, sizeof(DUPLICATE_EXTENTS_DATA), nullptr, 0, &bytesret, nullptr)) 823 throw last_error(GetLastError()); 824 825 offset += ded.ByteCount.QuadPart; 826 } 827 } 828 829 ULONG streambufsize = 0; 830 vector<char> streambuf; 831 832 do { 833 streambufsize += 0x1000; 834 streambuf.resize(streambufsize); 835 836 memset(streambuf.data(), 0, streambufsize); 837 838 Status = NtQueryInformationFile(source, &iosb, streambuf.data(), streambufsize, FileStreamInformation); 839 } while (Status == STATUS_BUFFER_OVERFLOW); 840 841 if (!NT_SUCCESS(Status)) 842 throw ntstatus_error(Status); 843 844 auto fsi = reinterpret_cast<FILE_STREAM_INFORMATION*>(streambuf.data()); 845 846 while (true) { 847 if (fsi->StreamNameLength > 0) { 848 wstring sn = wstring(fsi->StreamName, fsi->StreamNameLength / sizeof(WCHAR)); 849 850 if (sn != L"::$DATA" && sn.length() > 6 && sn.substr(sn.length() - 6, 6) == L":$DATA") { 851 win_handle stream; 852 uint8_t* data = nullptr; 853 auto stream_size = (uint16_t)fsi->StreamSize.QuadPart; 854 855 856 if (stream_size > 0) { 857 wstring fn2; 858 859 fn2 = fn; 860 fn2 += sn; 861 862 stream = CreateFileW(fn2.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr); 863 864 if (stream == INVALID_HANDLE_VALUE) 865 throw last_error(GetLastError()); 866 867 // We can get away with this because our streams are guaranteed to be below 64 KB - 868 // don't do this on NTFS! 869 data = (uint8_t*)malloc(stream_size); 870 871 if (!ReadFile(stream, data, stream_size, &bytesret, nullptr)) { 872 free(data); 873 throw last_error(GetLastError()); 874 } 875 } 876 877 stream = CreateFileW((newpath + sn).c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, CREATE_NEW, 0, nullptr); 878 879 if (stream == INVALID_HANDLE_VALUE) { 880 if (data) free(data); 881 throw last_error(GetLastError()); 882 } 883 884 if (data) { 885 if (!WriteFile(stream, data, stream_size, &bytesret, nullptr)) { 886 free(data); 887 throw last_error(GetLastError()); 888 } 889 890 free(data); 891 } 892 } 893 } 894 895 if (fsi->NextEntryOffset == 0) 896 break; 897 898 fsi = reinterpret_cast<FILE_STREAM_INFORMATION*>(reinterpret_cast<char*>(fsi) + fsi->NextEntryOffset); 899 } 900 } 901 902 atime.dwLowDateTime = fbi.LastAccessTime.LowPart; 903 atime.dwHighDateTime = fbi.LastAccessTime.HighPart; 904 mtime.dwLowDateTime = fbi.LastWriteTime.LowPart; 905 mtime.dwHighDateTime = fbi.LastWriteTime.HighPart; 906 SetFileTime(dest, nullptr, &atime, &mtime); 907 908 Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_XATTRS, nullptr, 0, &bsxa, sizeof(btrfs_set_xattr)); 909 910 if (Status == STATUS_BUFFER_OVERFLOW || (NT_SUCCESS(Status) && bsxa.valuelen > 0)) { 911 ULONG xalen = 0; 912 btrfs_set_xattr *xa = nullptr, *xa2; 913 914 do { 915 xalen += 1024; 916 917 if (xa) free(xa); 918 xa = (btrfs_set_xattr*)malloc(xalen); 919 920 Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_XATTRS, nullptr, 0, xa, xalen); 921 } while (Status == STATUS_BUFFER_OVERFLOW); 922 923 if (!NT_SUCCESS(Status)) { 924 free(xa); 925 throw ntstatus_error(Status); 926 } 927 928 xa2 = xa; 929 while (xa2->valuelen > 0) { 930 Status = NtFsControlFile(dest, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_XATTR, xa2, 931 (ULONG)(offsetof(btrfs_set_xattr, data[0]) + xa2->namelen + xa2->valuelen), nullptr, 0); 932 if (!NT_SUCCESS(Status)) { 933 free(xa); 934 throw ntstatus_error(Status); 935 } 936 xa2 = (btrfs_set_xattr*)&xa2->data[xa2->namelen + xa2->valuelen]; 937 } 938 939 free(xa); 940 } else if (!NT_SUCCESS(Status)) 941 throw ntstatus_error(Status); 942 } catch (...) { 943 FILE_DISPOSITION_INFO fdi; 944 945 fdi.DeleteFile = true; 946 Status = NtSetInformationFile(dest, &iosb, &fdi, sizeof(FILE_DISPOSITION_INFO), FileDispositionInformation); 947 if (!NT_SUCCESS(Status)) 948 throw ntstatus_error(Status); 949 950 throw; 951 } 952 } 953 954 HRESULT __stdcall BtrfsContextMenu::InvokeCommand(LPCMINVOKECOMMANDINFO picia) { 955 LPCMINVOKECOMMANDINFOEX pici = (LPCMINVOKECOMMANDINFOEX)picia; 956 957 try { 958 if (ignore) 959 return E_INVALIDARG; 960 961 if (!bg) { 962 if ((IS_INTRESOURCE(pici->lpVerb) && allow_snapshot && pici->lpVerb == 0) || (!IS_INTRESOURCE(pici->lpVerb) && !strcmp(pici->lpVerb, SNAPSHOT_VERBA))) { 963 UINT num_files, i; 964 WCHAR fn[MAX_PATH]; 965 966 if (!stgm_set) 967 return E_FAIL; 968 969 num_files = DragQueryFileW((HDROP)stgm.hGlobal, 0xFFFFFFFF, nullptr, 0); 970 971 if (num_files == 0) 972 return E_FAIL; 973 974 for (i = 0; i < num_files; i++) { 975 if (DragQueryFileW((HDROP)stgm.hGlobal, i, fn, sizeof(fn) / sizeof(WCHAR))) { 976 create_snapshot(pici->hwnd, fn); 977 } 978 } 979 980 return S_OK; 981 } else if ((IS_INTRESOURCE(pici->lpVerb) && ((allow_snapshot && (ULONG_PTR)pici->lpVerb == 1) || (!allow_snapshot && (ULONG_PTR)pici->lpVerb == 0))) || 982 (!IS_INTRESOURCE(pici->lpVerb) && !strcmp(pici->lpVerb, SEND_VERBA))) { 983 UINT num_files, i; 984 WCHAR dll[MAX_PATH], fn[MAX_PATH]; 985 wstring t; 986 SHELLEXECUTEINFOW sei; 987 988 GetModuleFileNameW(module, dll, sizeof(dll) / sizeof(WCHAR)); 989 990 if (!stgm_set) 991 return E_FAIL; 992 993 num_files = DragQueryFileW((HDROP)stgm.hGlobal, 0xFFFFFFFF, nullptr, 0); 994 995 if (num_files == 0) 996 return E_FAIL; 997 998 for (i = 0; i < num_files; i++) { 999 if (DragQueryFileW((HDROP)stgm.hGlobal, i, fn, sizeof(fn) / sizeof(WCHAR))) { 1000 t = L"\""; 1001 t += dll; 1002 t += L"\",SendSubvolGUI "; 1003 t += fn; 1004 1005 RtlZeroMemory(&sei, sizeof(sei)); 1006 1007 sei.cbSize = sizeof(sei); 1008 sei.hwnd = pici->hwnd; 1009 sei.lpVerb = L"runas"; 1010 sei.lpFile = L"rundll32.exe"; 1011 sei.lpParameters = t.c_str(); 1012 sei.nShow = SW_SHOW; 1013 sei.fMask = SEE_MASK_NOCLOSEPROCESS; 1014 1015 if (!ShellExecuteExW(&sei)) 1016 throw last_error(GetLastError()); 1017 1018 WaitForSingleObject(sei.hProcess, INFINITE); 1019 CloseHandle(sei.hProcess); 1020 } 1021 } 1022 1023 return S_OK; 1024 } 1025 } else { 1026 if ((IS_INTRESOURCE(pici->lpVerb) && (ULONG_PTR)pici->lpVerb == 0) || (!IS_INTRESOURCE(pici->lpVerb) && !strcmp(pici->lpVerb, NEW_SUBVOL_VERBA))) { 1027 win_handle h; 1028 IO_STATUS_BLOCK iosb; 1029 NTSTATUS Status; 1030 wstring name, nameorig, searchpath; 1031 btrfs_create_subvol* bcs; 1032 WIN32_FIND_DATAW wfd; 1033 1034 if (!load_string(module, IDS_NEW_SUBVOL_FILENAME, name)) 1035 throw last_error(GetLastError()); 1036 1037 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); 1038 1039 if (h == INVALID_HANDLE_VALUE) 1040 throw last_error(GetLastError()); 1041 1042 searchpath = path + L"\\" + name; 1043 nameorig = name; 1044 1045 { 1046 fff_handle fff = FindFirstFileW(searchpath.c_str(), &wfd); 1047 1048 if (fff != INVALID_HANDLE_VALUE) { 1049 ULONG num = 2; 1050 1051 do { 1052 #ifndef __REACTOS__ 1053 name = nameorig + L" (" + to_wstring(num) + L")"; 1054 #else 1055 { 1056 WCHAR buffer[32]; 1057 1058 swprintf(buffer, L"%d", num); 1059 name = nameorig + L" (" + buffer + L")"; 1060 } 1061 #endif 1062 searchpath = path + L"\\" + name; 1063 1064 fff = FindFirstFileW(searchpath.c_str(), &wfd); 1065 num++; 1066 } while (fff != INVALID_HANDLE_VALUE); 1067 } 1068 } 1069 1070 size_t bcslen = offsetof(btrfs_create_subvol, name[0]) + (name.length() * sizeof(WCHAR)); 1071 bcs = (btrfs_create_subvol*)malloc(bcslen); 1072 1073 bcs->readonly = false; 1074 bcs->posix = false; 1075 bcs->namelen = (uint16_t)(name.length() * sizeof(WCHAR)); 1076 memcpy(bcs->name, name.c_str(), name.length() * sizeof(WCHAR)); 1077 1078 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SUBVOL, bcs, (ULONG)bcslen, nullptr, 0); 1079 1080 free(bcs); 1081 1082 if (!NT_SUCCESS(Status)) 1083 throw ntstatus_error(Status); 1084 1085 return S_OK; 1086 } else if ((IS_INTRESOURCE(pici->lpVerb) && (ULONG_PTR)pici->lpVerb == 1) || (!IS_INTRESOURCE(pici->lpVerb) && !strcmp(pici->lpVerb, RECV_VERBA))) { 1087 WCHAR dll[MAX_PATH]; 1088 wstring t; 1089 SHELLEXECUTEINFOW sei; 1090 1091 GetModuleFileNameW(module, dll, sizeof(dll) / sizeof(WCHAR)); 1092 1093 t = L"\""; 1094 t += dll; 1095 t += L"\",RecvSubvolGUI "; 1096 t += path; 1097 1098 RtlZeroMemory(&sei, sizeof(sei)); 1099 1100 sei.cbSize = sizeof(sei); 1101 sei.hwnd = pici->hwnd; 1102 sei.lpVerb = L"runas"; 1103 sei.lpFile = L"rundll32.exe"; 1104 sei.lpParameters = t.c_str(); 1105 sei.nShow = SW_SHOW; 1106 sei.fMask = SEE_MASK_NOCLOSEPROCESS; 1107 1108 if (!ShellExecuteExW(&sei)) 1109 throw last_error(GetLastError()); 1110 1111 WaitForSingleObject(sei.hProcess, INFINITE); 1112 CloseHandle(sei.hProcess); 1113 1114 return S_OK; 1115 } else if ((IS_INTRESOURCE(pici->lpVerb) && (ULONG_PTR)pici->lpVerb == 2) || (!IS_INTRESOURCE(pici->lpVerb) && !strcmp(pici->lpVerb, REFLINK_VERBA))) { 1116 HDROP hdrop; 1117 1118 if (!IsClipboardFormatAvailable(CF_HDROP)) 1119 return S_OK; 1120 1121 if (!OpenClipboard(pici->hwnd)) 1122 throw last_error(GetLastError()); 1123 1124 try { 1125 hdrop = (HDROP)GetClipboardData(CF_HDROP); 1126 1127 if (hdrop) { 1128 HANDLE lh; 1129 1130 lh = GlobalLock(hdrop); 1131 1132 if (lh) { 1133 try { 1134 ULONG num_files, i; 1135 WCHAR fn[MAX_PATH]; 1136 1137 num_files = DragQueryFileW(hdrop, 0xFFFFFFFF, nullptr, 0); 1138 1139 for (i = 0; i < num_files; i++) { 1140 if (DragQueryFileW(hdrop, i, fn, sizeof(fn) / sizeof(WCHAR))) { 1141 reflink_copy(pici->hwnd, fn, pici->lpDirectoryW); 1142 } 1143 } 1144 } catch (...) { 1145 GlobalUnlock(lh); 1146 throw; 1147 } 1148 1149 GlobalUnlock(lh); 1150 } 1151 } 1152 } catch (...) { 1153 CloseClipboard(); 1154 throw; 1155 } 1156 1157 CloseClipboard(); 1158 1159 return S_OK; 1160 } 1161 } 1162 } catch (const exception& e) { 1163 error_message(pici->hwnd, e.what()); 1164 } 1165 1166 return E_FAIL; 1167 } 1168 1169 HRESULT __stdcall BtrfsContextMenu::GetCommandString(UINT_PTR idCmd, UINT uFlags, UINT* pwReserved, LPSTR pszName, UINT cchMax) { 1170 if (ignore) 1171 return E_INVALIDARG; 1172 1173 if (idCmd != 0) 1174 return E_INVALIDARG; 1175 1176 if (!bg) { 1177 if (idCmd == 0) { 1178 switch (uFlags) { 1179 case GCS_HELPTEXTA: 1180 if (LoadStringA(module, IDS_CREATE_SNAPSHOT_HELP_TEXT, pszName, cchMax)) 1181 return S_OK; 1182 else 1183 return E_FAIL; 1184 1185 case GCS_HELPTEXTW: 1186 if (LoadStringW(module, IDS_CREATE_SNAPSHOT_HELP_TEXT, (LPWSTR)pszName, cchMax)) 1187 return S_OK; 1188 else 1189 return E_FAIL; 1190 1191 case GCS_VALIDATEA: 1192 case GCS_VALIDATEW: 1193 return S_OK; 1194 1195 case GCS_VERBA: 1196 return StringCchCopyA(pszName, cchMax, SNAPSHOT_VERBA); 1197 1198 case GCS_VERBW: 1199 return StringCchCopyW((STRSAFE_LPWSTR)pszName, cchMax, SNAPSHOT_VERBW); 1200 1201 default: 1202 return E_INVALIDARG; 1203 } 1204 } else if (idCmd == 1) { 1205 switch (uFlags) { 1206 case GCS_HELPTEXTA: 1207 if (LoadStringA(module, IDS_SEND_SUBVOL_HELP, pszName, cchMax)) 1208 return S_OK; 1209 else 1210 return E_FAIL; 1211 1212 case GCS_HELPTEXTW: 1213 if (LoadStringW(module, IDS_SEND_SUBVOL_HELP, (LPWSTR)pszName, cchMax)) 1214 return S_OK; 1215 else 1216 return E_FAIL; 1217 1218 case GCS_VALIDATEA: 1219 case GCS_VALIDATEW: 1220 return S_OK; 1221 1222 case GCS_VERBA: 1223 return StringCchCopyA(pszName, cchMax, SEND_VERBA); 1224 1225 case GCS_VERBW: 1226 return StringCchCopyW((STRSAFE_LPWSTR)pszName, cchMax, SEND_VERBW); 1227 1228 default: 1229 return E_INVALIDARG; 1230 } 1231 } else 1232 return E_INVALIDARG; 1233 } else { 1234 if (idCmd == 0) { 1235 switch (uFlags) { 1236 case GCS_HELPTEXTA: 1237 if (LoadStringA(module, IDS_NEW_SUBVOL_HELP_TEXT, pszName, cchMax)) 1238 return S_OK; 1239 else 1240 return E_FAIL; 1241 1242 case GCS_HELPTEXTW: 1243 if (LoadStringW(module, IDS_NEW_SUBVOL_HELP_TEXT, (LPWSTR)pszName, cchMax)) 1244 return S_OK; 1245 else 1246 return E_FAIL; 1247 1248 case GCS_VALIDATEA: 1249 case GCS_VALIDATEW: 1250 return S_OK; 1251 1252 case GCS_VERBA: 1253 return StringCchCopyA(pszName, cchMax, NEW_SUBVOL_VERBA); 1254 1255 case GCS_VERBW: 1256 return StringCchCopyW((STRSAFE_LPWSTR)pszName, cchMax, NEW_SUBVOL_VERBW); 1257 1258 default: 1259 return E_INVALIDARG; 1260 } 1261 } else if (idCmd == 1) { 1262 switch (uFlags) { 1263 case GCS_HELPTEXTA: 1264 if (LoadStringA(module, IDS_RECV_SUBVOL_HELP, pszName, cchMax)) 1265 return S_OK; 1266 else 1267 return E_FAIL; 1268 1269 case GCS_HELPTEXTW: 1270 if (LoadStringW(module, IDS_RECV_SUBVOL_HELP, (LPWSTR)pszName, cchMax)) 1271 return S_OK; 1272 else 1273 return E_FAIL; 1274 1275 case GCS_VALIDATEA: 1276 case GCS_VALIDATEW: 1277 return S_OK; 1278 1279 case GCS_VERBA: 1280 return StringCchCopyA(pszName, cchMax, RECV_VERBA); 1281 1282 case GCS_VERBW: 1283 return StringCchCopyW((STRSAFE_LPWSTR)pszName, cchMax, RECV_VERBW); 1284 1285 default: 1286 return E_INVALIDARG; 1287 } 1288 } else if (idCmd == 2) { 1289 switch (uFlags) { 1290 case GCS_HELPTEXTA: 1291 if (LoadStringA(module, IDS_REFLINK_PASTE_HELP, pszName, cchMax)) 1292 return S_OK; 1293 else 1294 return E_FAIL; 1295 1296 case GCS_HELPTEXTW: 1297 if (LoadStringW(module, IDS_REFLINK_PASTE_HELP, (LPWSTR)pszName, cchMax)) 1298 return S_OK; 1299 else 1300 return E_FAIL; 1301 1302 case GCS_VALIDATEA: 1303 case GCS_VALIDATEW: 1304 return S_OK; 1305 1306 case GCS_VERBA: 1307 return StringCchCopyA(pszName, cchMax, REFLINK_VERBA); 1308 1309 case GCS_VERBW: 1310 return StringCchCopyW((STRSAFE_LPWSTR)pszName, cchMax, REFLINK_VERBW); 1311 1312 default: 1313 return E_INVALIDARG; 1314 } 1315 } else 1316 return E_INVALIDARG; 1317 } 1318 } 1319 1320 static void reflink_copy2(const wstring& srcfn, const wstring& destdir, const wstring& destname) { 1321 win_handle source, dest; 1322 FILE_BASIC_INFO fbi; 1323 FILETIME atime, mtime; 1324 btrfs_inode_info bii; 1325 btrfs_set_inode_info bsii; 1326 ULONG bytesret; 1327 NTSTATUS Status; 1328 IO_STATUS_BLOCK iosb; 1329 btrfs_set_xattr bsxa; 1330 1331 source = CreateFileW(srcfn.c_str(), GENERIC_READ | FILE_TRAVERSE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_OPEN_REPARSE_POINT, nullptr); 1332 if (source == INVALID_HANDLE_VALUE) 1333 throw last_error(GetLastError()); 1334 1335 Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info)); 1336 if (!NT_SUCCESS(Status)) 1337 throw ntstatus_error(Status); 1338 1339 // if subvol, do snapshot instead 1340 if (bii.inode == SUBVOL_ROOT_INODE) { 1341 btrfs_create_snapshot* bcs; 1342 win_handle dirh; 1343 1344 dirh = CreateFileW(destdir.c_str(), FILE_ADD_SUBDIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 1345 if (dirh == INVALID_HANDLE_VALUE) 1346 throw last_error(GetLastError()); 1347 1348 size_t bcslen = offsetof(btrfs_create_snapshot, name[0]) + (destname.length() * sizeof(WCHAR)); 1349 bcs = (btrfs_create_snapshot*)malloc(bcslen); 1350 bcs->subvol = source; 1351 bcs->namelen = (uint16_t)(destname.length() * sizeof(WCHAR)); 1352 memcpy(bcs->name, destname.c_str(), destname.length() * sizeof(WCHAR)); 1353 1354 Status = NtFsControlFile(dirh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SNAPSHOT, bcs, (ULONG)bcslen, nullptr, 0); 1355 if (!NT_SUCCESS(Status)) { 1356 free(bcs); 1357 throw ntstatus_error(Status); 1358 } 1359 1360 free(bcs); 1361 1362 return; 1363 } 1364 1365 Status = NtQueryInformationFile(source, &iosb, &fbi, sizeof(FILE_BASIC_INFO), FileBasicInformation); 1366 if (!NT_SUCCESS(Status)) 1367 throw ntstatus_error(Status); 1368 1369 if (bii.type == BTRFS_TYPE_CHARDEV || bii.type == BTRFS_TYPE_BLOCKDEV || bii.type == BTRFS_TYPE_FIFO || bii.type == BTRFS_TYPE_SOCKET) { 1370 win_handle dirh; 1371 btrfs_mknod* bmn; 1372 1373 dirh = CreateFileW(destdir.c_str(), FILE_ADD_FILE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 1374 if (dirh == INVALID_HANDLE_VALUE) 1375 throw last_error(GetLastError()); 1376 1377 size_t bmnsize = offsetof(btrfs_mknod, name[0]) + (destname.length() * sizeof(WCHAR)); 1378 bmn = (btrfs_mknod*)malloc(bmnsize); 1379 1380 bmn->inode = 0; 1381 bmn->type = bii.type; 1382 bmn->st_rdev = bii.st_rdev; 1383 bmn->namelen = (uint16_t)(destname.length() * sizeof(WCHAR)); 1384 memcpy(bmn->name, destname.c_str(), bmn->namelen); 1385 1386 Status = NtFsControlFile(dirh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_MKNOD, bmn, (ULONG)bmnsize, nullptr, 0); 1387 if (!NT_SUCCESS(Status)) { 1388 free(bmn); 1389 throw ntstatus_error(Status); 1390 } 1391 1392 free(bmn); 1393 1394 dest = CreateFileW((destdir + destname).c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, OPEN_EXISTING, 0, nullptr); 1395 } else if (fbi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) { 1396 if (CreateDirectoryExW(srcfn.c_str(), (destdir + destname).c_str(), nullptr)) 1397 dest = CreateFileW((destdir + destname).c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 1398 nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 1399 else 1400 dest = INVALID_HANDLE_VALUE; 1401 } else 1402 dest = CreateFileW((destdir + destname).c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, CREATE_NEW, 0, source); 1403 1404 if (dest == INVALID_HANDLE_VALUE) 1405 throw last_error(GetLastError()); 1406 1407 memset(&bsii, 0, sizeof(btrfs_set_inode_info)); 1408 1409 bsii.flags_changed = true; 1410 bsii.flags = bii.flags; 1411 1412 if (bii.flags & BTRFS_INODE_COMPRESS) { 1413 bsii.compression_type_changed = true; 1414 bsii.compression_type = bii.compression_type; 1415 } 1416 1417 try { 1418 Status = NtFsControlFile(dest, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_INODE_INFO, &bsii, sizeof(btrfs_set_inode_info), nullptr, 0); 1419 if (!NT_SUCCESS(Status)) 1420 throw ntstatus_error(Status); 1421 1422 if (fbi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) { 1423 if (!(fbi.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) { 1424 WIN32_FIND_DATAW fff; 1425 wstring qs; 1426 1427 qs = srcfn; 1428 qs += L"\\*"; 1429 1430 fff_handle h = FindFirstFileW(qs.c_str(), &fff); 1431 if (h != INVALID_HANDLE_VALUE) { 1432 do { 1433 wstring fn2; 1434 1435 if (fff.cFileName[0] == '.' && (fff.cFileName[1] == 0 || (fff.cFileName[1] == '.' && fff.cFileName[2] == 0))) 1436 continue; 1437 1438 fn2 = srcfn; 1439 fn2 += L"\\"; 1440 fn2 += fff.cFileName; 1441 1442 reflink_copy2(fn2, destdir + destname + L"\\", fff.cFileName); 1443 } while (FindNextFileW(h, &fff)); 1444 } 1445 } 1446 1447 // CreateDirectoryExW also copies streams, no need to do it here 1448 } else { 1449 if (fbi.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { 1450 reparse_header rh; 1451 uint8_t* rp; 1452 1453 if (!DeviceIoControl(source, FSCTL_GET_REPARSE_POINT, nullptr, 0, &rh, sizeof(reparse_header), &bytesret, nullptr)) { 1454 if (GetLastError() != ERROR_MORE_DATA) 1455 throw last_error(GetLastError()); 1456 } 1457 1458 size_t rplen = sizeof(reparse_header) + rh.ReparseDataLength; 1459 rp = (uint8_t*)malloc(rplen); 1460 1461 try { 1462 if (!DeviceIoControl(source, FSCTL_GET_REPARSE_POINT, nullptr, 0, rp, (DWORD)rplen, &bytesret, nullptr)) 1463 throw last_error(GetLastError()); 1464 1465 if (!DeviceIoControl(dest, FSCTL_SET_REPARSE_POINT, rp, (DWORD)rplen, nullptr, 0, &bytesret, nullptr)) 1466 throw last_error(GetLastError()); 1467 } catch (...) { 1468 free(rp); 1469 throw; 1470 } 1471 1472 free(rp); 1473 } else { 1474 FILE_STANDARD_INFO fsi; 1475 FILE_END_OF_FILE_INFO feofi; 1476 FSCTL_GET_INTEGRITY_INFORMATION_BUFFER fgiib; 1477 FSCTL_SET_INTEGRITY_INFORMATION_BUFFER fsiib; 1478 DUPLICATE_EXTENTS_DATA ded; 1479 uint64_t offset, alloc_size; 1480 ULONG maxdup; 1481 1482 Status = NtQueryInformationFile(source, &iosb, &fsi, sizeof(FILE_STANDARD_INFO), FileStandardInformation); 1483 if (!NT_SUCCESS(Status)) 1484 throw ntstatus_error(Status); 1485 1486 if (!DeviceIoControl(source, FSCTL_GET_INTEGRITY_INFORMATION, nullptr, 0, &fgiib, sizeof(FSCTL_GET_INTEGRITY_INFORMATION_BUFFER), &bytesret, nullptr)) 1487 throw last_error(GetLastError()); 1488 1489 if (fbi.FileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) { 1490 if (!DeviceIoControl(dest, FSCTL_SET_SPARSE, nullptr, 0, nullptr, 0, &bytesret, nullptr)) 1491 throw last_error(GetLastError()); 1492 } 1493 1494 fsiib.ChecksumAlgorithm = fgiib.ChecksumAlgorithm; 1495 fsiib.Reserved = 0; 1496 fsiib.Flags = fgiib.Flags; 1497 if (!DeviceIoControl(dest, FSCTL_SET_INTEGRITY_INFORMATION, &fsiib, sizeof(FSCTL_SET_INTEGRITY_INFORMATION_BUFFER), nullptr, 0, &bytesret, nullptr)) 1498 throw last_error(GetLastError()); 1499 1500 feofi.EndOfFile = fsi.EndOfFile; 1501 Status = NtSetInformationFile(dest, &iosb, &feofi, sizeof(FILE_END_OF_FILE_INFO), FileEndOfFileInformation); 1502 if (!NT_SUCCESS(Status)) 1503 throw ntstatus_error(Status); 1504 1505 ded.FileHandle = source; 1506 maxdup = 0xffffffff - fgiib.ClusterSizeInBytes + 1; 1507 1508 alloc_size = sector_align(fsi.EndOfFile.QuadPart, fgiib.ClusterSizeInBytes); 1509 1510 offset = 0; 1511 while (offset < alloc_size) { 1512 ded.SourceFileOffset.QuadPart = ded.TargetFileOffset.QuadPart = offset; 1513 ded.ByteCount.QuadPart = maxdup < (alloc_size - offset) ? maxdup : (alloc_size - offset); 1514 if (!DeviceIoControl(dest, FSCTL_DUPLICATE_EXTENTS_TO_FILE, &ded, sizeof(DUPLICATE_EXTENTS_DATA), nullptr, 0, &bytesret, nullptr)) 1515 throw last_error(GetLastError()); 1516 1517 offset += ded.ByteCount.QuadPart; 1518 } 1519 } 1520 1521 ULONG streambufsize = 0; 1522 vector<char> streambuf; 1523 1524 do { 1525 streambufsize += 0x1000; 1526 streambuf.resize(streambufsize); 1527 1528 memset(streambuf.data(), 0, streambufsize); 1529 1530 Status = NtQueryInformationFile(source, &iosb, streambuf.data(), streambufsize, FileStreamInformation); 1531 } while (Status == STATUS_BUFFER_OVERFLOW); 1532 1533 if (!NT_SUCCESS(Status)) 1534 throw ntstatus_error(Status); 1535 1536 auto fsi = reinterpret_cast<FILE_STREAM_INFORMATION*>(streambuf.data()); 1537 1538 while (true) { 1539 if (fsi->StreamNameLength > 0) { 1540 wstring sn = wstring(fsi->StreamName, fsi->StreamNameLength / sizeof(WCHAR)); 1541 1542 if (sn != L"::$DATA" && sn.length() > 6 && sn.substr(sn.length() - 6, 6) == L":$DATA") { 1543 win_handle stream; 1544 uint8_t* data = nullptr; 1545 auto stream_size = (uint16_t)fsi->StreamSize.QuadPart; 1546 1547 if (stream_size > 0) { 1548 wstring fn2; 1549 1550 fn2 = srcfn; 1551 fn2 += sn; 1552 1553 stream = CreateFileW(fn2.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr); 1554 1555 if (stream == INVALID_HANDLE_VALUE) 1556 throw last_error(GetLastError()); 1557 1558 // We can get away with this because our streams are guaranteed to be below 64 KB - 1559 // don't do this on NTFS! 1560 data = (uint8_t*)malloc(stream_size); 1561 1562 if (!ReadFile(stream, data, stream_size, &bytesret, nullptr)) { 1563 free(data); 1564 throw last_error(GetLastError()); 1565 } 1566 } 1567 1568 stream = CreateFileW((destdir + destname + sn).c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, CREATE_NEW, 0, nullptr); 1569 1570 if (stream == INVALID_HANDLE_VALUE) { 1571 if (data) free(data); 1572 throw last_error(GetLastError()); 1573 } 1574 1575 if (data) { 1576 if (!WriteFile(stream, data, stream_size, &bytesret, nullptr)) { 1577 free(data); 1578 throw last_error(GetLastError()); 1579 } 1580 1581 free(data); 1582 } 1583 } 1584 1585 } 1586 1587 if (fsi->NextEntryOffset == 0) 1588 break; 1589 1590 fsi = reinterpret_cast<FILE_STREAM_INFORMATION*>(reinterpret_cast<char*>(fsi) + fsi->NextEntryOffset); 1591 } 1592 } 1593 1594 atime.dwLowDateTime = fbi.LastAccessTime.LowPart; 1595 atime.dwHighDateTime = fbi.LastAccessTime.HighPart; 1596 mtime.dwLowDateTime = fbi.LastWriteTime.LowPart; 1597 mtime.dwHighDateTime = fbi.LastWriteTime.HighPart; 1598 SetFileTime(dest, nullptr, &atime, &mtime); 1599 1600 Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_XATTRS, nullptr, 0, &bsxa, sizeof(btrfs_set_xattr)); 1601 1602 if (Status == STATUS_BUFFER_OVERFLOW || (NT_SUCCESS(Status) && bsxa.valuelen > 0)) { 1603 ULONG xalen = 0; 1604 btrfs_set_xattr *xa = nullptr, *xa2; 1605 1606 do { 1607 xalen += 1024; 1608 1609 if (xa) free(xa); 1610 xa = (btrfs_set_xattr*)malloc(xalen); 1611 1612 Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_XATTRS, nullptr, 0, xa, xalen); 1613 } while (Status == STATUS_BUFFER_OVERFLOW); 1614 1615 if (!NT_SUCCESS(Status)) { 1616 free(xa); 1617 throw ntstatus_error(Status); 1618 } 1619 1620 xa2 = xa; 1621 while (xa2->valuelen > 0) { 1622 Status = NtFsControlFile(dest, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_XATTR, xa2, 1623 (ULONG)(offsetof(btrfs_set_xattr, data[0]) + xa2->namelen + xa2->valuelen), nullptr, 0); 1624 if (!NT_SUCCESS(Status)) { 1625 free(xa); 1626 throw ntstatus_error(Status); 1627 } 1628 xa2 = (btrfs_set_xattr*)&xa2->data[xa2->namelen + xa2->valuelen]; 1629 } 1630 1631 free(xa); 1632 } else if (!NT_SUCCESS(Status)) 1633 throw ntstatus_error(Status); 1634 } catch (...) { 1635 FILE_DISPOSITION_INFO fdi; 1636 1637 fdi.DeleteFile = true; 1638 Status = NtSetInformationFile(dest, &iosb, &fdi, sizeof(FILE_DISPOSITION_INFO), FileDispositionInformation); 1639 if (!NT_SUCCESS(Status)) 1640 throw ntstatus_error(Status); 1641 1642 throw; 1643 } 1644 } 1645 1646 #ifdef __REACTOS__ 1647 extern "C" { 1648 #endif 1649 1650 void CALLBACK ReflinkCopyW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow) { 1651 vector<wstring> args; 1652 1653 command_line_to_args(lpszCmdLine, args); 1654 1655 if (args.size() >= 2) { 1656 bool dest_is_dir = false; 1657 wstring dest = args[args.size() - 1], destdir, destname; 1658 WCHAR volpath2[MAX_PATH]; 1659 1660 { 1661 win_handle destdirh = CreateFileW(dest.c_str(), FILE_TRAVERSE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 1662 nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr); 1663 1664 if (destdirh != INVALID_HANDLE_VALUE) { 1665 BY_HANDLE_FILE_INFORMATION bhfi; 1666 1667 if (GetFileInformationByHandle(destdirh, &bhfi) && bhfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { 1668 dest_is_dir = true; 1669 1670 destdir = dest; 1671 if (destdir.substr(destdir.length() - 1, 1) != L"\\") 1672 destdir += L"\\"; 1673 } 1674 } 1675 } 1676 1677 if (!dest_is_dir) { 1678 size_t found = dest.rfind(L"\\"); 1679 1680 if (found == wstring::npos) { 1681 destdir = L""; 1682 destname = dest; 1683 } else { 1684 destdir = dest.substr(0, found); 1685 destname = dest.substr(found + 1); 1686 } 1687 } 1688 1689 if (!GetVolumePathNameW(dest.c_str(), volpath2, sizeof(volpath2) / sizeof(WCHAR))) 1690 return; 1691 1692 for (unsigned int i = 0; i < args.size() - 1; i++) { 1693 WIN32_FIND_DATAW ffd; 1694 1695 fff_handle h = FindFirstFileW(args[i].c_str(), &ffd); 1696 if (h != INVALID_HANDLE_VALUE) { 1697 WCHAR volpath1[MAX_PATH]; 1698 wstring path = args[i]; 1699 size_t found = path.rfind(L"\\"); 1700 1701 if (found == wstring::npos) 1702 path = L""; 1703 else 1704 path = path.substr(0, found); 1705 1706 path += L"\\"; 1707 1708 if (get_volume_path_parent(path.c_str(), volpath1, sizeof(volpath1) / sizeof(WCHAR))) { 1709 if (!wcscmp(volpath1, volpath2)) { 1710 do { 1711 try { 1712 reflink_copy2(path + ffd.cFileName, destdir, dest_is_dir ? ffd.cFileName : destname); 1713 } catch (const exception& e) { 1714 cerr << "Error: " << e.what() << endl; 1715 } 1716 } while (FindNextFileW(h, &ffd)); 1717 } 1718 } 1719 } 1720 } 1721 } 1722 } 1723 1724 #ifdef __REACTOS__ 1725 } /* extern "C" */ 1726 #endif 1727