BtrfsSend Class Reference

#include <send.h>

Collaboration diagram for BtrfsSend:

Public Member Functions
	BtrfsSend ()
	~BtrfsSend ()
void	Open (HWND hwnd, WCHAR *path)
INT_PTR	SendDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
DWORD	Thread ()

Private Member Functions
void	StartSend (HWND hwnd)
void	Browse (HWND hwnd)
void	BrowseParent (HWND hwnd)
void	AddClone (HWND hwnd)
void	RemoveClone (HWND hwnd)

Private Attributes
bool	started
bool	incremental
WCHAR	file [MAX_PATH]
WCHAR	closetext [255]
HANDLE	thread
HANDLE	dirh
HANDLE	stream
HWND	hwnd
wstring	subvol
char *	buf
vector< wstring >	clones

Detailed Description

Definition at line 27 of file send.h.

Constructor & Destructor Documentation

BtrfsSend()

BtrfsSend::BtrfsSend ( )

inline

Definition at line 29 of file send.h.

                {
        started = false;
        file[0] = 0;
        dirh = INVALID_HANDLE_VALUE;
        stream = INVALID_HANDLE_VALUE;
        subvol = L"";
        buf = nullptr;
        incremental = false;
    }

~BtrfsSend()

BtrfsSend::~BtrfsSend ( )

inline

Definition at line 39 of file send.h.

                 {
        if (buf)
            free(buf);
    }

Member Function Documentation

AddClone()

void BtrfsSend::AddClone ( HWND  hwnd )

private

Definition at line 360 of file send.cpp.

                                  {
    BROWSEINFOW bi;
    PIDLIST_ABSOLUTE root, pidl;
    HRESULT hr;
    WCHAR path[MAX_PATH], volpathw[MAX_PATH];
    NTSTATUS Status;
    IO_STATUS_BLOCK iosb;
    btrfs_get_file_ids bgfi;
 
    if (!GetVolumePathNameW(subvol.c_str(), volpathw, (sizeof(volpathw) / sizeof(WCHAR)) - 1))
        throw string_error(IDS_RECV_GETVOLUMEPATHNAME_FAILED, GetLastError(), format_message(GetLastError()).c_str());
 
    hr = SHParseDisplayName(volpathw, 0, &root, 0, 0);
    if (FAILED(hr))
        throw string_error(IDS_SHPARSEDISPLAYNAME_FAILED);
 
    memset(&bi, 0, sizeof(BROWSEINFOW));
 
    bi.hwndOwner = hwnd;
    bi.pidlRoot = root;
    bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_USENEWUI | BIF_NONEWFOLDERBUTTON;
 
    pidl = SHBrowseForFolderW(&bi);
 
    if (!pidl)
        return;
 
    if (!SHGetPathFromIDListW(pidl, path))
        throw string_error(IDS_SHGETPATHFROMIDLIST_FAILED);
 
    {
        win_handle h = CreateFileW(path, FILE_TRAVERSE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
        if (h == INVALID_HANDLE_VALUE)
            throw string_error(IDS_SEND_CANT_OPEN_DIR, path, GetLastError(), format_message(GetLastError()).c_str());
 
        Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_FILE_IDS, nullptr, 0, &bgfi, sizeof(btrfs_get_file_ids));
        if (!NT_SUCCESS(Status))
            throw string_error(IDS_GET_FILE_IDS_FAILED, Status, format_ntstatus(Status).c_str());
    }
 
    if (bgfi.inode != 0x100 || bgfi.top)
        throw string_error(IDS_NOT_SUBVOL);
 
    SendMessageW(GetDlgItem(hwnd, IDC_CLONE_LIST), LB_ADDSTRING, 0, (LPARAM)path);
}

Referenced by SendDlgProc().

Browse()

void BtrfsSend::Browse ( HWND  hwnd )

private

Definition at line 295 of file send.cpp.

                                {
    OPENFILENAMEW ofn;
 
    file[0] = 0;
 
    memset(&ofn, 0, sizeof(OPENFILENAMEW));
    ofn.lStructSize = sizeof(OPENFILENAMEW);
    ofn.hwndOwner = hwnd;
    ofn.hInstance = module;
    ofn.lpstrFile = file;
    ofn.nMaxFile = sizeof(file) / sizeof(WCHAR);
    ofn.Flags = OFN_EXPLORER;
 
    if (!GetSaveFileNameW(&ofn))
        return;
 
    SetDlgItemTextW(hwnd, IDC_STREAM_DEST, file);
}

Referenced by SendDlgProc().

BrowseParent()

void BtrfsSend::BrowseParent ( HWND  hwnd )

private

Definition at line 314 of file send.cpp.

                                      {
    BROWSEINFOW bi;
    PIDLIST_ABSOLUTE root, pidl;
    HRESULT hr;
    WCHAR parent[MAX_PATH], volpathw[MAX_PATH];
    NTSTATUS Status;
    IO_STATUS_BLOCK iosb;
    btrfs_get_file_ids bgfi;
 
    if (!GetVolumePathNameW(subvol.c_str(), volpathw, (sizeof(volpathw) / sizeof(WCHAR)) - 1))
        throw string_error(IDS_RECV_GETVOLUMEPATHNAME_FAILED, GetLastError(), format_message(GetLastError()).c_str());
 
    hr = SHParseDisplayName(volpathw, 0, &root, 0, 0);
    if (FAILED(hr))
        throw string_error(IDS_SHPARSEDISPLAYNAME_FAILED);
 
    memset(&bi, 0, sizeof(BROWSEINFOW));
 
    bi.hwndOwner = hwnd;
    bi.pidlRoot = root;
    bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_USENEWUI | BIF_NONEWFOLDERBUTTON;
 
    pidl = SHBrowseForFolderW(&bi);
 
    if (!pidl)
        return;
 
    if (!SHGetPathFromIDListW(pidl, parent))
        throw string_error(IDS_SHGETPATHFROMIDLIST_FAILED);
 
    {
        win_handle h = CreateFileW(parent, FILE_TRAVERSE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
        if (h == INVALID_HANDLE_VALUE)
            throw string_error(IDS_SEND_CANT_OPEN_DIR, parent, GetLastError(), format_message(GetLastError()).c_str());
 
        Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_FILE_IDS, nullptr, 0, &bgfi, sizeof(btrfs_get_file_ids));
        if (!NT_SUCCESS(Status))
            throw string_error(IDS_GET_FILE_IDS_FAILED, Status, format_ntstatus(Status).c_str());
    }
 
    if (bgfi.inode != 0x100 || bgfi.top)
        throw string_error(IDS_NOT_SUBVOL);
 
    SetDlgItemTextW(hwnd, IDC_PARENT_SUBVOL, parent);
}

Referenced by SendDlgProc().

Open()

void BtrfsSend::Open	(	HWND	hwnd,
		WCHAR *	path
	)

Definition at line 528 of file send.cpp.

                                           {
    subvol = path;
 
    if (DialogBoxParamW(module, MAKEINTRESOURCEW(IDD_SEND_SUBVOL), hwnd, stub_SendDlgProc, (LPARAM)this) <= 0)
        throw last_error(GetLastError());
}

RemoveClone()

void BtrfsSend::RemoveClone ( HWND  hwnd )

private

Definition at line 406 of file send.cpp.

                                     {
    LRESULT sel;
    HWND cl = GetDlgItem(hwnd, IDC_CLONE_LIST);
 
    sel = SendMessageW(cl, LB_GETCURSEL, 0, 0);
 
    if (sel == LB_ERR)
        return;
 
    SendMessageW(cl, LB_DELETESTRING, sel, 0);
 
    if (SendMessageW(cl, LB_GETCURSEL, 0, 0) == LB_ERR)
        EnableWindow(GetDlgItem(hwnd, IDC_CLONE_REMOVE), false);
}

Referenced by SendDlgProc().

SendDlgProc()

INT_PTR BtrfsSend::SendDlgProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 421 of file send.cpp.

                                                                                    {
    try {
        switch (uMsg) {
            case WM_INITDIALOG:
                this->hwnd = hwndDlg;
 
                GetDlgItemTextW(hwndDlg, IDCANCEL, closetext, sizeof(closetext) / sizeof(WCHAR));
            break;
 
            case WM_COMMAND:
                switch (HIWORD(wParam)) {
                    case BN_CLICKED:
                        switch (LOWORD(wParam)) {
                            case IDOK:
                                StartSend(hwndDlg);
                            return true;
 
                            case IDCANCEL:
                                if (started) {
                                    TerminateThread(thread, 0);
 
                                    if (stream != INVALID_HANDLE_VALUE) {
                                        NTSTATUS Status;
                                        FILE_DISPOSITION_INFO fdi;
                                        IO_STATUS_BLOCK iosb;
 
                                        fdi.DeleteFile = true;
 
                                        Status = NtSetInformationFile(stream, &iosb, &fdi, sizeof(FILE_DISPOSITION_INFO), FileDispositionInformation);
 
                                        CloseHandle(stream);
 
                                        if (!NT_SUCCESS(Status))
                                            throw ntstatus_error(Status);
                                    }
 
                                    if (dirh != INVALID_HANDLE_VALUE)
                                        CloseHandle(dirh);
 
                                    started = false;
 
                                    SetDlgItemTextW(hwndDlg, IDCANCEL, closetext);
 
                                    EnableWindow(GetDlgItem(hwnd, IDOK), true);
                                    EnableWindow(GetDlgItem(hwnd, IDC_STREAM_DEST), true);
                                    EnableWindow(GetDlgItem(hwnd, IDC_BROWSE), true);
                                } else
                                    EndDialog(hwndDlg, 1);
                            return true;
 
                            case IDC_BROWSE:
                                Browse(hwndDlg);
                            return true;
 
                            case IDC_INCREMENTAL:
                                incremental = IsDlgButtonChecked(hwndDlg, LOWORD(wParam));
 
                                EnableWindow(GetDlgItem(hwnd, IDC_PARENT_SUBVOL), incremental);
                                EnableWindow(GetDlgItem(hwnd, IDC_PARENT_BROWSE), incremental);
                            return true;
 
                            case IDC_PARENT_BROWSE:
                                BrowseParent(hwndDlg);
                            return true;
 
                            case IDC_CLONE_ADD:
                                AddClone(hwndDlg);
                            return true;
 
                            case IDC_CLONE_REMOVE:
                                RemoveClone(hwndDlg);
                            return true;
                        }
                    break;
 
                    case LBN_SELCHANGE:
                        switch (LOWORD(wParam)) {
                            case IDC_CLONE_LIST:
                                EnableWindow(GetDlgItem(hwnd, IDC_CLONE_REMOVE), true);
                            return true;
                        }
                    break;
                }
            break;
        }
    } catch (const exception& e) {
        error_message(hwnd, e.what());
    }
 
    return false;
}

StartSend()

void BtrfsSend::StartSend ( HWND  hwnd )

private

Definition at line 233 of file send.cpp.

                                   {
    wstring s;
    HWND cl;
 
    if (started)
        return;
 
    GetDlgItemTextW(hwnd, IDC_STREAM_DEST, file, sizeof(file) / sizeof(WCHAR));
 
    if (file[0] == 0)
        return;
 
    if (incremental) {
        WCHAR parent[MAX_PATH];
 
        GetDlgItemTextW(hwnd, IDC_PARENT_SUBVOL, parent, sizeof(parent) / sizeof(WCHAR));
 
        if (parent[0] == 0)
            return;
    }
 
    started = true;
 
    wstring writing;
 
    load_string(module, IDS_SEND_WRITING, writing);
 
    SetDlgItemTextW(hwnd, IDC_SEND_STATUS, writing.c_str());
 
    load_string(module, IDS_SEND_CANCEL, s);
    SetDlgItemTextW(hwnd, IDCANCEL, s.c_str());
 
    EnableWindow(GetDlgItem(hwnd, IDOK), false);
    EnableWindow(GetDlgItem(hwnd, IDC_STREAM_DEST), false);
    EnableWindow(GetDlgItem(hwnd, IDC_BROWSE), false);
 
    clones.clear();
 
    cl = GetDlgItem(hwnd, IDC_CLONE_LIST);
    auto num_clones = SendMessageW(cl, LB_GETCOUNT, 0, 0);
 
    if (num_clones != LB_ERR) {
        for (unsigned int i = 0; i < (unsigned int)num_clones; i++) {
            WCHAR* t;
 
            auto len = SendMessageW(cl, LB_GETTEXTLEN, i, 0);
            t = (WCHAR*)malloc((len + 1) * sizeof(WCHAR));
 
            SendMessageW(cl, LB_GETTEXT, i, (LPARAM)t);
 
            clones.push_back(t);
 
            free(t);
        }
    }
 
    thread = CreateThread(nullptr, 0, send_thread, this, 0, nullptr);
 
    if (!thread)
        throw last_error(GetLastError());
}

Referenced by SendDlgProc().

Thread()

DWORD BtrfsSend::Thread

(

)

Definition at line 30 of file send.cpp.

                        {
    try {
        NTSTATUS Status;
        IO_STATUS_BLOCK iosb;
        btrfs_send_subvol* bss;
        btrfs_send_header header;
        btrfs_send_command end;
        ULONG i;
 
        buf = (char*)malloc(SEND_BUFFER_LEN);
 
        try {
            dirh = CreateFileW(subvol.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
            if (dirh == INVALID_HANDLE_VALUE)
                throw string_error(IDS_SEND_CANT_OPEN_DIR, subvol.c_str(), GetLastError(), format_message(GetLastError()).c_str());
 
            try {
                size_t bss_size = offsetof(btrfs_send_subvol, clones[0]) + (clones.size() * sizeof(HANDLE));
                bss = (btrfs_send_subvol*)malloc(bss_size);
                memset(bss, 0, bss_size);
 
                if (incremental) {
                    WCHAR parent[MAX_PATH];
                    HANDLE parenth;
 
                    parent[0] = 0;
 
                    GetDlgItemTextW(hwnd, IDC_PARENT_SUBVOL, parent, sizeof(parent) / sizeof(WCHAR));
 
                    parenth = CreateFileW(parent, FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
                    if (parenth == INVALID_HANDLE_VALUE)
                        throw string_error(IDS_SEND_CANT_OPEN_DIR, parent, GetLastError(), format_message(GetLastError()).c_str());
 
                    bss->parent = parenth;
                } else
                    bss->parent = nullptr;
 
                bss->num_clones = (ULONG)clones.size();
 
                for (i = 0; i < bss->num_clones; i++) {
                    HANDLE h;
 
                    h = CreateFileW(clones[i].c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
                    if (h == INVALID_HANDLE_VALUE) {
                        auto le = GetLastError();
                        ULONG j;
 
                        for (j = 0; j < i; j++) {
                            CloseHandle(bss->clones[j]);
                        }
 
                        if (bss->parent) CloseHandle(bss->parent);
 
                        throw string_error(IDS_SEND_CANT_OPEN_DIR, clones[i].c_str(), le, format_message(le).c_str());
                    }
 
                    bss->clones[i] = h;
                }
 
                Status = NtFsControlFile(dirh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SEND_SUBVOL, bss, (ULONG)bss_size, nullptr, 0);
 
                for (i = 0; i < bss->num_clones; i++) {
                    CloseHandle(bss->clones[i]);
                }
 
                if (!NT_SUCCESS(Status)) {
                    if (Status == (NTSTATUS)STATUS_INVALID_PARAMETER) {
                        BY_HANDLE_FILE_INFORMATION fileinfo;
                        if (!GetFileInformationByHandle(dirh, &fileinfo)) {
                            auto le = GetLastError();
                            if (bss->parent) CloseHandle(bss->parent);
                            throw string_error(IDS_SEND_GET_FILE_INFO_FAILED, le, format_message(le).c_str());
                        }
 
                        if (!(fileinfo.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
                            if (bss->parent) CloseHandle(bss->parent);
                            throw string_error(IDS_SEND_NOT_READONLY);
                        }
 
                        if (bss->parent) {
                            if (!GetFileInformationByHandle(bss->parent, &fileinfo)) {
                                auto le = GetLastError();
                                CloseHandle(bss->parent);
                                throw string_error(IDS_SEND_GET_FILE_INFO_FAILED, le, format_message(le).c_str());
                            }
 
                            if (!(fileinfo.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
                                CloseHandle(bss->parent);
                                throw string_error(IDS_SEND_PARENT_NOT_READONLY);
                            }
                        }
                    }
 
                    if (bss->parent) CloseHandle(bss->parent);
                    throw string_error(IDS_SEND_FSCTL_BTRFS_SEND_SUBVOL_FAILED, Status, format_ntstatus(Status).c_str());
                }
 
                if (bss->parent) CloseHandle(bss->parent);
 
                stream = CreateFileW(file, FILE_WRITE_DATA | DELETE, 0, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
                if (stream == INVALID_HANDLE_VALUE)
                    throw string_error(IDS_SEND_CANT_OPEN_FILE, file, GetLastError(), format_message(GetLastError()).c_str());
 
                try {
                    memcpy(header.magic, BTRFS_SEND_MAGIC, sizeof(header.magic));
                    header.version = 1;
 
                    if (!WriteFile(stream, &header, sizeof(header), nullptr, nullptr))
                        throw string_error(IDS_SEND_WRITEFILE_FAILED, GetLastError(), format_message(GetLastError()).c_str());
 
                    do {
                        Status = NtFsControlFile(dirh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_READ_SEND_BUFFER, nullptr, 0, buf, SEND_BUFFER_LEN);
 
                        if (NT_SUCCESS(Status)) {
                            if (!WriteFile(stream, buf, (DWORD)iosb.Information, nullptr, nullptr))
                                throw string_error(IDS_SEND_WRITEFILE_FAILED, GetLastError(), format_message(GetLastError()).c_str());
                        }
                    } while (NT_SUCCESS(Status));
 
                    if (Status != STATUS_END_OF_FILE)
                        throw string_error(IDS_SEND_FSCTL_BTRFS_READ_SEND_BUFFER_FAILED, Status, format_ntstatus(Status).c_str());
 
                    end.length = 0;
                    end.cmd = BTRFS_SEND_CMD_END;
                    end.csum = 0x9dc96c50;
 
                    if (!WriteFile(stream, &end, sizeof(end), nullptr, nullptr))
                        throw string_error(IDS_SEND_WRITEFILE_FAILED, GetLastError(), format_message(GetLastError()).c_str());
 
                    SetEndOfFile(stream);
                } catch (...) {
                    FILE_DISPOSITION_INFO fdi;
 
                    fdi.DeleteFile = true;
 
                    Status = NtSetInformationFile(stream, &iosb, &fdi, sizeof(FILE_DISPOSITION_INFO), FileDispositionInformation);
 
                    CloseHandle(stream);
                    stream = INVALID_HANDLE_VALUE;
 
                    if (!NT_SUCCESS(Status))
                        throw ntstatus_error(Status);
 
                    throw;
                }
 
                CloseHandle(stream);
                stream = INVALID_HANDLE_VALUE;
            } catch (...) {
                CloseHandle(dirh);
                dirh = INVALID_HANDLE_VALUE;
 
                throw;
            }
 
            CloseHandle(dirh);
            dirh = INVALID_HANDLE_VALUE;
        } catch (...) {
            free(buf);
            buf = nullptr;
 
            started = false;
 
            SetDlgItemTextW(hwnd, IDCANCEL, closetext);
            EnableWindow(GetDlgItem(hwnd, IDOK), true);
            EnableWindow(GetDlgItem(hwnd, IDC_STREAM_DEST), true);
            EnableWindow(GetDlgItem(hwnd, IDC_BROWSE), true);
 
            throw;
        }
    } catch (const exception& e) {
        auto msg = utf8_to_utf16(e.what());
 
        SetDlgItemTextW(hwnd, IDC_SEND_STATUS, msg.c_str());
        return 0;
    }
 
 
    free(buf);
    buf = nullptr;
 
    started = false;
 
    SetDlgItemTextW(hwnd, IDCANCEL, closetext);
    EnableWindow(GetDlgItem(hwnd, IDOK), true);
    EnableWindow(GetDlgItem(hwnd, IDC_STREAM_DEST), true);
    EnableWindow(GetDlgItem(hwnd, IDC_BROWSE), true);
 
    wstring success;
 
    load_string(module, IDS_SEND_SUCCESS, success);
 
    SetDlgItemTextW(hwnd, IDC_SEND_STATUS, success.c_str());
 
    return 0;
}

Member Data Documentation

buf

char* BtrfsSend::buf

private

Definition at line 61 of file send.h.

clones

vector<wstring> BtrfsSend::clones

private

Definition at line 62 of file send.h.

Referenced by StartSend(), and Thread().

closetext

WCHAR BtrfsSend::closetext[255]

private

Definition at line 57 of file send.h.

Referenced by SendDlgProc(), and Thread().

dirh

HANDLE BtrfsSend::dirh

private

Definition at line 58 of file send.h.

Referenced by BtrfsSend(), SendDlgProc(), and Thread().

file

WCHAR BtrfsSend::file[MAX_PATH]

private

Definition at line 57 of file send.h.

Referenced by Browse().

hwnd

HWND BtrfsSend::hwnd

private

Definition at line 59 of file send.h.

Referenced by AddClone(), Browse(), and BrowseParent().

incremental

bool BtrfsSend::incremental

private

Definition at line 56 of file send.h.

Referenced by BtrfsSend(), SendDlgProc(), StartSend(), and Thread().

started

bool BtrfsSend::started

private

Definition at line 55 of file send.h.

Referenced by BtrfsSend(), SendDlgProc(), StartSend(), and Thread().

stream

HANDLE BtrfsSend::stream

private

Definition at line 58 of file send.h.

subvol

wstring BtrfsSend::subvol

private

Definition at line 60 of file send.h.

Referenced by AddClone(), BrowseParent(), BtrfsSend(), Open(), and Thread().

thread

HANDLE BtrfsSend::thread

private

Definition at line 58 of file send.h.

Referenced by SendDlgProc(), and StartSend().

---

The documentation for this class was generated from the following files:

• dll/shellext/shellbtrfs/send.h
• dll/shellext/shellbtrfs/send.cpp