ReactOS 0.4.15-dev-6047-gb29e82d
BtrfsRecv Class Reference

#include <recv.h>

Collaboration diagram for BtrfsRecv:

Public Member Functions

 BtrfsRecv ()
 
virtual ~BtrfsRecv ()
 
void Open (HWND hwnd, const wstring &file, const wstring &path, bool quiet)
 
DWORD recv_thread ()
 
INT_PTR CALLBACK RecvProgressDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 

Private Member Functions

void cmd_subvol (HWND hwnd, btrfs_send_command *cmd, uint8_t *data, const win_handle &parent)
 
void cmd_snapshot (HWND hwnd, btrfs_send_command *cmd, uint8_t *data, const win_handle &parent)
 
void cmd_mkfile (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_rename (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_link (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_unlink (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_rmdir (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_setxattr (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_removexattr (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_write (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_clone (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_truncate (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_chmod (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_chown (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void cmd_utimes (HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
 
void add_cache_entry (BTRFS_UUID *uuid, uint64_t transid, const wstring &path)
 
bool find_tlv (uint8_t *data, ULONG datalen, uint16_t type, void **value, ULONG *len)
 
void do_recv (const win_handle &f, uint64_t *pos, uint64_t size, const win_handle &parent)
 

Private Attributes

HANDLE dir
 
HANDLE master
 
HANDLE thread
 
HANDLE lastwritefile
 
HWND hwnd
 
wstring streamfile
 
wstring dirpath
 
wstring subvolpath
 
wstring lastwritepath
 
DWORD lastwriteatt
 
ULONG num_received
 
uint64_t stransid
 
BTRFS_UUID subvol_uuid
 
bool running
 
bool cancelling
 
vector< subvol_cachecache
 

Detailed Description

Definition at line 35 of file recv.h.

Constructor & Destructor Documentation

◆ BtrfsRecv()

BtrfsRecv::BtrfsRecv ( )
inline

Definition at line 37 of file recv.h.

37 {
38 thread = nullptr;
41 running = false;
42 cancelling = false;
43 stransid = 0;
44 num_received = 0;
45 hwnd = nullptr;
46 cache.clear();
47 }
uint64_t stransid
Definition: recv.h:82
HANDLE dir
Definition: recv.h:77
bool running
Definition: recv.h:84
HANDLE thread
Definition: recv.h:77
HANDLE master
Definition: recv.h:77
ULONG num_received
Definition: recv.h:81
bool cancelling
Definition: recv.h:84
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
Definition: cache.c:49
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

◆ ~BtrfsRecv()

virtual BtrfsRecv::~BtrfsRecv ( )
inlinevirtual

Definition at line 49 of file recv.h.

49 {
50 cache.clear();
51 }

Member Function Documentation

◆ add_cache_entry()

void BtrfsRecv::add_cache_entry ( BTRFS_UUID uuid,
uint64_t  transid,
const wstring &  path 
)
private

Definition at line 144 of file recv.cpp.

144 {
145 subvol_cache sc;
146
147 sc.uuid = *uuid;
148 sc.transid = transid;
149 sc.path = path;
150
151 cache.push_back(sc);
152}
Definition: msctf.idl:511
BTRFS_UUID uuid
Definition: recv.h:30
uint64_t transid
Definition: recv.h:31
wstring path
Definition: recv.h:32

Referenced by cmd_clone(), cmd_snapshot(), and cmd_subvol().

◆ cmd_chmod()

void BtrfsRecv::cmd_chmod ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 977 of file recv.cpp.

977 {
979 uint32_t* mode;
980 ULONG modelen;
981 wstring pathu;
985
986 {
987 char* path;
988 ULONG pathlen;
989
990 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
992
993 pathu = utf8_to_utf16(string(path, pathlen));
994 }
995
996 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_MODE, (void**)&mode, &modelen))
998
999 if (modelen < sizeof(uint32_t))
1000 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"mode", modelen, sizeof(uint32_t));
1001
1002 h = CreateFileW((subvolpath + pathu).c_str(), WRITE_DAC, 0, nullptr, OPEN_EXISTING,
1004 if (h == INVALID_HANDLE_VALUE)
1006
1007 memset(&bsii, 0, sizeof(btrfs_set_inode_info));
1008
1009 bsii.mode_changed = true;
1010 bsii.st_mode = *mode;
1011
1012 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_INODE_INFO, &bsii, sizeof(btrfs_set_inode_info), nullptr, 0);
1013 if (!NT_SUCCESS(Status))
1015}
LONG NTSTATUS
Definition: precomp.h:26
#define FSCTL_BTRFS_SET_INODE_INFO
Definition: btrfsioctl.h:11
bool find_tlv(uint8_t *data, ULONG datalen, uint16_t type, void **value, ULONG *len)
Definition: recv.cpp:42
wstring subvolpath
Definition: recv.h:79
UINT32 uint32_t
Definition: types.h:75
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
wstring format_ntstatus(NTSTATUS Status)
Definition: main.cpp:184
wstring utf8_to_utf16(const string_view &utf8)
Definition: main.cpp:734
#define IDS_RECV_SETINODEINFO_FAILED
Definition: resource.h:150
#define IDS_RECV_CANT_OPEN_FILE
Definition: resource.h:132
#define IDS_RECV_SHORT_PARAM
Definition: resource.h:140
#define IDS_RECV_MISSING_PARAM
Definition: resource.h:139
#define OPEN_EXISTING
Definition: compat.h:775
#define CreateFileW
Definition: compat.h:741
#define BTRFS_SEND_TLV_PATH
Definition: btrfs.h:582
#define BTRFS_SEND_TLV_MODE
Definition: btrfs.h:572
#define FILE_OPEN_REPARSE_POINT
Definition: from_kernel.h:46
Status
Definition: gdiplustypes.h:25
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLenum mode
Definition: glext.h:6217
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
format_message(j_common_ptr cinfo, char *buffer)
Definition: jerror.c:158
#define FILE_FLAG_POSIX_SEMANTICS
Definition: disk.h:40
#define FILE_FLAG_BACKUP_SEMANTICS
Definition: disk.h:41
static PIO_STATUS_BLOCK iosb
Definition: file.c:98
#define WRITE_DAC
Definition: nt_native.h:59
NTSYSAPI NTSTATUS NTAPI NtFsControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
#define L(x)
Definition: ntvdm.h:50
#define memset(x, y, z)
Definition: compat.h:39
#define funcname
Definition: shellext.h:96
Definition: ftp_var.h:139
uint32_t ULONG
Definition: typedefs.h:59
DWORD WINAPI GetLastError(void)
Definition: except.c:1040

Referenced by do_recv().

◆ cmd_chown()

void BtrfsRecv::cmd_chown ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 1017 of file recv.cpp.

1017 {
1018 win_handle h;
1019 uint32_t *uid, *gid;
1020 ULONG uidlen, gidlen;
1021 wstring pathu;
1023
1024 {
1025 char* path;
1026 ULONG pathlen;
1027
1028 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
1030
1031 pathu = utf8_to_utf16(string(path, pathlen));
1032 }
1033
1034 h = CreateFileW((subvolpath + pathu).c_str(), FILE_WRITE_ATTRIBUTES | WRITE_OWNER | WRITE_DAC, 0, nullptr, OPEN_EXISTING,
1036 if (h == INVALID_HANDLE_VALUE)
1038
1039 memset(&bsii, 0, sizeof(btrfs_set_inode_info));
1040
1041 if (find_tlv(data, cmd->length, BTRFS_SEND_TLV_UID, (void**)&uid, &uidlen)) {
1042 if (uidlen < sizeof(uint32_t))
1043 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"uid", uidlen, sizeof(uint32_t));
1044
1045 bsii.uid_changed = true;
1046 bsii.st_uid = *uid;
1047 }
1048
1049 if (find_tlv(data, cmd->length, BTRFS_SEND_TLV_GID, (void**)&gid, &gidlen)) {
1050 if (gidlen < sizeof(uint32_t))
1051 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"gid", gidlen, sizeof(uint32_t));
1052
1053 bsii.gid_changed = true;
1054 bsii.st_gid = *gid;
1055 }
1056
1057 if (bsii.uid_changed || bsii.gid_changed) {
1060
1061 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_INODE_INFO, &bsii, sizeof(btrfs_set_inode_info), nullptr, 0);
1062 if (!NT_SUCCESS(Status))
1064 }
1065}
#define BTRFS_SEND_TLV_GID
Definition: btrfs.h:574
#define BTRFS_SEND_TLV_UID
Definition: btrfs.h:573
#define FILE_WRITE_ATTRIBUTES
Definition: nt_native.h:649
#define WRITE_OWNER
Definition: nt_native.h:60

Referenced by do_recv().

◆ cmd_clone()

void BtrfsRecv::cmd_clone ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 788 of file recv.cpp.

788 {
789 uint64_t *offset, *cloneoffset, *clonetransid, *clonelen;
790 BTRFS_UUID* cloneuuid;
791 ULONG i, offsetlen, cloneoffsetlen, cloneuuidlen, clonetransidlen, clonelenlen;
792 wstring pathu, clonepathu, clonepar;
796 WCHAR cloneparw[MAX_PATH];
798 LARGE_INTEGER filesize;
799 bool found = false;
800
801 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_OFFSET, (void**)&offset, &offsetlen))
803
804 if (offsetlen < sizeof(uint64_t))
805 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"offset", offsetlen, sizeof(uint64_t));
806
807 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_CLONE_LENGTH, (void**)&clonelen, &clonelenlen))
808 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"clone_len");
809
810 if (clonelenlen < sizeof(uint64_t))
811 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"clone_len", clonelenlen, sizeof(uint64_t));
812
813 {
814 char* path;
815 ULONG pathlen;
816
817 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
819
820 pathu = utf8_to_utf16(string(path, pathlen));
821 }
822
823 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_CLONE_UUID, (void**)&cloneuuid, &cloneuuidlen))
824 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"clone_uuid");
825
826 if (cloneuuidlen < sizeof(BTRFS_UUID))
827 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"clone_uuid", cloneuuidlen, sizeof(BTRFS_UUID));
828
829 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_CLONE_CTRANSID, (void**)&clonetransid, &clonetransidlen))
830 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"clone_ctransid");
831
832 if (clonetransidlen < sizeof(uint64_t))
833 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"clone_ctransid", clonetransidlen, sizeof(uint64_t));
834
835 {
836 char* clonepath;
837 ULONG clonepathlen;
838
839 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_CLONE_PATH, (void**)&clonepath, &clonepathlen))
840 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"clone_path");
841
842 clonepathu = utf8_to_utf16(string(clonepath, clonepathlen));
843 }
844
845 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_CLONE_OFFSET, (void**)&cloneoffset, &cloneoffsetlen))
846 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"clone_offset");
847
848 if (cloneoffsetlen < sizeof(uint64_t))
849 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"clone_offset", cloneoffsetlen, sizeof(uint64_t));
850
851 for (i = 0; i < cache.size(); i++) {
852 if (!memcmp(cloneuuid, &cache[i].uuid, sizeof(BTRFS_UUID)) && *clonetransid == cache[i].transid) {
853 clonepar = cache[i].path;
854 found = true;
855 break;
856 }
857 }
858
859 if (!found) {
860 WCHAR volpathw[MAX_PATH];
861
862 bfs.uuid = *cloneuuid;
863 bfs.ctransid = *clonetransid;
864
865 Status = NtFsControlFile(dir, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_FIND_SUBVOL, &bfs, sizeof(btrfs_find_subvol),
866 cloneparw, sizeof(cloneparw));
869 else if (!NT_SUCCESS(Status))
871
872 if (!GetVolumePathNameW(dirpath.c_str(), volpathw, (sizeof(volpathw) / sizeof(WCHAR)) - 1))
874
875 clonepar = volpathw;
876 if (clonepar.substr(clonepar.length() - 1) == L"\\")
877 clonepar = clonepar.substr(0, clonepar.length() - 1);
878
879 clonepar += cloneparw;
880 clonepar += L"\\";
881
882 add_cache_entry(cloneuuid, *clonetransid, clonepar);
883 }
884
885 {
889 throw string_error(IDS_RECV_CANT_OPEN_FILE, funcname, (clonepar + clonepathu).c_str(), GetLastError(), format_message(GetLastError()).c_str());
890
895
896 if (!GetFileSizeEx(dest, &filesize))
898
899 if ((uint64_t)filesize.QuadPart < *offset + *clonelen) {
900 LARGE_INTEGER sizeli;
901
902 sizeli.QuadPart = *offset + *clonelen;
903
906
907 if (!SetEndOfFile(dest))
909 }
910
911 ded.FileHandle = src;
912 ded.SourceFileOffset.QuadPart = *cloneoffset;
914 ded.ByteCount.QuadPart = *clonelen;
915
916 Status = NtFsControlFile(dest, nullptr, nullptr, nullptr, &iosb, FSCTL_DUPLICATE_EXTENTS_TO_FILE, &ded, sizeof(DUPLICATE_EXTENTS_DATA),
917 nullptr, 0);
918 if (!NT_SUCCESS(Status))
920 }
921}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define FSCTL_BTRFS_FIND_SUBVOL
Definition: btrfsioctl.h:35
void add_cache_entry(BTRFS_UUID *uuid, uint64_t transid, const wstring &path)
Definition: recv.cpp:144
wstring dirpath
Definition: recv.h:79
UINT64 uint64_t
Definition: types.h:77
#define IDS_RECV_DUPLICATE_EXTENTS_FAILED
Definition: resource.h:174
#define IDS_RECV_SETFILEPOINTER_FAILED
Definition: resource.h:144
#define IDS_RECV_CANT_FIND_CLONE_SUBVOL
Definition: resource.h:172
#define IDS_RECV_SETENDOFFILE_FAILED
Definition: resource.h:147
#define IDS_RECV_GETVOLUMEPATHNAME_FAILED
Definition: resource.h:169
#define IDS_RECV_FIND_SUBVOL_FAILED
Definition: resource.h:167
#define IDS_RECV_GETFILESIZEEX_FAILED
Definition: resource.h:173
#define FILE_BEGIN
Definition: compat.h:761
#define INVALID_SET_FILE_POINTER
Definition: compat.h:732
#define SetFilePointer
Definition: compat.h:743
#define MAX_PATH
Definition: compat.h:34
#define GetFileSizeEx
Definition: compat.h:757
#define FILE_SHARE_READ
Definition: compat.h:136
BOOL WINAPI SetEndOfFile(HANDLE hFile)
Definition: fileinfo.c:1004
BOOL WINAPI GetVolumePathNameW(IN LPCWSTR lpszFileName, IN LPWSTR lpszVolumePathName, IN DWORD cchBufferLength)
Definition: volume.c:815
#define BTRFS_SEND_TLV_CLONE_UUID
Definition: btrfs.h:587
#define BTRFS_SEND_TLV_CLONE_OFFSET
Definition: btrfs.h:590
#define BTRFS_SEND_TLV_CLONE_PATH
Definition: btrfs.h:589
#define BTRFS_SEND_TLV_CLONE_LENGTH
Definition: btrfs.h:591
#define BTRFS_SEND_TLV_OFFSET
Definition: btrfs.h:585
#define BTRFS_SEND_TLV_CLONE_CTRANSID
Definition: btrfs.h:588
GLenum src
Definition: glext.h:6340
GLintptr offset
Definition: glext.h:5920
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static char * dest
Definition: rtl.c:135
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define FILE_WRITE_DATA
Definition: nt_native.h:631
#define FILE_READ_DATA
Definition: nt_native.h:628
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
#define FSCTL_DUPLICATE_EXTENTS_TO_FILE
Definition: shellext.h:205
#define STATUS_NOT_FOUND
Definition: shellext.h:72
LARGE_INTEGER ByteCount
Definition: shellext.h:202
LARGE_INTEGER SourceFileOffset
Definition: shellext.h:200
LARGE_INTEGER TargetFileOffset
Definition: shellext.h:201
BTRFS_UUID uuid
Definition: btrfsioctl.h:263
uint64_t ctransid
Definition: btrfsioctl.h:264
LONGLONG QuadPart
Definition: typedefs.h:114
ULONG LowPart
Definition: typedefs.h:106
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by do_recv().

◆ cmd_link()

void BtrfsRecv::cmd_link ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 454 of file recv.cpp.

454 {
455 wstring pathu, path_linku;
456
457 {
458 char* path;
460
461 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &path_len))
463
464 pathu = utf8_to_utf16(string(path, path_len));
465 }
466
467 {
468 char* path_link;
469 ULONG path_link_len;
470
471 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH_LINK, (void**)&path_link, &path_link_len))
472 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"path_link");
473
474 path_linku = utf8_to_utf16(string(path_link, path_link_len));
475 }
476
477 if (!CreateHardLinkW((subvolpath + pathu).c_str(), (subvolpath + path_linku).c_str(), nullptr))
478 throw string_error(IDS_RECV_CREATEHARDLINK_FAILED, pathu.c_str(), path_linku.c_str(), GetLastError(), format_message(GetLastError()).c_str());
479}
#define IDS_RECV_CREATEHARDLINK_FAILED
Definition: resource.h:146
#define BTRFS_SEND_TLV_PATH_LINK
Definition: btrfs.h:584
static DWORD path_len
Definition: batch.c:31

Referenced by do_recv().

◆ cmd_mkfile()

void BtrfsRecv::cmd_mkfile ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 277 of file recv.cpp.

277 {
278 uint64_t *inode, *rdev = nullptr, *mode = nullptr;
279 ULONG inodelen;
282 btrfs_mknod* bmn;
283 wstring nameu, pathlinku;
284
285 {
286 char* name;
288
289 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&name, &namelen))
291
292 nameu = utf8_to_utf16(string(name, namelen));
293 }
294
295 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_INODE, (void**)&inode, &inodelen))
297
298 if (inodelen < sizeof(uint64_t))
299 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"inode", inodelen, sizeof(uint64_t));
300
302 ULONG rdevlen, modelen;
303
304 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_RDEV, (void**)&rdev, &rdevlen))
306
307 if (rdevlen < sizeof(uint64_t))
308 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"rdev", rdev, sizeof(uint64_t));
309
310 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_MODE, (void**)&mode, &modelen))
312
313 if (modelen < sizeof(uint64_t))
314 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"mode", modelen, sizeof(uint64_t));
315 } else if (cmd->cmd == BTRFS_SEND_CMD_SYMLINK) {
316 char* pathlink;
317 ULONG pathlinklen;
318
319 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH_LINK, (void**)&pathlink, &pathlinklen))
320 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"path_link");
321
322 pathlinku = utf8_to_utf16(string(pathlink, pathlinklen));
323 }
324
325 size_t bmnsize = sizeof(btrfs_mknod) - sizeof(WCHAR) + (nameu.length() * sizeof(WCHAR));
326 bmn = (btrfs_mknod*)malloc(bmnsize);
327
328 bmn->inode = *inode;
329
330 if (cmd->cmd == BTRFS_SEND_CMD_MKDIR)
332 else if (cmd->cmd == BTRFS_SEND_CMD_MKNOD)
334 else if (cmd->cmd == BTRFS_SEND_CMD_MKFIFO)
335 bmn->type = BTRFS_TYPE_FIFO;
336 else if (cmd->cmd == BTRFS_SEND_CMD_MKSOCK)
337 bmn->type = BTRFS_TYPE_SOCKET;
338 else
339 bmn->type = BTRFS_TYPE_FILE;
340
341 bmn->st_rdev = rdev ? *rdev : 0;
342 bmn->namelen = (uint16_t)(nameu.length() * sizeof(WCHAR));
343 memcpy(bmn->name, nameu.c_str(), bmn->namelen);
344
345 Status = NtFsControlFile(dir, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_MKNOD, bmn, (ULONG)bmnsize, nullptr, 0);
346 if (!NT_SUCCESS(Status)) {
347 free(bmn);
349 }
350
351 free(bmn);
352
353 if (cmd->cmd == BTRFS_SEND_CMD_SYMLINK) {
356
357 size_t rdblen = offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer[0]) + (2 * pathlinku.length() * sizeof(WCHAR));
358
359 if (rdblen >= 0x10000)
361
362 rdb = (REPARSE_DATA_BUFFER*)malloc(rdblen);
363
365 rdb->ReparseDataLength = (uint16_t)(rdblen - offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer));
366 rdb->Reserved = 0;
367 rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset = 0;
368 rdb->SymbolicLinkReparseBuffer.SubstituteNameLength = (uint16_t)(pathlinku.length() * sizeof(WCHAR));
369 rdb->SymbolicLinkReparseBuffer.PrintNameOffset = (uint16_t)(pathlinku.length() * sizeof(WCHAR));
370 rdb->SymbolicLinkReparseBuffer.PrintNameLength = (uint16_t)(pathlinku.length() * sizeof(WCHAR));
372
373 memcpy(rdb->SymbolicLinkReparseBuffer.PathBuffer, pathlinku.c_str(), rdb->SymbolicLinkReparseBuffer.SubstituteNameLength);
374 memcpy(rdb->SymbolicLinkReparseBuffer.PathBuffer + (rdb->SymbolicLinkReparseBuffer.SubstituteNameLength / sizeof(WCHAR)),
375 pathlinku.c_str(), rdb->SymbolicLinkReparseBuffer.PrintNameLength);
376
379 if (h == INVALID_HANDLE_VALUE) {
380 free(rdb);
382 }
383
384 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_SET_REPARSE_POINT, rdb, (ULONG)rdblen, nullptr, 0);
385 if (!NT_SUCCESS(Status)) {
386 free(rdb);
388 }
389
390 free(rdb);
391
392 memset(&bsii, 0, sizeof(btrfs_set_inode_info));
393
394 bsii.mode_changed = true;
395 bsii.st_mode = 0777;
396
397 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_INODE_INFO, &bsii, sizeof(btrfs_set_inode_info), nullptr, 0);
398 if (!NT_SUCCESS(Status))
400 } else if (cmd->cmd == BTRFS_SEND_CMD_MKNOD || cmd->cmd == BTRFS_SEND_CMD_MKFIFO || cmd->cmd == BTRFS_SEND_CMD_MKSOCK) {
401 uint64_t* mode;
402 ULONG modelen;
403
404 if (find_tlv(data, cmd->length, BTRFS_SEND_TLV_MODE, (void**)&mode, &modelen)) {
406
407 if (modelen < sizeof(uint64_t))
408 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"mode", modelen, sizeof(uint64_t));
409
412 if (h == INVALID_HANDLE_VALUE)
414
415 memset(&bsii, 0, sizeof(btrfs_set_inode_info));
416
417 bsii.mode_changed = true;
418 bsii.st_mode = (uint32_t)*mode;
419
420 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_INODE_INFO, &bsii, sizeof(btrfs_set_inode_info), nullptr, 0);
421 if (!NT_SUCCESS(Status))
423 }
424 }
425}
#define FSCTL_BTRFS_MKNOD
Definition: btrfsioctl.h:30
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define IDS_RECV_SET_REPARSE_POINT_FAILED
Definition: resource.h:142
#define IDS_RECV_MKNOD_FAILED
Definition: resource.h:141
#define IDS_RECV_PATH_TOO_LONG
Definition: resource.h:208
#define BTRFS_SEND_CMD_MKFIFO
Definition: btrfs.h:550
#define BTRFS_SEND_CMD_MKNOD
Definition: btrfs.h:549
#define BTRFS_SEND_CMD_SYMLINK
Definition: btrfs.h:552
#define BTRFS_SEND_CMD_MKSOCK
Definition: btrfs.h:551
#define BTRFS_SEND_TLV_INODE
Definition: btrfs.h:570
#define BTRFS_SEND_TLV_RDEV
Definition: btrfs.h:575
#define BTRFS_SEND_CMD_MKDIR
Definition: btrfs.h:548
#define S_IFCHR
Definition: ext2fs.h:364
GLint namelen
Definition: glext.h:7232
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define uint32_t
Definition: nsiface.idl:61
#define uint16_t
Definition: nsiface.idl:60
#define GENERIC_WRITE
Definition: nt_native.h:90
#define FSCTL_SET_REPARSE_POINT
Definition: winioctl.h:98
#define offsetof(TYPE, MEMBER)
#define BTRFS_TYPE_FILE
Definition: shellext.h:85
#define SYMLINK_FLAG_RELATIVE
Definition: shellext.h:193
#define BTRFS_TYPE_DIRECTORY
Definition: shellext.h:86
#define BTRFS_TYPE_SOCKET
Definition: shellext.h:90
#define BTRFS_TYPE_FIFO
Definition: shellext.h:89
#define BTRFS_TYPE_CHARDEV
Definition: shellext.h:87
#define BTRFS_TYPE_BLOCKDEV
Definition: shellext.h:88
WCHAR PathBuffer[1]
Definition: shellext.h:176
struct _REPARSE_DATA_BUFFER::@306::@308 SymbolicLinkReparseBuffer
USHORT ReparseDataLength
Definition: shellext.h:166
uint64_t inode
Definition: btrfsioctl.h:237
WCHAR name[1]
Definition: btrfsioctl.h:241
uint16_t namelen
Definition: btrfsioctl.h:240
uint64_t st_rdev
Definition: btrfsioctl.h:239
uint8_t type
Definition: btrfsioctl.h:238
Definition: fs.h:78
Definition: name.c:39
#define IO_REPARSE_TAG_SYMLINK
Definition: iotypes.h:7240

Referenced by do_recv().

◆ cmd_removexattr()

void BtrfsRecv::cmd_removexattr ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 631 of file recv.cpp.

631 {
632 wstring pathu;
633 string xattrname;
634
635 {
636 char* path;
637 ULONG pathlen;
638
639 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
641
642 pathu = utf8_to_utf16(string(path, pathlen));
643 }
644
645 {
646 char* xattrnamebuf;
647 ULONG xattrnamelen;
648
649 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_XATTR_NAME, (void**)&xattrnamebuf, &xattrnamelen))
650 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"xattr_name");
651
652 xattrname = string(xattrnamebuf, xattrnamelen);
653 }
654
655 if (xattrname.length() > XATTR_USER.length() && xattrname.substr(0, XATTR_USER.length()) == XATTR_USER && xattrname != EA_DOSATTRIB && xattrname != EA_EA) { // deleting stream
656 ULONG att;
657
658 auto streamname = utf8_to_utf16(xattrname);
659
660 streamname = streamname.substr(XATTR_USER.length());
661
662 att = GetFileAttributesW((subvolpath + pathu).c_str());
663 if (att == INVALID_FILE_ATTRIBUTES)
665
666 if (att & FILE_ATTRIBUTE_READONLY) {
667 if (!SetFileAttributesW((subvolpath + pathu).c_str(), att & ~FILE_ATTRIBUTE_READONLY))
669 }
670
671 if (!DeleteFileW((subvolpath + pathu + L":" + streamname).c_str()))
672 throw string_error(IDS_RECV_DELETEFILE_FAILED, (pathu + L":" + streamname).c_str(), GetLastError(), format_message(GetLastError()).c_str());
673
674 if (att & FILE_ATTRIBUTE_READONLY) {
675 if (!SetFileAttributesW((subvolpath + pathu).c_str(), att))
677 }
678 } else {
682 btrfs_set_xattr* bsxa;
683
684 if (xattrname == EA_NTACL)
685 perms |= WRITE_DAC | WRITE_OWNER;
686 else if (xattrname == EA_EA)
687 perms |= FILE_WRITE_EA;
688
691 if (h == INVALID_HANDLE_VALUE)
693
694 size_t bsxalen = offsetof(btrfs_set_xattr, data[0]) + xattrname.length();
695 bsxa = (btrfs_set_xattr*)malloc(bsxalen);
696 if (!bsxa)
698
699 bsxa->namelen = (uint16_t)(xattrname.length());
700 bsxa->valuelen = 0;
701 memcpy(bsxa->data, xattrname.c_str(), xattrname.length());
702
703 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_XATTR, bsxa, (ULONG)bsxalen, nullptr, 0);
704 if (!NT_SUCCESS(Status)) {
705 free(bsxa);
707 }
708
709 free(bsxa);
710 }
711}
#define IDS_OUT_OF_MEMORY
Definition: resource.h:5
#define EA_EA
Definition: btrfs_drv.h:102
#define EA_NTACL
Definition: btrfs_drv.h:93
#define EA_DOSATTRIB
Definition: btrfs_drv.h:96
#define FSCTL_BTRFS_SET_XATTR
Definition: btrfsioctl.h:33
_Self substr(size_type __pos=0, size_type __n=npos) const
Definition: _string.h:1022
const _CharT * c_str() const
Definition: _string.h:949
size_type length() const
Definition: _string.h:401
#define IDS_RECV_SETXATTR_FAILED
Definition: resource.h:161
#define IDS_RECV_GETFILEATTRIBUTES_FAILED
Definition: resource.h:154
#define IDS_RECV_SETFILEATTRIBUTES_FAILED
Definition: resource.h:153
#define IDS_RECV_DELETEFILE_FAILED
Definition: resource.h:170
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:652
BOOL WINAPI SetFileAttributesW(LPCWSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:794
#define BTRFS_SEND_TLV_XATTR_NAME
Definition: btrfs.h:580
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
#define FILE_WRITE_EA
Definition: nt_native.h:640
const string XATTR_USER
Definition: recv.cpp:40
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23

Referenced by do_recv().

◆ cmd_rename()

void BtrfsRecv::cmd_rename ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 427 of file recv.cpp.

427 {
428 wstring pathu, path_tou;
429
430 {
431 char* path;
433
434 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &path_len))
436
437 pathu = utf8_to_utf16(string(path, path_len));
438 }
439
440 {
441 char* path_to;
442 ULONG path_to_len;
443
444 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH_TO, (void**)&path_to, &path_to_len))
446
447 path_tou = utf8_to_utf16(string(path_to, path_to_len));
448 }
449
450 if (!MoveFileW((subvolpath + pathu).c_str(), (subvolpath + path_tou).c_str()))
451 throw string_error(IDS_RECV_MOVEFILE_FAILED, pathu.c_str(), path_tou.c_str(), GetLastError(), format_message(GetLastError()).c_str());
452}
#define IDS_RECV_MOVEFILE_FAILED
Definition: resource.h:143
BOOL WINAPI MoveFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName)
Definition: move.c:1104
#define BTRFS_SEND_TLV_PATH_TO
Definition: btrfs.h:583

Referenced by do_recv().

◆ cmd_rmdir()

void BtrfsRecv::cmd_rmdir ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 508 of file recv.cpp.

508 {
509 wstring pathu;
510 ULONG att;
511
512 {
513 char* path;
514 ULONG pathlen;
515
516 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
518
519 pathu = utf8_to_utf16(string(path, pathlen));
520 }
521
522 att = GetFileAttributesW((subvolpath + pathu).c_str());
523 if (att == INVALID_FILE_ATTRIBUTES)
525
526 if (att & FILE_ATTRIBUTE_READONLY) {
527 if (!SetFileAttributesW((subvolpath + pathu).c_str(), att & ~FILE_ATTRIBUTE_READONLY))
529 }
530
531 if (!RemoveDirectoryW((subvolpath + pathu).c_str()))
533}
#define IDS_RECV_REMOVEDIRECTORY_FAILED
Definition: resource.h:171
BOOL WINAPI RemoveDirectoryW(IN LPCWSTR lpPathName)
Definition: dir.c:732

Referenced by do_recv().

◆ cmd_setxattr()

void BtrfsRecv::cmd_setxattr ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 535 of file recv.cpp.

535 {
536 string xattrname;
537 uint8_t* xattrdata;
538 ULONG xattrdatalen;
539 wstring pathu;
540
541 {
542 char* path;
543 ULONG pathlen;
544
545 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
547
548 pathu = utf8_to_utf16(string(path, pathlen));
549 }
550
551 {
552 char* xattrnamebuf;
553 ULONG xattrnamelen;
554
555 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_XATTR_NAME, (void**)&xattrnamebuf, &xattrnamelen))
556 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"xattr_name");
557
558 xattrname = string(xattrnamebuf, xattrnamelen);
559 }
560
561 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_XATTR_DATA, (void**)&xattrdata, &xattrdatalen))
562 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"xattr_data");
563
564 if (xattrname.length() > XATTR_USER.length() && xattrname.substr(0, XATTR_USER.length()) == XATTR_USER &&
565 xattrname != EA_DOSATTRIB && xattrname != EA_EA && xattrname != EA_REPARSE) {
566 ULONG att;
567
568 auto streamname = utf8_to_utf16(xattrname);
569
570 att = GetFileAttributesW((subvolpath + pathu).c_str());
571 if (att == INVALID_FILE_ATTRIBUTES)
573
574 if (att & FILE_ATTRIBUTE_READONLY) {
575 if (!SetFileAttributesW((subvolpath + pathu).c_str(), att & ~FILE_ATTRIBUTE_READONLY))
577 }
578
579 streamname = streamname.substr(XATTR_USER.length());
580
581 win_handle h = CreateFileW((subvolpath + pathu + L":" + streamname).c_str(), GENERIC_WRITE, 0,
582 nullptr, CREATE_ALWAYS, FILE_FLAG_POSIX_SEMANTICS, nullptr);
583 if (h == INVALID_HANDLE_VALUE)
584 throw string_error(IDS_RECV_CANT_CREATE_FILE, (pathu + L":" + streamname).c_str(), GetLastError(), format_message(GetLastError()).c_str());
585
586 if (xattrdatalen > 0) {
587 if (!WriteFile(h, xattrdata, xattrdatalen, nullptr, nullptr))
589 }
590
591 if (att & FILE_ATTRIBUTE_READONLY) {
592 if (!SetFileAttributesW((subvolpath + pathu).c_str(), att))
594 }
595 } else {
599 btrfs_set_xattr* bsxa;
600
601 if (xattrname == EA_NTACL)
602 perms |= WRITE_DAC | WRITE_OWNER;
603 else if (xattrname == EA_EA)
604 perms |= FILE_WRITE_EA;
605
608 if (h == INVALID_HANDLE_VALUE)
610
611 size_t bsxalen = offsetof(btrfs_set_xattr, data[0]) + xattrname.length() + xattrdatalen;
612 bsxa = (btrfs_set_xattr*)malloc(bsxalen);
613 if (!bsxa)
615
616 bsxa->namelen = (uint16_t)xattrname.length();
617 bsxa->valuelen = (uint16_t)xattrdatalen;
618 memcpy(bsxa->data, xattrname.c_str(), xattrname.length());
619 memcpy(&bsxa->data[xattrname.length()], xattrdata, xattrdatalen);
620
621 Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_SET_XATTR, bsxa, (ULONG)bsxalen, nullptr, 0);
622 if (!NT_SUCCESS(Status)) {
623 free(bsxa);
625 }
626
627 free(bsxa);
628 }
629}
#define EA_REPARSE
Definition: btrfs_drv.h:99
#define IDS_RECV_CANT_CREATE_FILE
Definition: resource.h:148
#define IDS_RECV_WRITEFILE_FAILED
Definition: resource.h:145
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
#define BTRFS_SEND_TLV_XATTR_DATA
Definition: btrfs.h:581
#define CREATE_ALWAYS
Definition: disk.h:72
BYTE uint8_t
Definition: msvideo1.c:66

Referenced by do_recv().

◆ cmd_snapshot()

void BtrfsRecv::cmd_snapshot ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data,
const win_handle parent 
)
private

Definition at line 154 of file recv.cpp.

154 {
155 string name;
156 BTRFS_UUID *uuid, *parent_uuid;
157 uint64_t *gen, *parent_transid;
158 ULONG uuidlen, genlen, paruuidlen, partransidlen;
162 wstring parpath;
164 WCHAR parpathw[MAX_PATH], volpathw[MAX_PATH];
165 size_t bcslen;
166
167 {
168 char* namebuf;
170
171 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&namebuf, &namelen))
173
174 name = string(namebuf, namelen);
175 }
176
177 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_UUID, (void**)&uuid, &uuidlen))
179
180 if (uuidlen < sizeof(BTRFS_UUID))
181 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"uuid", uuidlen, sizeof(BTRFS_UUID));
182
183 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_TRANSID, (void**)&gen, &genlen))
185
186 if (genlen < sizeof(uint64_t))
187 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"transid", genlen, sizeof(uint64_t));
188
189 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_CLONE_UUID, (void**)&parent_uuid, &paruuidlen))
190 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"clone_uuid");
191
192 if (paruuidlen < sizeof(BTRFS_UUID))
193 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"clone_uuid", paruuidlen, sizeof(BTRFS_UUID));
194
195 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_CLONE_CTRANSID, (void**)&parent_transid, &partransidlen))
196 throw string_error(IDS_RECV_MISSING_PARAM, funcname, L"clone_ctransid");
197
198 if (partransidlen < sizeof(uint64_t))
199 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"clone_ctransid", partransidlen, sizeof(uint64_t));
200
201 this->subvol_uuid = *uuid;
202 this->stransid = *gen;
203
204 auto nameu = utf8_to_utf16(name);
205
206 bfs.uuid = *parent_uuid;
207 bfs.ctransid = *parent_transid;
208
209 Status = NtFsControlFile(parent, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_FIND_SUBVOL, &bfs, sizeof(btrfs_find_subvol),
210 parpathw, sizeof(parpathw));
213 else if (!NT_SUCCESS(Status))
215
216 if (!GetVolumePathNameW(dirpath.c_str(), volpathw, (sizeof(volpathw) / sizeof(WCHAR)) - 1))
218
219 parpath = volpathw;
220 if (parpath.substr(parpath.length() - 1) == L"\\")
221 parpath = parpath.substr(0, parpath.length() - 1);
222
223 parpath += parpathw;
224
225 {
227 nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
228 if (subvol == INVALID_HANDLE_VALUE)
229 throw string_error(IDS_RECV_CANT_OPEN_PATH, parpath.c_str(), GetLastError(), format_message(GetLastError()).c_str());
230
231 bcslen = offsetof(btrfs_create_snapshot, name[0]) + (nameu.length() * sizeof(WCHAR));
232 bcs = (btrfs_create_snapshot*)malloc(bcslen);
233
234 bcs->readonly = true;
235 bcs->posix = true;
236 bcs->subvol = subvol;
237 bcs->namelen = (uint16_t)(nameu.length() * sizeof(WCHAR));
238 memcpy(bcs->name, nameu.c_str(), bcs->namelen);
239
240 Status = NtFsControlFile(parent, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SNAPSHOT, bcs, (ULONG)bcslen, nullptr, 0);
241 if (!NT_SUCCESS(Status))
243 }
244
246 subvolpath += L"\\";
247 subvolpath += nameu;
248
251
254
259
260 Status = NtFsControlFile(master, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_RESERVE_SUBVOL, bcs, (ULONG)bcslen, nullptr, 0);
261 if (!NT_SUCCESS(Status))
263
269
270 subvolpath += L"\\";
271
273
274 num_received++;
275}
#define FSCTL_BTRFS_CREATE_SNAPSHOT
Definition: btrfsioctl.h:9
#define FSCTL_BTRFS_RESERVE_SUBVOL
Definition: btrfsioctl.h:34
BTRFS_UUID subvol_uuid
Definition: recv.h:83
#define IDS_RECV_RESERVE_SUBVOL_FAILED
Definition: resource.h:164
#define IDS_RECV_CREATE_SNAPSHOT_FAILED
Definition: resource.h:168
#define IDS_RECV_CANT_OPEN_PATH
Definition: resource.h:136
#define IDS_RECV_CANT_FIND_PARENT_SUBVOL
Definition: resource.h:166
#define CloseHandle
Definition: compat.h:739
#define GENERIC_READ
Definition: compat.h:135
r parent
Definition: btrfs.c:3010
#define BTRFS_SEND_TLV_TRANSID
Definition: btrfs.h:569
#define BTRFS_SEND_TLV_UUID
Definition: btrfs.h:568
#define FILE_TRAVERSE
Definition: nt_native.h:643
#define FILE_ADD_SUBDIRECTORY
Definition: nt_native.h:635
#define FILE_ADD_FILE
Definition: nt_native.h:632

Referenced by do_recv().

◆ cmd_subvol()

void BtrfsRecv::cmd_subvol ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data,
const win_handle parent 
)
private

Definition at line 64 of file recv.cpp.

64 {
65 string name;
67 uint64_t* gen;
68 ULONG uuidlen, genlen;
72
73 {
74 char* namebuf;
76
77 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&namebuf, &namelen))
79
80 name = string(namebuf, namelen);
81 }
82
83 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_UUID, (void**)&uuid, &uuidlen))
85
86 if (uuidlen < sizeof(BTRFS_UUID))
87 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"uuid", uuidlen, sizeof(BTRFS_UUID));
88
89 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_TRANSID, (void**)&gen, &genlen))
91
92 if (genlen < sizeof(uint64_t))
93 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"transid", genlen, sizeof(uint64_t));
94
95 this->subvol_uuid = *uuid;
96 this->stransid = *gen;
97
98 auto nameu = utf8_to_utf16(name);
99
100 size_t bcslen = offsetof(btrfs_create_subvol, name[0]) + (nameu.length() * sizeof(WCHAR));
101 bcs = (btrfs_create_subvol*)malloc(bcslen);
102
103 bcs->readonly = true;
104 bcs->posix = true;
105 bcs->namelen = (uint16_t)(nameu.length() * sizeof(WCHAR));
106 memcpy(bcs->name, nameu.c_str(), bcs->namelen);
107
108 Status = NtFsControlFile(parent, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_CREATE_SUBVOL, bcs, (ULONG)bcslen, nullptr, 0);
109 if (!NT_SUCCESS(Status))
111
113 subvolpath += L"\\";
114 subvolpath += nameu;
115
118
121
126
127 Status = NtFsControlFile(master, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_RESERVE_SUBVOL, bcs, (ULONG)bcslen, nullptr, 0);
128 if (!NT_SUCCESS(Status))
130
136
137 subvolpath += L"\\";
138
140
141 num_received++;
142}
#define FSCTL_BTRFS_CREATE_SUBVOL
Definition: btrfsioctl.h:8
#define IDS_RECV_CREATE_SUBVOL_FAILED
Definition: resource.h:138

Referenced by do_recv().

◆ cmd_truncate()

void BtrfsRecv::cmd_truncate ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 923 of file recv.cpp.

923 {
924 uint64_t* size;
925 ULONG sizelen;
926 wstring pathu;
927 LARGE_INTEGER sizeli;
928 DWORD att;
929
930 {
931 char* path;
932 ULONG pathlen;
933
934 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
936
937 pathu = utf8_to_utf16(string(path, pathlen));
938 }
939
940 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_SIZE, (void**)&size, &sizelen))
942
943 if (sizelen < sizeof(uint64_t))
944 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"size", sizelen, sizeof(uint64_t));
945
946 att = GetFileAttributesW((subvolpath + pathu).c_str());
947 if (att == INVALID_FILE_ATTRIBUTES)
949
950 if (att & FILE_ATTRIBUTE_READONLY) {
951 if (!SetFileAttributesW((subvolpath + pathu).c_str(), att & ~FILE_ATTRIBUTE_READONLY))
953 }
954
955 {
956 win_handle h = CreateFileW((subvolpath + pathu).c_str(), FILE_WRITE_DATA, 0, nullptr, OPEN_EXISTING,
958
959 if (h == INVALID_HANDLE_VALUE)
961
962 sizeli.QuadPart = *size;
963
966
967 if (!SetEndOfFile(h))
969 }
970
971 if (att & FILE_ATTRIBUTE_READONLY) {
972 if (!SetFileAttributesW((subvolpath + pathu).c_str(), att))
974 }
975}
#define BTRFS_SEND_TLV_SIZE
Definition: btrfs.h:571
unsigned long DWORD
Definition: ntddk_ex.h:95
GLsizeiptr size
Definition: glext.h:5919

Referenced by do_recv().

◆ cmd_unlink()

void BtrfsRecv::cmd_unlink ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 481 of file recv.cpp.

481 {
482 wstring pathu;
483 ULONG att;
484
485 {
486 char* path;
487 ULONG pathlen;
488
489 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
491
492 pathu = utf8_to_utf16(string(path, pathlen));
493 }
494
495 att = GetFileAttributesW((subvolpath + pathu).c_str());
496 if (att == INVALID_FILE_ATTRIBUTES)
498
499 if (att & FILE_ATTRIBUTE_READONLY) {
500 if (!SetFileAttributesW((subvolpath + pathu).c_str(), att & ~FILE_ATTRIBUTE_READONLY))
502 }
503
504 if (!DeleteFileW((subvolpath + pathu).c_str()))
506}

Referenced by do_recv().

◆ cmd_utimes()

void BtrfsRecv::cmd_utimes ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 1071 of file recv.cpp.

1071 {
1072 wstring pathu;
1073 win_handle h;
1074 FILE_BASIC_INFO fbi;
1076 ULONG timelen;
1079
1080 {
1081 char* path;
1082 ULONG pathlen;
1083
1084 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
1086
1087 pathu = utf8_to_utf16(string(path, pathlen));
1088 }
1089
1090 h = CreateFileW((subvolpath + pathu).c_str(), FILE_WRITE_ATTRIBUTES, 0, nullptr, OPEN_EXISTING,
1092 if (h == INVALID_HANDLE_VALUE)
1094
1095 memset(&fbi, 0, sizeof(FILE_BASIC_INFO));
1096
1097 if (find_tlv(data, cmd->length, BTRFS_SEND_TLV_OTIME, (void**)&time, &timelen) && timelen >= sizeof(BTRFS_TIME))
1098 fbi.CreationTime.QuadPart = unix_time_to_win(time);
1099
1100 if (find_tlv(data, cmd->length, BTRFS_SEND_TLV_ATIME, (void**)&time, &timelen) && timelen >= sizeof(BTRFS_TIME))
1101 fbi.LastAccessTime.QuadPart = unix_time_to_win(time);
1102
1103 if (find_tlv(data, cmd->length, BTRFS_SEND_TLV_MTIME, (void**)&time, &timelen) && timelen >= sizeof(BTRFS_TIME))
1104 fbi.LastWriteTime.QuadPart = unix_time_to_win(time);
1105
1106 if (find_tlv(data, cmd->length, BTRFS_SEND_TLV_CTIME, (void**)&time, &timelen) && timelen >= sizeof(BTRFS_TIME))
1107 fbi.ChangeTime.QuadPart = unix_time_to_win(time);
1108
1109 Status = NtSetInformationFile(h, &iosb, &fbi, sizeof(FILE_BASIC_INFO), FileBasicInformation);
1110 if (!NT_SUCCESS(Status))
1111 throw ntstatus_error(Status);
1112}
#define BTRFS_SEND_TLV_MTIME
Definition: btrfs.h:577
#define BTRFS_SEND_TLV_ATIME
Definition: btrfs.h:578
#define BTRFS_SEND_TLV_CTIME
Definition: btrfs.h:576
#define BTRFS_SEND_TLV_OTIME
Definition: btrfs.h:579
@ FileBasicInformation
Definition: from_kernel.h:65
__u16 time
Definition: mkdosfs.c:8
NTSYSAPI NTSTATUS NTAPI NtSetInformationFile(IN HANDLE hFile, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN PVOID FileInformationBuffer, IN ULONG FileInformationBufferLength, IN FILE_INFORMATION_CLASS FileInfoClass)
Definition: iofunc.c:3096
static __inline uint64_t unix_time_to_win(BTRFS_TIME *t)
Definition: recv.cpp:1067

Referenced by do_recv().

◆ cmd_write()

void BtrfsRecv::cmd_write ( HWND  hwnd,
btrfs_send_command cmd,
uint8_t data 
)
private

Definition at line 713 of file recv.cpp.

713 {
715 uint8_t* writedata;
716 ULONG offsetlen, datalen;
717 wstring pathu;
718 HANDLE h;
719 LARGE_INTEGER offli;
722
723 {
724 char* path;
725 ULONG pathlen;
726
727 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_PATH, (void**)&path, &pathlen))
729
730 pathu = utf8_to_utf16(string(path, pathlen));
731 }
732
733 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_OFFSET, (void**)&offset, &offsetlen))
735
736 if (offsetlen < sizeof(uint64_t))
737 throw string_error(IDS_RECV_SHORT_PARAM, funcname, L"offset", offsetlen, sizeof(uint64_t));
738
739 if (!find_tlv(data, cmd->length, BTRFS_SEND_TLV_DATA, (void**)&writedata, &datalen))
741
742 if (lastwritepath != pathu) {
743 FILE_BASIC_INFO fbi;
744
748 }
749
751
752 lastwriteatt = GetFileAttributesW((subvolpath + pathu).c_str());
755
759 }
760
763 if (h == INVALID_HANDLE_VALUE)
765
766 lastwritepath = pathu;
768
769 memset(&fbi, 0, sizeof(FILE_BASIC_INFO));
770
771 fbi.LastWriteTime.QuadPart = -1;
772
773 Status = NtSetInformationFile(h, &iosb, &fbi, sizeof(FILE_BASIC_INFO), FileBasicInformation);
774 if (!NT_SUCCESS(Status))
775 throw ntstatus_error(Status);
776 } else
778
779 offli.QuadPart = *offset;
780
783
784 if (!WriteFile(h, writedata, datalen, nullptr, nullptr))
786}
DWORD lastwriteatt
Definition: recv.h:80
wstring lastwritepath
Definition: recv.h:79
HANDLE lastwritefile
Definition: recv.h:77
#define BTRFS_SEND_TLV_DATA
Definition: btrfs.h:586
int const JOCTET unsigned int datalen
Definition: jpeglib.h:1031

Referenced by do_recv().

◆ do_recv()

void BtrfsRecv::do_recv ( const win_handle f,
uint64_t pos,
uint64_t  size,
const win_handle parent 
)
private

Definition at line 1157 of file recv.cpp.

1157 {
1158 try {
1160 bool ended = false;
1161
1162 if (!ReadFile(f, &header, sizeof(btrfs_send_header), nullptr, nullptr))
1164
1165 *pos += sizeof(btrfs_send_header);
1166
1167 if (memcmp(header.magic, BTRFS_SEND_MAGIC, sizeof(header.magic)))
1169
1170 if (header.version > 1)
1172
1174
1176 lastwritepath = L"";
1177 lastwriteatt = 0;
1178
1179 while (true) {
1181 uint8_t* data = nullptr;
1183
1184 if (cancelling)
1185 break;
1186
1187 progress = (ULONG)((float)*pos * 65536.0f / (float)size);
1189
1190 if (!ReadFile(f, &cmd, sizeof(btrfs_send_command), nullptr, nullptr)) {
1193
1194 break;
1195 }
1196
1197 *pos += sizeof(btrfs_send_command);
1198
1199 if (cmd.length > 0) {
1200 if (*pos + cmd.length > size)
1202
1203 data = (uint8_t*)malloc(cmd.length);
1204 if (!data)
1206 }
1207
1208 try {
1209 if (data) {
1210 if (!ReadFile(f, data, cmd.length, nullptr, nullptr))
1212
1213 *pos += cmd.length;
1214 }
1215
1216 if (!check_csum(&cmd, data))
1218
1219 if (cmd.cmd == BTRFS_SEND_CMD_END) {
1220 ended = true;
1221 break;
1222 }
1223
1228 }
1229
1231
1233 lastwritepath = L"";
1234 lastwriteatt = 0;
1235 }
1236
1237 switch (cmd.cmd) {
1240 break;
1241
1244 break;
1245
1252 cmd_mkfile(hwnd, &cmd, data);
1253 break;
1254
1256 cmd_rename(hwnd, &cmd, data);
1257 break;
1258
1260 cmd_link(hwnd, &cmd, data);
1261 break;
1262
1264 cmd_unlink(hwnd, &cmd, data);
1265 break;
1266
1268 cmd_rmdir(hwnd, &cmd, data);
1269 break;
1270
1273 break;
1274
1277 break;
1278
1280 cmd_write(hwnd, &cmd, data);
1281 break;
1282
1284 cmd_clone(hwnd, &cmd, data);
1285 break;
1286
1289 break;
1290
1292 cmd_chmod(hwnd, &cmd, data);
1293 break;
1294
1296 cmd_chown(hwnd, &cmd, data);
1297 break;
1298
1300 cmd_utimes(hwnd, &cmd, data);
1301 break;
1302
1304 // does nothing
1305 break;
1306
1307 default:
1309 }
1310 } catch (...) {
1311 if (data) free(data);
1312 throw;
1313 }
1314
1315 if (data) free(data);
1316 }
1317
1322 }
1323
1325 }
1326
1327 if (!ended && !cancelling)
1329
1330 if (!cancelling) {
1334
1335 brs.generation = stransid;
1336 brs.uuid = subvol_uuid;
1337
1338 Status = NtFsControlFile(dir, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_RECEIVED_SUBVOL, &brs, sizeof(btrfs_received_subvol),
1339 nullptr, 0);
1340 if (!NT_SUCCESS(Status))
1342 }
1343
1345
1348 } catch (...) {
1349 if (subvolpath != L"") {
1350 ULONG attrib;
1351
1352 attrib = GetFileAttributesW(subvolpath.c_str());
1353 attrib &= ~FILE_ATTRIBUTE_READONLY;
1354
1355 if (SetFileAttributesW(subvolpath.c_str(), attrib))
1357 }
1358
1359 throw;
1360 }
1361}
#define FSCTL_BTRFS_RECEIVED_SUBVOL
Definition: btrfsioctl.h:31
cd_progress_ptr progress
Definition: cdjpeg.h:152
void cmd_removexattr(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:631
void cmd_chmod(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:977
void cmd_subvol(HWND hwnd, btrfs_send_command *cmd, uint8_t *data, const win_handle &parent)
Definition: recv.cpp:64
void cmd_write(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:713
void cmd_rmdir(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:508
void cmd_snapshot(HWND hwnd, btrfs_send_command *cmd, uint8_t *data, const win_handle &parent)
Definition: recv.cpp:154
void cmd_clone(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:788
void cmd_setxattr(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:535
void cmd_mkfile(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:277
void cmd_link(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:454
void cmd_unlink(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:481
void cmd_rename(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:427
void cmd_truncate(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:923
void cmd_chown(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:1017
void cmd_utimes(HWND hwnd, btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:1071
#define IDS_RECV_CSUM_ERROR
Definition: resource.h:155
#define IDS_RECV_FILE_TRUNCATED
Definition: resource.h:163
#define IDS_RECV_NOT_A_SEND_STREAM
Definition: resource.h:156
#define IDS_RECV_RECEIVED_SUBVOL_FAILED
Definition: resource.h:159
#define IDS_RECV_UNKNOWN_COMMAND
Definition: resource.h:135
#define IDS_RECV_READFILE_FAILED
Definition: resource.h:133
#define IDS_RECV_UNSUPPORTED_VERSION
Definition: resource.h:157
#define IDC_RECV_PROGRESS
Definition: resource.h:264
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
#define BTRFS_SEND_CMD_RMDIR
Definition: btrfs.h:556
#define BTRFS_SEND_CMD_SET_XATTR
Definition: btrfs.h:557
#define BTRFS_SEND_CMD_MKFILE
Definition: btrfs.h:547
#define BTRFS_SEND_CMD_UPDATE_EXTENT
Definition: btrfs.h:566
#define BTRFS_SEND_CMD_WRITE
Definition: btrfs.h:559
#define BTRFS_SEND_CMD_UTIMES
Definition: btrfs.h:564
#define BTRFS_SEND_CMD_CHMOD
Definition: btrfs.h:562
#define BTRFS_SEND_CMD_LINK
Definition: btrfs.h:554
#define BTRFS_SEND_CMD_RENAME
Definition: btrfs.h:553
#define BTRFS_SEND_CMD_SUBVOL
Definition: btrfs.h:545
#define BTRFS_SEND_CMD_SNAPSHOT
Definition: btrfs.h:546
#define BTRFS_SEND_CMD_TRUNCATE
Definition: btrfs.h:561
#define BTRFS_SEND_CMD_CHOWN
Definition: btrfs.h:563
#define BTRFS_SEND_CMD_END
Definition: btrfs.h:565
#define BTRFS_SEND_CMD_UNLINK
Definition: btrfs.h:555
#define BTRFS_SEND_CMD_REMOVE_XATTR
Definition: btrfs.h:558
#define BTRFS_SEND_CMD_CLONE
Definition: btrfs.h:560
#define BTRFS_SEND_MAGIC
Definition: btrfs.h:593
GLfloat f
Definition: glext.h:7540
static float(__cdecl *square_half_float)(float x
#define PBM_SETRANGE32
Definition: commctrl.h:2188
#define PBM_SETPOS
Definition: commctrl.h:2184
static void delete_directory(const wstring &dir)
Definition: recv.cpp:1114
static bool check_csum(btrfs_send_command *cmd, uint8_t *data)
Definition: recv.cpp:1144
LONG_PTR LPARAM
Definition: windef.h:208
#define ERROR_HANDLE_EOF
Definition: winerror.h:140
HWND WINAPI GetDlgItem(_In_opt_ HWND, _In_ int)
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by recv_thread().

◆ find_tlv()

bool BtrfsRecv::find_tlv ( uint8_t data,
ULONG  datalen,
uint16_t  type,
void **  value,
ULONG len 
)
private

Definition at line 42 of file recv.cpp.

42 {
43 size_t off = 0;
44
45 while (off < datalen) {
46 btrfs_send_tlv* tlv = (btrfs_send_tlv*)(data + off);
47 uint8_t* payload = data + off + sizeof(btrfs_send_tlv);
48
49 if (off + sizeof(btrfs_send_tlv) + tlv->length > datalen) // file is truncated
50 return false;
51
52 if (tlv->type == type) {
53 *value = payload;
54 *len = tlv->length;
55 return true;
56 }
57
58 off += sizeof(btrfs_send_tlv) + tlv->length;
59 }
60
61 return false;
62}
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLenum GLsizei len
Definition: glext.h:6722
uint16_t type
Definition: btrfs.h:607
uint16_t length
Definition: btrfs.h:608
Definition: pdh_main.c:94

Referenced by cmd_chmod(), cmd_chown(), cmd_clone(), cmd_link(), cmd_mkfile(), cmd_removexattr(), cmd_rename(), cmd_rmdir(), cmd_setxattr(), cmd_snapshot(), cmd_subvol(), cmd_truncate(), cmd_unlink(), cmd_utimes(), and cmd_write().

◆ Open()

void BtrfsRecv::Open ( HWND  hwnd,
const wstring &  file,
const wstring &  path,
bool  quiet 
)

Definition at line 1528 of file recv.cpp.

1528 {
1529 streamfile = file;
1530 dirpath = path;
1531 subvolpath = L"";
1532
1533#if defined(_X86_) || defined(_AMD64_)
1534 check_cpu();
1535#endif
1536
1537 if (quiet)
1538 recv_thread();
1539 else {
1541 throw last_error(GetLastError());
1542 }
1543}
DWORD recv_thread()
Definition: recv.cpp:1390
wstring streamfile
Definition: recv.h:79
#define IDD_RECV_PROGRESS
Definition: resource.h:86
static INT_PTR CALLBACK stub_RecvProgressDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: recv.cpp:1512
Definition: fci.c:127
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
INT_PTR WINAPI DialogBoxParamW(_In_opt_ HINSTANCE, _In_ LPCWSTR, _In_opt_ HWND, _In_opt_ DLGPROC, _In_ LPARAM)
static int quiet
Definition: xmllint.c:162

Referenced by RecvSubvolW().

◆ recv_thread()

DWORD BtrfsRecv::recv_thread ( )

Definition at line 1390 of file recv.cpp.

1390 {
1392 uint64_t pos = 0;
1393 bool b = true;
1394
1395 running = true;
1396
1397 try {
1398 win_handle f = CreateFileW(streamfile.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr);
1399 if (f == INVALID_HANDLE_VALUE)
1401
1402 if (!GetFileSizeEx(f, &size))
1404
1405 {
1410
1411 do {
1412 do_recv(f, &pos, size.QuadPart, parent);
1413 } while (pos < (uint64_t)size.QuadPart);
1414 }
1415 } catch (const exception& e) {
1416 auto msg = utf8_to_utf16(e.what());
1417
1419
1420 SendMessageW(GetDlgItem(hwnd, IDC_RECV_PROGRESS), PBM_SETSTATE, PBST_ERROR, 0);
1421
1422 b = false;
1423 }
1424
1425 if (b && hwnd) {
1426 wstring s;
1427
1429
1430 if (num_received == 1) {
1433 } else {
1434 wstring t;
1435
1437
1439
1441 }
1442
1444
1445 SetDlgItemTextW(hwnd, IDCANCEL, s.c_str());
1446 }
1447
1448 thread = nullptr;
1449 running = false;
1450
1451 return 0;
1452}
#define msg(x)
Definition: auth_time.c:54
void do_recv(const win_handle &f, uint64_t *pos, uint64_t size, const win_handle &parent)
Definition: recv.cpp:1157
void wstring_sprintf(wstring &s, wstring fmt,...)
Definition: main.cpp:225
#define IDC_RECV_MSG
Definition: resource.h:325
#define IDS_RECV_SUCCESS
Definition: resource.h:151
#define IDS_RECV_BUTTON_OK
Definition: resource.h:152
#define IDS_RECV_SUCCESS_PLURAL
Definition: resource.h:175
GLdouble s
Definition: gl.h:2039
GLdouble GLdouble t
Definition: gl.h:2047
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define e
Definition: ke_i.h:82
static int load_string(HINSTANCE hModule, UINT resId, LPWSTR pwszBuffer, INT cMaxChars)
Definition: muireg.c:10
#define IDCANCEL
Definition: winuser.h:825
BOOL WINAPI SetDlgItemTextW(_In_ HWND, _In_ int, _In_ LPCWSTR)

Referenced by global_recv_thread(), and Open().

◆ RecvProgressDlgProc()

INT_PTR CALLBACK BtrfsRecv::RecvProgressDlgProc ( HWND  hwndDlg,
UINT  uMsg,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 1460 of file recv.cpp.

1460 {
1461 switch (uMsg) {
1462 case WM_INITDIALOG:
1463 try {
1464 this->hwnd = hwndDlg;
1465 thread = CreateThread(nullptr, 0, global_recv_thread, this, 0, nullptr);
1466
1467 if (!thread)
1469 } catch (const exception& e) {
1470 auto msg = utf8_to_utf16(e.what());
1471
1473
1474 SendMessageW(GetDlgItem(hwnd, IDC_RECV_PROGRESS), PBM_SETSTATE, PBST_ERROR, 0);
1475 }
1476 break;
1477
1478 case WM_COMMAND:
1479 switch (HIWORD(wParam)) {
1480 case BN_CLICKED:
1481 switch (LOWORD(wParam)) {
1482 case IDOK:
1483 case IDCANCEL:
1484 if (running) {
1485 wstring s;
1486
1487 cancelling = true;
1488
1490 throw last_error(GetLastError());
1491
1494
1496 throw last_error(GetLastError());
1497
1498 SetDlgItemTextW(hwnd, IDCANCEL, s.c_str());
1499 } else
1500 EndDialog(hwndDlg, 1);
1501
1502 return true;
1503 }
1504 break;
1505 }
1506 break;
1507 }
1508
1509 return false;
1510}
WPARAM wParam
Definition: combotst.c:138
#define IDS_RECV_CREATETHREAD_FAILED
Definition: resource.h:162
#define IDS_RECV_CANCELLED
Definition: resource.h:165
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
#define LOWORD(l)
Definition: pedump.c:82
static DWORD WINAPI global_recv_thread(LPVOID lpParameter)
Definition: recv.cpp:1454
#define HIWORD(l)
Definition: typedefs.h:247
#define WM_COMMAND
Definition: winuser.h:1730
#define WM_INITDIALOG
Definition: winuser.h:1729
#define IDOK
Definition: winuser.h:824
#define BN_CLICKED
Definition: winuser.h:1915
BOOL WINAPI EndDialog(_In_ HWND, _In_ INT_PTR)

Referenced by stub_RecvProgressDlgProc().

Member Data Documentation

◆ cache

vector<subvol_cache> BtrfsRecv::cache
private

Definition at line 85 of file recv.h.

◆ cancelling

bool BtrfsRecv::cancelling
private

Definition at line 84 of file recv.h.

Referenced by BtrfsRecv(), do_recv(), and RecvProgressDlgProc().

◆ dir

HANDLE BtrfsRecv::dir
private

Definition at line 77 of file recv.h.

Referenced by BtrfsRecv(), cmd_clone(), cmd_mkfile(), cmd_snapshot(), cmd_subvol(), and do_recv().

◆ dirpath

wstring BtrfsRecv::dirpath
private

Definition at line 79 of file recv.h.

Referenced by cmd_clone(), cmd_snapshot(), cmd_subvol(), Open(), and recv_thread().

◆ hwnd

HWND BtrfsRecv::hwnd
private

Definition at line 78 of file recv.h.

◆ lastwriteatt

DWORD BtrfsRecv::lastwriteatt
private

Definition at line 80 of file recv.h.

Referenced by cmd_write(), and do_recv().

◆ lastwritefile

HANDLE BtrfsRecv::lastwritefile
private

Definition at line 77 of file recv.h.

Referenced by cmd_write(), and do_recv().

◆ lastwritepath

wstring BtrfsRecv::lastwritepath
private

Definition at line 79 of file recv.h.

Referenced by cmd_write(), and do_recv().

◆ master

HANDLE BtrfsRecv::master
private

Definition at line 77 of file recv.h.

Referenced by BtrfsRecv(), cmd_snapshot(), cmd_subvol(), and do_recv().

◆ num_received

ULONG BtrfsRecv::num_received
private

Definition at line 81 of file recv.h.

Referenced by BtrfsRecv(), cmd_snapshot(), cmd_subvol(), and recv_thread().

◆ running

bool BtrfsRecv::running
private

Definition at line 84 of file recv.h.

Referenced by BtrfsRecv(), recv_thread(), and RecvProgressDlgProc().

◆ stransid

uint64_t BtrfsRecv::stransid
private

Definition at line 82 of file recv.h.

Referenced by BtrfsRecv(), cmd_snapshot(), cmd_subvol(), and do_recv().

◆ streamfile

wstring BtrfsRecv::streamfile
private

Definition at line 79 of file recv.h.

Referenced by Open(), and recv_thread().

◆ subvol_uuid

BTRFS_UUID BtrfsRecv::subvol_uuid
private

Definition at line 83 of file recv.h.

Referenced by cmd_snapshot(), cmd_subvol(), and do_recv().

◆ subvolpath

◆ thread

HANDLE BtrfsRecv::thread
private

Definition at line 77 of file recv.h.

Referenced by BtrfsRecv(), recv_thread(), and RecvProgressDlgProc().


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