recv.cpp File Reference

#include "shellext.h"
#include <windows.h>
#include <strsafe.h>
#include <stddef.h>
#include <sys/stat.h>
#include <iostream>
#include "recv.h"
#include "resource.h"
#include <cpuid.h>
#include <smmintrin.h>

Include dependency graph for recv.cpp:

Go to the source code of this file.

Macros
#define	ALIGN_SIZE   0x08UL
#define	ALIGN_MASK   (ALIGN_SIZE - 1)
#define	CALC_CRC(op, crc, type, buf, len)

Functions
static uint32_t	crc32c_hw (const void *input, ULONG len, uint32_t crc)
static uint32_t	calc_crc32c (uint32_t seed, uint8_t *msg, ULONG msglen)
static __inline uint64_t	unix_time_to_win (BTRFS_TIME *t)
static void	delete_directory (const wstring &dir)
static bool	check_csum (btrfs_send_command *cmd, uint8_t *data)
static DWORD WINAPI	global_recv_thread (LPVOID lpParameter)
static INT_PTR CALLBACK	stub_RecvProgressDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
void CALLBACK	RecvSubvolGUIW (HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
void CALLBACK	RecvSubvolW (HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)

Variables
const string	EA_NTACL = "security.NTACL"
const string	EA_DOSATTRIB = "user.DOSATTRIB"
const string	EA_REPARSE = "user.reparse"
const string	EA_EA = "user.EA"
const string	XATTR_USER = "user."
bool	have_sse42 = false
static const uint32_t	crctable []

Macro Definition Documentation

ALIGN_MASK

#define ALIGN_MASK   (ALIGN_SIZE - 1)

Definition at line 84 of file recv.cpp.

ALIGN_SIZE

#define ALIGN_SIZE   0x08UL

Definition at line 83 of file recv.cpp.

CALC_CRC

#define CALC_CRC	(		op,
			crc,
			type,
			buf,
			len
	)

Value:

do {                                                                  \
    for (; (len) >= sizeof (type); (len) -= (ULONG)sizeof(type), buf += sizeof (type)) { \
        (crc) = (uint32_t)op((crc), *(type *) (buf));                               \
    }                                                                   \
} while(0)

Definition at line 85 of file recv.cpp.

Function Documentation

calc_crc32c()

static uint32_t calc_crc32c ( uint32_t  seed, uint8_t *  msg, ULONG  msglen  )

static

Definition at line 134 of file recv.cpp.

                                                                       {
#ifndef __REACTOS__
    if (have_sse42)
        return crc32c_hw(msg, msglen, seed);
    else {
#endif
        uint32_t rem;
        ULONG i;

        rem = seed;

        for (i = 0; i < msglen; i++) {
            rem = crctable[(rem ^ msg[i]) & 0xff] ^ (rem >> 8);
        }

        return rem;
#ifndef __REACTOS__
    }
#endif
}

Referenced by check_csum().

check_csum()

static bool check_csum ( btrfs_send_command *  cmd, uint8_t *  data  )

static

Definition at line 1257 of file recv.cpp.

                                                               {
    uint32_t crc32 = cmd->csum, calc;

    cmd->csum = 0;

    calc = calc_crc32c(0, (uint8_t*)cmd, sizeof(btrfs_send_command));

    if (cmd->length > 0)
        calc = calc_crc32c(calc, data, cmd->length);

    return calc == crc32 ? true : false;
}

Referenced by BtrfsRecv::do_recv(), and scrub_extent_dup().

crc32c_hw()

static uint32_t crc32c_hw ( const void *  input, ULONG  len, uint32_t  crc  )

static

Definition at line 93 of file recv.cpp.

                                                                      {
    const char* buf = (const char*)input;

    // Annoyingly, the CRC32 intrinsics don't work properly in modern versions of MSVC -
    // it compiles _mm_crc32_u8 as if it was _mm_crc32_u32. And because we're apparently
    // not allowed to use inline asm on amd64, there's no easy way to fix this!

    for (; (len > 0) && ((size_t)buf & ALIGN_MASK); len--, buf++) {
#ifdef _MSC_VER
        crc = crctable[(crc ^ *buf) & 0xff] ^ (crc >> 8);
#else
        crc = _mm_crc32_u8(crc, *buf);
#endif
    }

#ifdef _AMD64_
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4244) // _mm_crc32_u64 wants to return uint64_t(!)
#pragma warning(disable:4242)
#endif
    CALC_CRC(_mm_crc32_u64, crc, uint64_t, buf, len);
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif
    CALC_CRC(_mm_crc32_u32, crc, uint32_t, buf, len);

#ifdef _MSC_VER
    for (; len > 0; len--, buf++) {
        crc = crctable[(crc ^ *buf) & 0xff] ^ (crc >> 8);
    }
#else
    CALC_CRC(_mm_crc32_u16, crc, uint16_t, buf, len);
    CALC_CRC(_mm_crc32_u8, crc, uint8_t, buf, len);
#endif

    return crc;
}

Referenced by calc_crc32c().

delete_directory()

static void delete_directory ( const wstring &  dir )

static

Definition at line 1227 of file recv.cpp.

                                                 {
    WIN32_FIND_DATAW fff;

    fff_handle h = FindFirstFileW((dir + L"*").c_str(), &fff);

    if (h == INVALID_HANDLE_VALUE)
        return;

    do {
        wstring file;

        file = fff.cFileName;

        if (file != L"." && file != L"..") {
            if (fff.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
                SetFileAttributesW((dir + file).c_str(), fff.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);

            if (fff.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
                if (!(fff.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
                    delete_directory(dir + file + L"\\");
                else
                    RemoveDirectoryW((dir + file).c_str());
            } else
                DeleteFileW((dir + file).c_str());
        }
    } while (FindNextFileW(h, &fff));

    RemoveDirectoryW(dir.c_str());
}

Referenced by BtrfsRecv::do_recv().

global_recv_thread()

static DWORD WINAPI global_recv_thread ( LPVOID  lpParameter )

static

Definition at line 1540 of file recv.cpp.

                                                           {
    BtrfsRecv* br = (BtrfsRecv*)lpParameter;

    return br->recv_thread();
}

Referenced by BtrfsRecv::RecvProgressDlgProc().

RecvSubvolGUIW()

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

Definition at line 1645 of file recv.cpp.

                                                                                           {
    try {
        OPENFILENAMEW ofn;
        WCHAR file[MAX_PATH];
        win_handle token;
        TOKEN_PRIVILEGES* tp;
        LUID luid;
        ULONG tplen;

        set_dpi_aware();

        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token))
            throw last_error(GetLastError());

        tplen = offsetof(TOKEN_PRIVILEGES, Privileges[0]) + (3 * sizeof(LUID_AND_ATTRIBUTES));
        tp = (TOKEN_PRIVILEGES*)malloc(tplen);
        if (!tp)
            throw string_error(IDS_OUT_OF_MEMORY);

        tp->PrivilegeCount = 3;

        if (!LookupPrivilegeValueW(nullptr, L"SeManageVolumePrivilege", &luid)) {
            free(tp);
            throw last_error(GetLastError());
        }

        tp->Privileges[0].Luid = luid;
        tp->Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

        if (!LookupPrivilegeValueW(nullptr, L"SeSecurityPrivilege", &luid)) {
            free(tp);
            throw last_error(GetLastError());
        }

        tp->Privileges[1].Luid = luid;
        tp->Privileges[1].Attributes = SE_PRIVILEGE_ENABLED;

        if (!LookupPrivilegeValueW(nullptr, L"SeRestorePrivilege", &luid)) {
            free(tp);
            throw last_error(GetLastError());
        }

        tp->Privileges[2].Luid = luid;
        tp->Privileges[2].Attributes = SE_PRIVILEGE_ENABLED;

        if (!AdjustTokenPrivileges(token, false, tp, tplen, nullptr, nullptr)) {
            free(tp);
            throw last_error(GetLastError());
        }

        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_FILEMUSTEXIST | OFN_HIDEREADONLY;

        if (GetOpenFileNameW(&ofn)) {
            BtrfsRecv recv;

            recv.Open(hwnd, file, lpszCmdLine, false);
        }

        free(tp);
    } catch (const exception& e) {
        error_message(hwnd, e.what());
    }
}

RecvSubvolW()

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

Definition at line 1717 of file recv.cpp.

                                                                                        {
    try {
        vector<wstring> args;

        command_line_to_args(lpszCmdLine, args);

        if (args.size() >= 2) {
            win_handle token;
            TOKEN_PRIVILEGES* tp;
            ULONG tplen;
            LUID luid;

            if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token))
                return;

            tplen = offsetof(TOKEN_PRIVILEGES, Privileges[0]) + (3 * sizeof(LUID_AND_ATTRIBUTES));
            tp = (TOKEN_PRIVILEGES*)malloc(tplen);
            if (!tp)
                return;

            tp->PrivilegeCount = 3;

            if (!LookupPrivilegeValueW(nullptr, L"SeManageVolumePrivilege", &luid)) {
                free(tp);
                return;
            }

            tp->Privileges[0].Luid = luid;
            tp->Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

            if (!LookupPrivilegeValueW(nullptr, L"SeSecurityPrivilege", &luid)) {
                free(tp);
                return;
            }

            tp->Privileges[1].Luid = luid;
            tp->Privileges[1].Attributes = SE_PRIVILEGE_ENABLED;

            if (!LookupPrivilegeValueW(nullptr, L"SeRestorePrivilege", &luid)) {
                free(tp);
                return;
            }

            tp->Privileges[2].Luid = luid;
            tp->Privileges[2].Attributes = SE_PRIVILEGE_ENABLED;

            if (!AdjustTokenPrivileges(token, false, tp, tplen, nullptr, nullptr)) {
                free(tp);
                return;
            }

            free(tp);

            BtrfsRecv br;
            br.Open(nullptr, args[0], args[1], true);
        }
    } catch (const exception& e) {
        cerr << "Error: " << e.what() << endl;
    }
}

stub_RecvProgressDlgProc()

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

static

Definition at line 1598 of file recv.cpp.

                                                                                                        {
    BtrfsRecv* br;

    if (uMsg == WM_INITDIALOG) {
        SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
        br = (BtrfsRecv*)lParam;
    } else {
        br = (BtrfsRecv*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
    }

    if (br)
        return br->RecvProgressDlgProc(hwndDlg, uMsg, wParam, lParam);
    else
        return false;
}

Referenced by BtrfsRecv::Open().

unix_time_to_win()

static __inline uint64_t unix_time_to_win ( BTRFS_TIME *  t )

static

Definition at line 1180 of file recv.cpp.

                                                         {
    return (t->seconds * 10000000) + (t->nanoseconds / 100) + 116444736000000000;
}

Referenced by _Function_class_(), BtrfsRecv::cmd_utimes(), fill_in_file_basic_information(), fill_in_file_network_open_information(), fill_in_file_stat_information(), fill_in_file_stat_lx_information(), and query_dir_item().

Variable Documentation

crctable

const uint32_t crctable[]

static

Definition at line 47 of file recv.cpp.

Referenced by calc_crc32c(), and crc32c_hw().

EA_DOSATTRIB

const string EA_DOSATTRIB = "user.DOSATTRIB"

Definition at line 38 of file recv.cpp.

Referenced by BtrfsRecv::cmd_removexattr(), BtrfsRecv::cmd_setxattr(), flush_fcb(), fsctl_set_xattr(), get_file_attributes(), open_fcb(), rename_file_to_stream(), and rename_stream().

EA_EA

const string EA_EA = "user.EA"

Definition at line 40 of file recv.cpp.

Referenced by BtrfsRecv::cmd_removexattr(), BtrfsRecv::cmd_setxattr(), flush_fcb(), fsctl_set_xattr(), get_ea_len(), open_fcb(), rename_file_to_stream(), and rename_stream().

EA_NTACL

const string EA_NTACL = "security.NTACL"

Definition at line 37 of file recv.cpp.

Referenced by BtrfsRecv::cmd_removexattr(), BtrfsRecv::cmd_setxattr(), fcb_get_sd(), flush_fcb(), fsctl_set_xattr(), and open_fcb().

EA_REPARSE

const string EA_REPARSE = "user.reparse"

Definition at line 39 of file recv.cpp.

Referenced by BtrfsRecv::cmd_setxattr(), flush_fcb(), fsctl_set_xattr(), open_fcb(), rename_file_to_stream(), and rename_stream().

have_sse42

bool have_sse42 = false

Definition at line 44 of file recv.cpp.

Referenced by calc_crc32c(), and BtrfsRecv::Open().

XATTR_USER

const string XATTR_USER = "user."

Definition at line 41 of file recv.cpp.

Referenced by BtrfsRecv::cmd_removexattr(), and BtrfsRecv::cmd_setxattr().