contextmenu.cpp File Reference

#include "shellext.h"
#include <windows.h>
#include <strsafe.h>
#include <stddef.h>
#include <winternl.h>
#include <wincodec.h>
#include <sstream>
#include <iostream>
#include <shlwapi.h>
#include "contextmenu.h"
#include "resource.h"
#include "../btrfsioctl.h"

Include dependency graph for contextmenu.cpp:

Go to the source code of this file.

Classes
struct	reparse_header

Macros
#define	NO_SHLWAPI_STRFCNS
#define	NEW_SUBVOL_VERBA   "newsubvol"
#define	NEW_SUBVOL_VERBW   L"newsubvol"
#define	SNAPSHOT_VERBA   "snapshot"
#define	SNAPSHOT_VERBW   L"snapshot"
#define	REFLINK_VERBA   "reflink"
#define	REFLINK_VERBW   L"reflink"
#define	RECV_VERBA   "recvsubvol"
#define	RECV_VERBW   L"recvsubvol"
#define	SEND_VERBA   "sendsubvol"
#define	SEND_VERBW   L"sendsubvol"

Functions
static void	path_remove_file (wstring &path)
static bool	get_volume_path_parent (const WCHAR *fn, WCHAR *volpath, ULONG volpathlen)
static bool	show_reflink_paste (const wstring &path)
static void	InitBitmapInfo (BITMAPINFO *pbmi, ULONG cbInfo, LONG cx, LONG cy, WORD bpp)
static HRESULT	Create32BitHBITMAP (HDC hdc, const SIZE *psize, void **ppvBits, HBITMAP *phBmp)
static void	path_strip_path (wstring &path)
static void	create_snapshot (HWND hwnd, const wstring &fn)
static uint64_t __inline	sector_align (uint64_t n, uint64_t a)
static void	reflink_copy2 (const wstring &srcfn, const wstring &destdir, const wstring &destname)
void CALLBACK	ReflinkCopyW (HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)

Macro Definition Documentation

NEW_SUBVOL_VERBA

#define NEW_SUBVOL_VERBA   "newsubvol"

Definition at line 49 of file contextmenu.cpp.

NEW_SUBVOL_VERBW

#define NEW_SUBVOL_VERBW   L"newsubvol"

Definition at line 50 of file contextmenu.cpp.

NO_SHLWAPI_STRFCNS

#define NO_SHLWAPI_STRFCNS

Definition at line 38 of file contextmenu.cpp.

RECV_VERBA

#define RECV_VERBA   "recvsubvol"

Definition at line 55 of file contextmenu.cpp.

RECV_VERBW

#define RECV_VERBW   L"recvsubvol"

Definition at line 56 of file contextmenu.cpp.

REFLINK_VERBA

#define REFLINK_VERBA   "reflink"

Definition at line 53 of file contextmenu.cpp.

REFLINK_VERBW

#define REFLINK_VERBW   L"reflink"

Definition at line 54 of file contextmenu.cpp.

SEND_VERBA

#define SEND_VERBA   "sendsubvol"

Definition at line 57 of file contextmenu.cpp.

SEND_VERBW

#define SEND_VERBW   L"sendsubvol"

Definition at line 58 of file contextmenu.cpp.

SNAPSHOT_VERBA

#define SNAPSHOT_VERBA   "snapshot"

Definition at line 51 of file contextmenu.cpp.

SNAPSHOT_VERBW

#define SNAPSHOT_VERBW   L"snapshot"

Definition at line 52 of file contextmenu.cpp.

Function Documentation

Create32BitHBITMAP()

static HRESULT Create32BitHBITMAP ( HDC  hdc, const SIZE *  psize, void **  ppvBits, HBITMAP *  phBmp  )

static

Definition at line 275 of file contextmenu.cpp.

                                                                                              {
    BITMAPINFO bmi;
    HDC hdcUsed;
 
    *phBmp = nullptr;
 
    InitBitmapInfo(&bmi, sizeof(bmi), psize->cx, psize->cy, 32);
 
    hdcUsed = hdc ? hdc : GetDC(nullptr);
 
    if (hdcUsed) {
        *phBmp = CreateDIBSection(hdcUsed, &bmi, DIB_RGB_COLORS, ppvBits, nullptr, 0);
        if (hdc != hdcUsed)
            ReleaseDC(nullptr, hdcUsed);
    }
 
    return !*phBmp ? E_OUTOFMEMORY : S_OK;
}

Referenced by BtrfsContextMenu::get_uac_icon().

create_snapshot()

static void create_snapshot ( HWND  hwnd, const wstring &  fn  )

static

Definition at line 451 of file contextmenu.cpp.

                                                          {
    win_handle h;
    NTSTATUS Status;
    IO_STATUS_BLOCK iosb;
    btrfs_get_file_ids bgfi;
 
    h = CreateFileW(fn.c_str(), FILE_TRAVERSE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
 
    if (h != INVALID_HANDLE_VALUE) {
        Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_FILE_IDS, nullptr, 0, &bgfi, sizeof(btrfs_get_file_ids));
 
        if (NT_SUCCESS(Status) && bgfi.inode == 0x100 && !bgfi.top) {
            wstring subvolname, parpath, searchpath, temp1, name, nameorig;
            win_handle h2;
            WIN32_FIND_DATAW wfd;
            SYSTEMTIME time;
 
            parpath = fn;
            path_remove_file(parpath);
 
            subvolname = fn;
            path_strip_path(subvolname);
 
            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);
 
            if (h2 == INVALID_HANDLE_VALUE)
                throw last_error(GetLastError());
 
            if (!load_string(module, IDS_SNAPSHOT_FILENAME, temp1))
                throw last_error(GetLastError());
 
            GetLocalTime(&time);
 
            wstring_sprintf(name, temp1, subvolname.c_str(), time.wYear, time.wMonth, time.wDay);
            nameorig = name;
 
            searchpath = parpath + L"\\" + name;
 
            fff_handle fff = FindFirstFileW(searchpath.c_str(), &wfd);
 
            if (fff != INVALID_HANDLE_VALUE) {
                ULONG num = 2;
 
                do {
#ifndef __REACTOS__
                    name = nameorig + L" (" + to_wstring(num) + L")";
#else
                    {
                        WCHAR buffer[32];
 
                        swprintf(buffer, L"%d", num);
                        name = nameorig + L" (" + buffer + L")";
                    }
#endif
                    searchpath = parpath + L"\\" + name;
 
                    fff = FindFirstFileW(searchpath.c_str(), &wfd);
                    num++;
                } while (fff != INVALID_HANDLE_VALUE);
            }
 
            size_t namelen = name.length() * sizeof(WCHAR);
 
            auto bcs = (btrfs_create_snapshot*)malloc(sizeof(btrfs_create_snapshot) - 1 + namelen);
            bcs->readonly = false;
            bcs->posix = false;
            bcs->subvol = h;
            bcs->namelen = (uint16_t)namelen;
            memcpy(bcs->name, name.c_str(), namelen);
 
            Status = NtFsControlFile(h2, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SNAPSHOT, bcs,
                                     (ULONG)(sizeof(btrfs_create_snapshot) - 1 + namelen), nullptr, 0);
 
            if (!NT_SUCCESS(Status))
                throw ntstatus_error(Status);
        }
    } else
        throw last_error(GetLastError());
}

Referenced by BtrfsContextMenu::InvokeCommand().

get_volume_path_parent()

static bool get_volume_path_parent ( const WCHAR *  fn, WCHAR *  volpath, ULONG  volpathlen  )

static

Definition at line 185 of file contextmenu.cpp.

                                                                                      {
    WCHAR *f, *p;
    bool b;
 
    f = PathFindFileNameW(fn);
 
    if (f == fn)
        return GetVolumePathNameW(fn, volpath, volpathlen);
 
    p = (WCHAR*)malloc((f - fn + 1) * sizeof(WCHAR));
    memcpy(p, fn, (f - fn) * sizeof(WCHAR));
    p[f - fn] = 0;
 
    b = GetVolumePathNameW(p, volpath, volpathlen);
 
    free(p);
 
    return b;
}

Referenced by BtrfsContextMenu::reflink_copy(), ReflinkCopyW(), and show_reflink_paste().

InitBitmapInfo()

static void InitBitmapInfo ( BITMAPINFO *  pbmi, ULONG  cbInfo, LONG  cx, LONG  cy, WORD  bpp  )

static

Definition at line 264 of file contextmenu.cpp.

                                                                                       {
    ZeroMemory(pbmi, cbInfo);
    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    pbmi->bmiHeader.biPlanes = 1;
    pbmi->bmiHeader.biCompression = BI_RGB;
 
    pbmi->bmiHeader.biWidth = cx;
    pbmi->bmiHeader.biHeight = cy;
    pbmi->bmiHeader.biBitCount = bpp;
}

Referenced by Create32BitHBITMAP().

path_remove_file()

static void path_remove_file ( wstring &  path )

static

Definition at line 426 of file contextmenu.cpp.

                                            {
    size_t bs = path.rfind(L"\\");
 
    if (bs == string::npos)
        return;
 
    if (bs == path.find(L"\\")) { // only one backslash
        path = path.substr(0, bs + 1);
        return;
    }
 
    path = path.substr(0, bs);
}

Referenced by create_snapshot(), and BtrfsContextMenu::Initialize().

path_strip_path()

static void path_strip_path ( wstring &  path )

static

Definition at line 440 of file contextmenu.cpp.

                                           {
    size_t bs = path.rfind(L"\\");
 
    if (bs == string::npos) {
        path = L"";
        return;
    }
 
    path = path.substr(bs + 1);
}

Referenced by create_snapshot().

reflink_copy2()

static void reflink_copy2 ( const wstring &  srcfn, const wstring &  destdir, const wstring &  destname  )

static

Definition at line 1320 of file contextmenu.cpp.

                                                                                                 {
    win_handle source, dest;
    FILE_BASIC_INFO fbi;
    FILETIME atime, mtime;
    btrfs_inode_info bii;
    btrfs_set_inode_info bsii;
    ULONG bytesret;
    NTSTATUS Status;
    IO_STATUS_BLOCK iosb;
    btrfs_set_xattr bsxa;
 
    source = CreateFileW(srcfn.c_str(), GENERIC_READ | FILE_TRAVERSE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_OPEN_REPARSE_POINT, nullptr);
    if (source == INVALID_HANDLE_VALUE)
        throw last_error(GetLastError());
 
    Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info));
    if (!NT_SUCCESS(Status))
        throw ntstatus_error(Status);
 
    // if subvol, do snapshot instead
    if (bii.inode == SUBVOL_ROOT_INODE) {
        btrfs_create_snapshot* bcs;
        win_handle dirh;
 
        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);
        if (dirh == INVALID_HANDLE_VALUE)
            throw last_error(GetLastError());
 
        size_t bcslen = offsetof(btrfs_create_snapshot, name[0]) + (destname.length() * sizeof(WCHAR));
        bcs = (btrfs_create_snapshot*)malloc(bcslen);
        bcs->subvol = source;
        bcs->namelen = (uint16_t)(destname.length() * sizeof(WCHAR));
        memcpy(bcs->name, destname.c_str(), destname.length() * sizeof(WCHAR));
 
        Status = NtFsControlFile(dirh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SNAPSHOT, bcs, (ULONG)bcslen, nullptr, 0);
        if (!NT_SUCCESS(Status)) {
            free(bcs);
            throw ntstatus_error(Status);
        }
 
        free(bcs);
 
        return;
    }
 
    Status = NtQueryInformationFile(source, &iosb, &fbi, sizeof(FILE_BASIC_INFO), FileBasicInformation);
    if (!NT_SUCCESS(Status))
        throw ntstatus_error(Status);
 
    if (bii.type == BTRFS_TYPE_CHARDEV || bii.type == BTRFS_TYPE_BLOCKDEV || bii.type == BTRFS_TYPE_FIFO || bii.type == BTRFS_TYPE_SOCKET) {
        win_handle dirh;
        btrfs_mknod* bmn;
 
        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);
        if (dirh == INVALID_HANDLE_VALUE)
            throw last_error(GetLastError());
 
        size_t bmnsize = offsetof(btrfs_mknod, name[0]) + (destname.length() * sizeof(WCHAR));
        bmn = (btrfs_mknod*)malloc(bmnsize);
 
        bmn->inode = 0;
        bmn->type = bii.type;
        bmn->st_rdev = bii.st_rdev;
        bmn->namelen = (uint16_t)(destname.length() * sizeof(WCHAR));
        memcpy(bmn->name, destname.c_str(), bmn->namelen);
 
        Status = NtFsControlFile(dirh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_MKNOD, bmn, (ULONG)bmnsize, nullptr, 0);
        if (!NT_SUCCESS(Status)) {
            free(bmn);
            throw ntstatus_error(Status);
        }
 
        free(bmn);
 
        dest = CreateFileW((destdir + destname).c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
    } else if (fbi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
        if (CreateDirectoryExW(srcfn.c_str(), (destdir + destname).c_str(), nullptr))
            dest = CreateFileW((destdir + destname).c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                               nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
        else
            dest = INVALID_HANDLE_VALUE;
    } else
        dest = CreateFileW((destdir + destname).c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, CREATE_NEW, 0, source);
 
    if (dest == INVALID_HANDLE_VALUE)
        throw last_error(GetLastError());
 
    memset(&bsii, 0, sizeof(btrfs_set_inode_info));
 
    bsii.flags_changed = true;
    bsii.flags = bii.flags;
 
    if (bii.flags & BTRFS_INODE_COMPRESS) {
        bsii.compression_type_changed = true;
        bsii.compression_type = bii.compression_type;
    }
 
    try {
        Status = NtFsControlFile(dest, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_INODE_INFO, &bsii, sizeof(btrfs_set_inode_info), nullptr, 0);
        if (!NT_SUCCESS(Status))
            throw ntstatus_error(Status);
 
        if (fbi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
            if (!(fbi.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
                WIN32_FIND_DATAW fff;
                wstring qs;
 
                qs = srcfn;
                qs += L"\\*";
 
                fff_handle h = FindFirstFileW(qs.c_str(), &fff);
                if (h != INVALID_HANDLE_VALUE) {
                    do {
                        wstring fn2;
 
                        if (fff.cFileName[0] == '.' && (fff.cFileName[1] == 0 || (fff.cFileName[1] == '.' && fff.cFileName[2] == 0)))
                            continue;
 
                        fn2 = srcfn;
                        fn2 += L"\\";
                        fn2 += fff.cFileName;
 
                        reflink_copy2(fn2, destdir + destname + L"\\", fff.cFileName);
                    } while (FindNextFileW(h, &fff));
                }
            }
 
            // CreateDirectoryExW also copies streams, no need to do it here
        } else {
            if (fbi.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
                reparse_header rh;
                uint8_t* rp;
 
                if (!DeviceIoControl(source, FSCTL_GET_REPARSE_POINT, nullptr, 0, &rh, sizeof(reparse_header), &bytesret, nullptr)) {
                    if (GetLastError() != ERROR_MORE_DATA)
                        throw last_error(GetLastError());
                }
 
                size_t rplen = sizeof(reparse_header) + rh.ReparseDataLength;
                rp = (uint8_t*)malloc(rplen);
 
                try {
                    if (!DeviceIoControl(source, FSCTL_GET_REPARSE_POINT, nullptr, 0, rp, (DWORD)rplen, &bytesret, nullptr))
                        throw last_error(GetLastError());
 
                    if (!DeviceIoControl(dest, FSCTL_SET_REPARSE_POINT, rp, (DWORD)rplen, nullptr, 0, &bytesret, nullptr))
                        throw last_error(GetLastError());
                } catch (...) {
                    free(rp);
                    throw;
                }
 
                free(rp);
            } else {
                FILE_STANDARD_INFO fsi;
                FILE_END_OF_FILE_INFO feofi;
                FSCTL_GET_INTEGRITY_INFORMATION_BUFFER fgiib;
                FSCTL_SET_INTEGRITY_INFORMATION_BUFFER fsiib;
                DUPLICATE_EXTENTS_DATA ded;
                uint64_t offset, alloc_size;
                ULONG maxdup;
 
                Status = NtQueryInformationFile(source, &iosb, &fsi, sizeof(FILE_STANDARD_INFO), FileStandardInformation);
                if (!NT_SUCCESS(Status))
                    throw ntstatus_error(Status);
 
                if (!DeviceIoControl(source, FSCTL_GET_INTEGRITY_INFORMATION, nullptr, 0, &fgiib, sizeof(FSCTL_GET_INTEGRITY_INFORMATION_BUFFER), &bytesret, nullptr))
                    throw last_error(GetLastError());
 
                if (fbi.FileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) {
                    if (!DeviceIoControl(dest, FSCTL_SET_SPARSE, nullptr, 0, nullptr, 0, &bytesret, nullptr))
                        throw last_error(GetLastError());
                }
 
                fsiib.ChecksumAlgorithm = fgiib.ChecksumAlgorithm;
                fsiib.Reserved = 0;
                fsiib.Flags = fgiib.Flags;
                if (!DeviceIoControl(dest, FSCTL_SET_INTEGRITY_INFORMATION, &fsiib, sizeof(FSCTL_SET_INTEGRITY_INFORMATION_BUFFER), nullptr, 0, &bytesret, nullptr))
                    throw last_error(GetLastError());
 
                feofi.EndOfFile = fsi.EndOfFile;
                Status = NtSetInformationFile(dest, &iosb, &feofi, sizeof(FILE_END_OF_FILE_INFO), FileEndOfFileInformation);
                if (!NT_SUCCESS(Status))
                    throw ntstatus_error(Status);
 
                ded.FileHandle = source;
                maxdup = 0xffffffff - fgiib.ClusterSizeInBytes + 1;
 
                alloc_size = sector_align(fsi.EndOfFile.QuadPart, fgiib.ClusterSizeInBytes);
 
                offset = 0;
                while (offset < alloc_size) {
                    ded.SourceFileOffset.QuadPart = ded.TargetFileOffset.QuadPart = offset;
                    ded.ByteCount.QuadPart = maxdup < (alloc_size - offset) ? maxdup : (alloc_size - offset);
                    if (!DeviceIoControl(dest, FSCTL_DUPLICATE_EXTENTS_TO_FILE, &ded, sizeof(DUPLICATE_EXTENTS_DATA), nullptr, 0, &bytesret, nullptr))
                        throw last_error(GetLastError());
 
                    offset += ded.ByteCount.QuadPart;
                }
            }
 
            ULONG streambufsize = 0;
            vector<char> streambuf;
 
            do {
                streambufsize += 0x1000;
                streambuf.resize(streambufsize);
 
                memset(streambuf.data(), 0, streambufsize);
 
                Status = NtQueryInformationFile(source, &iosb, streambuf.data(), streambufsize, FileStreamInformation);
            } while (Status == STATUS_BUFFER_OVERFLOW);
 
            if (!NT_SUCCESS(Status))
                throw ntstatus_error(Status);
 
            auto fsi = reinterpret_cast<FILE_STREAM_INFORMATION*>(streambuf.data());
 
            while (true) {
                if (fsi->StreamNameLength > 0) {
                    wstring sn = wstring(fsi->StreamName, fsi->StreamNameLength / sizeof(WCHAR));
 
                    if (sn != L"::$DATA" && sn.length() > 6 && sn.substr(sn.length() - 6, 6) == L":$DATA") {
                        win_handle stream;
                        uint8_t* data = nullptr;
                        auto stream_size = (uint16_t)fsi->StreamSize.QuadPart;
 
                        if (stream_size > 0) {
                            wstring fn2;
 
                            fn2 = srcfn;
                            fn2 += sn;
 
                            stream = CreateFileW(fn2.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr);
 
                            if (stream == INVALID_HANDLE_VALUE)
                                throw last_error(GetLastError());
 
                            // We can get away with this because our streams are guaranteed to be below 64 KB -
                            // don't do this on NTFS!
                            data = (uint8_t*)malloc(stream_size);
 
                            if (!ReadFile(stream, data, stream_size, &bytesret, nullptr)) {
                                free(data);
                                throw last_error(GetLastError());
                            }
                        }
 
                        stream = CreateFileW((destdir + destname + sn).c_str(), GENERIC_READ | GENERIC_WRITE | DELETE, 0, nullptr, CREATE_NEW, 0, nullptr);
 
                        if (stream == INVALID_HANDLE_VALUE) {
                            if (data) free(data);
                            throw last_error(GetLastError());
                        }
 
                        if (data) {
                            if (!WriteFile(stream, data, stream_size, &bytesret, nullptr)) {
                                free(data);
                                throw last_error(GetLastError());
                            }
 
                            free(data);
                        }
                    }
 
                }
 
                if (fsi->NextEntryOffset == 0)
                    break;
 
                fsi = reinterpret_cast<FILE_STREAM_INFORMATION*>(reinterpret_cast<char*>(fsi) + fsi->NextEntryOffset);
            }
        }
 
        atime.dwLowDateTime = fbi.LastAccessTime.LowPart;
        atime.dwHighDateTime = fbi.LastAccessTime.HighPart;
        mtime.dwLowDateTime = fbi.LastWriteTime.LowPart;
        mtime.dwHighDateTime = fbi.LastWriteTime.HighPart;
        SetFileTime(dest, nullptr, &atime, &mtime);
 
        Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_XATTRS, nullptr, 0, &bsxa, sizeof(btrfs_set_xattr));
 
        if (Status == STATUS_BUFFER_OVERFLOW || (NT_SUCCESS(Status) && bsxa.valuelen > 0)) {
            ULONG xalen = 0;
            btrfs_set_xattr *xa = nullptr, *xa2;
 
            do {
                xalen += 1024;
 
                if (xa) free(xa);
                xa = (btrfs_set_xattr*)malloc(xalen);
 
                Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_XATTRS, nullptr, 0, xa, xalen);
            } while (Status == STATUS_BUFFER_OVERFLOW);
 
            if (!NT_SUCCESS(Status)) {
                free(xa);
                throw ntstatus_error(Status);
            }
 
            xa2 = xa;
            while (xa2->valuelen > 0) {
                Status = NtFsControlFile(dest, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_XATTR, xa2,
                                         (ULONG)(offsetof(btrfs_set_xattr, data[0]) + xa2->namelen + xa2->valuelen), nullptr, 0);
                if (!NT_SUCCESS(Status)) {
                    free(xa);
                    throw ntstatus_error(Status);
                }
                xa2 = (btrfs_set_xattr*)&xa2->data[xa2->namelen + xa2->valuelen];
            }
 
            free(xa);
        } else if (!NT_SUCCESS(Status))
            throw ntstatus_error(Status);
    } catch (...) {
        FILE_DISPOSITION_INFO fdi;
 
        fdi.DeleteFile = true;
        Status = NtSetInformationFile(dest, &iosb, &fdi, sizeof(FILE_DISPOSITION_INFO), FileDispositionInformation);
        if (!NT_SUCCESS(Status))
            throw ntstatus_error(Status);
 
        throw;
    }
}

Referenced by reflink_copy2(), and ReflinkCopyW().

ReflinkCopyW()

void CALLBACK ReflinkCopyW	(	HWND	hwnd,
		HINSTANCE	hinst,
		LPWSTR	lpszCmdLine,
		int	nCmdShow
	)

Definition at line 1646 of file contextmenu.cpp.

                                                                                                    {
    vector<wstring> args;
 
    command_line_to_args(lpszCmdLine, args);
 
    if (args.size() >= 2) {
        bool dest_is_dir = false;
        wstring dest = args[args.size() - 1], destdir, destname;
        WCHAR volpath2[MAX_PATH];
 
        {
            win_handle destdirh = CreateFileW(dest.c_str(), FILE_TRAVERSE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                                              nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
 
            if (destdirh != INVALID_HANDLE_VALUE) {
                BY_HANDLE_FILE_INFORMATION bhfi;
 
                if (GetFileInformationByHandle(destdirh, &bhfi) && bhfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
                    dest_is_dir = true;
 
                    destdir = dest;
                    if (destdir.substr(destdir.length() - 1, 1) != L"\\")
                        destdir += L"\\";
                }
            }
        }
 
        if (!dest_is_dir) {
            size_t found = dest.rfind(L"\\");
 
            if (found == wstring::npos) {
                destdir = L"";
                destname = dest;
            } else {
                destdir = dest.substr(0, found);
                destname = dest.substr(found + 1);
            }
        }
 
        if (!GetVolumePathNameW(dest.c_str(), volpath2, sizeof(volpath2) / sizeof(WCHAR)))
            return;
 
        for (unsigned int i = 0; i < args.size() - 1; i++) {
            WIN32_FIND_DATAW ffd;
 
            fff_handle h = FindFirstFileW(args[i].c_str(), &ffd);
            if (h != INVALID_HANDLE_VALUE) {
                WCHAR volpath1[MAX_PATH];
                wstring path = args[i];
                size_t found = path.rfind(L"\\");
 
                if (found == wstring::npos)
                    path = L"";
                else
                    path = path.substr(0, found);
 
                path += L"\\";
 
                if (get_volume_path_parent(path.c_str(), volpath1, sizeof(volpath1) / sizeof(WCHAR))) {
                    if (!wcscmp(volpath1, volpath2)) {
                        do {
                            try {
                                reflink_copy2(path + ffd.cFileName, destdir, dest_is_dir ? ffd.cFileName : destname);
                            } catch (const exception& e) {
                                cerr << "Error: " << e.what() << endl;
                            }
                        } while (FindNextFileW(h, &ffd));
                    }
                }
            }
        }
    }
}

sector_align()

static uint64_t __inline sector_align ( uint64_t  n, uint64_t  a  )

static

Definition at line 531 of file contextmenu.cpp.

                                                              {
    if (n & (a - 1))
        n = (n + a) & ~(a - 1);
 
    return n;
}

Referenced by __attribute__(), add_ext_holes(), add_trim_entry_avoid_sb(), allocate_cache_chunk(), balance_data_chunk(), check_for_orphans_root(), clean_space_cache(), delete_fileref_fcb(), device_still_valid(), duplicate_extents(), fcb_alloc_size(), fill_in_file_stream_information(), fill_in_hard_link_full_id_information(), fill_in_hard_link_information(), flush_extents(), flush_fcb(), get_inode_info(), get_superblock_size(), is_device_part_of_mounted_btrfs_raid(), load_stored_free_space_cache(), load_stored_free_space_tree(), lzo_compress(), protect_superblocks(), query_dir_item(), read_superblock(), BtrfsContextMenu::reflink_copy(), reflink_copy2(), remove_free_space_inode(), rename_file_to_stream(), rename_stream_to_file(), scrub_chunk(), scrub_chunk_raid56_stripe_run(), set_zero_data(), still_has_superblock(), test_vol(), trim_unalloc_space(), update_chunk_cache(), verify_device(), write_compressed(), write_superblock(), and zero_data().

show_reflink_paste()

static bool show_reflink_paste ( const wstring &  path )

static

Definition at line 205 of file contextmenu.cpp.

                                                    {
    HDROP hdrop;
    HANDLE lh;
    ULONG num_files;
    WCHAR fn[MAX_PATH], volpath1[255], volpath2[255];
 
    if (!IsClipboardFormatAvailable(CF_HDROP))
        return false;
 
    if (!GetVolumePathNameW(path.c_str(), volpath1, sizeof(volpath1) / sizeof(WCHAR)))
        return false;
 
    if (!OpenClipboard(nullptr))
        return false;
 
    hdrop = (HDROP)GetClipboardData(CF_HDROP);
 
    if (!hdrop) {
        CloseClipboard();
        return false;
    }
 
    lh = GlobalLock(hdrop);
 
    if (!lh) {
        CloseClipboard();
        return false;
    }
 
    num_files = DragQueryFileW(hdrop, 0xFFFFFFFF, nullptr, 0);
 
    if (num_files == 0) {
        GlobalUnlock(lh);
        CloseClipboard();
        return false;
    }
 
    if (!DragQueryFileW(hdrop, 0, fn, sizeof(fn) / sizeof(WCHAR))) {
        GlobalUnlock(lh);
        CloseClipboard();
        return false;
    }
 
    if (!get_volume_path_parent(fn, volpath2, sizeof(volpath2) / sizeof(WCHAR))) {
        GlobalUnlock(lh);
        CloseClipboard();
        return false;
    }
 
    GlobalUnlock(lh);
 
    CloseClipboard();
 
    return !wcscmp(volpath1, volpath2);
}

Referenced by BtrfsContextMenu::QueryContextMenu().