send.cpp File Reference

#include "shellext.h"
#include "send.h"
#include "resource.h"
#include <stddef.h>
#include <shlobj.h>
#include <iostream>

Include dependency graph for send.cpp:

Go to the source code of this file.

Macros
#define	SEND_BUFFER_LEN   1048576

Functions
static DWORD WINAPI	send_thread (LPVOID lpParameter)
static INT_PTR CALLBACK	stub_SendDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
void CALLBACK	SendSubvolGUIW (HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
static void	send_subvol (const wstring &subvol, const wstring &file, const wstring &parent, const vector< wstring > &clones)
void CALLBACK	SendSubvolW (HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)

Macro Definition Documentation

SEND_BUFFER_LEN

#define SEND_BUFFER_LEN   1048576

Definition at line 28 of file send.cpp.

Function Documentation

send_subvol()

static void send_subvol ( const wstring &  subvol, const wstring &  file, const wstring &  parent, const vector< wstring > &  clones  )

static

Definition at line 564 of file send.cpp.

                                                                                                                          {
    char* buf;
    win_handle dirh, stream;
    ULONG i;
    btrfs_send_subvol* bss;
    IO_STATUS_BLOCK iosb;
    NTSTATUS Status;
    btrfs_send_header header;
    btrfs_send_command end;
 
    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 last_error(GetLastError());
 
        stream = CreateFileW(file.c_str(), FILE_WRITE_DATA | DELETE, 0, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
        if (stream == INVALID_HANDLE_VALUE)
            throw last_error(GetLastError());
 
        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 (parent != L"") {
                HANDLE parenth;
 
                parenth = CreateFileW(parent.c_str(), 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 last_error(GetLastError());
 
                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 last_error(le);
                }
 
                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 (bss->parent) CloseHandle(bss->parent);
 
            if (!NT_SUCCESS(Status))
                throw ntstatus_error(Status);
 
            memcpy(header.magic, BTRFS_SEND_MAGIC, sizeof(header.magic));
            header.version = 1;
 
            if (!WriteFile(stream, &header, sizeof(header), nullptr, nullptr))
                throw last_error(GetLastError());
 
            do {
                Status = NtFsControlFile(dirh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_READ_SEND_BUFFER, nullptr, 0, buf, SEND_BUFFER_LEN);
 
                if (NT_SUCCESS(Status))
                    WriteFile(stream, buf, (DWORD)iosb.Information, nullptr, nullptr);
            } while (NT_SUCCESS(Status));
 
            if (Status != STATUS_END_OF_FILE)
                throw ntstatus_error(Status);
 
            end.length = 0;
            end.cmd = BTRFS_SEND_CMD_END;
            end.csum = 0x9dc96c50;
 
            if (!WriteFile(stream, &end, sizeof(end), nullptr, nullptr))
                throw last_error(GetLastError());
 
            SetEndOfFile(stream);
        } catch (...) {
            FILE_DISPOSITION_INFO fdi;
 
            fdi.DeleteFile = true;
 
            Status = NtSetInformationFile(stream, &iosb, &fdi, sizeof(FILE_DISPOSITION_INFO), FileDispositionInformation);
            if (!NT_SUCCESS(Status))
                throw ntstatus_error(Status);
 
            throw;
        }
    } catch (...) {
        free(buf);
        throw;
    }
 
    free(buf);
}

Referenced by fsctl_request(), and SendSubvolW().

send_thread()

static DWORD WINAPI send_thread ( LPVOID  lpParameter )

static

Definition at line 227 of file send.cpp.

                                                    {
    BtrfsSend* bs = (BtrfsSend*)lpParameter;
 
    return bs->Thread();
}

Referenced by send_subvol(), and BtrfsSend::StartSend().

SendSubvolGUIW()

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

Definition at line 535 of file send.cpp.

                                                                                                      {
    try {
        win_handle token;
        TOKEN_PRIVILEGES tp;
        LUID luid;
 
        set_dpi_aware();
 
        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token))
            throw last_error(GetLastError());
 
        if (!LookupPrivilegeValueW(nullptr, L"SeManageVolumePrivilege", &luid))
            throw last_error(GetLastError());
 
        tp.PrivilegeCount = 1;
        tp.Privileges[0].Luid = luid;
        tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 
        if (!AdjustTokenPrivileges(token, false, &tp, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr))
            throw last_error(GetLastError());
 
        BtrfsSend bs;
 
        bs.Open(hwnd, lpszCmdLine);
    } catch (const exception& e) {
        error_message(hwnd, e.what());
    }
}

SendSubvolW()

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

Definition at line 677 of file send.cpp.

                                                                                                   {
    vector<wstring> args;
    wstring subvol = L"", parent = L"", file = L"";
    vector<wstring> clones;
 
    command_line_to_args(lpszCmdLine, args);
 
    if (args.size() >= 2) {
        TOKEN_PRIVILEGES tp;
        LUID luid;
 
        {
            win_handle token;
 
            if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token))
                return;
 
            if (!LookupPrivilegeValueW(nullptr, L"SeManageVolumePrivilege", &luid))
                return;
 
            tp.PrivilegeCount = 1;
            tp.Privileges[0].Luid = luid;
            tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 
            if (!AdjustTokenPrivileges(token, false, &tp, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr))
                return;
        }
 
        for (unsigned int i = 0; i < args.size(); i++) {
            if (args[i][0] == '-') {
                if (args[i][2] == 0 && i < args.size() - 1) {
                    if (args[i][1] == 'p') {
                        parent = args[i+1];
                        i++;
                    } else if (args[i][1] == 'c') {
                        clones.push_back(args[i+1]);
                        i++;
                    }
                }
            } else {
                if (subvol == L"")
                    subvol = args[i];
                else if (file == L"")
                    file = args[i];
            }
        }
 
        if (subvol != L"" && file != L"") {
            try {
                send_subvol(subvol, file, parent, clones);
            } catch (const exception& e) {
                cerr << "Error: " << e.what() << endl;
            }
        }
    }
}

stub_SendDlgProc()

static INT_PTR CALLBACK stub_SendDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 513 of file send.cpp.

                                                                                                {
    BtrfsSend* bs;
 
    if (uMsg == WM_INITDIALOG) {
        SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
        bs = (BtrfsSend*)lParam;
    } else
        bs = (BtrfsSend*)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    if (bs)
        return bs->SendDlgProc(hwndDlg, uMsg, wParam, lParam);
    else
        return false;
}

Referenced by BtrfsSend::Open().