826 lines
36 KiB
C++
826 lines
36 KiB
C++
#include <winsock2.h>
|
|
#include <ws2tcpip.h>
|
|
#include <shellapi.h>
|
|
#include <shlobj.h>
|
|
#include <atomic>
|
|
#include <bcrypt.h>
|
|
#include <thread>
|
|
#include "lan_files.h"
|
|
#include "lan_channel.h"
|
|
|
|
namespace ks::lan
|
|
{
|
|
namespace fs = std::filesystem;
|
|
|
|
Json fileRequest(std::string_view action, const fs::path &path)
|
|
{
|
|
return {{"action",action},{"path",utf8(path.native())}};
|
|
}
|
|
|
|
fs::path filePath(const Json &value)
|
|
{
|
|
return wide(value.get<std::string>());
|
|
}
|
|
|
|
void checkFileReply(const Json &reply)
|
|
{
|
|
const auto error=reply.at("error").get<DWORD>();
|
|
if(error) throw std::system_error(static_cast<int>(error),std::system_category());
|
|
}
|
|
|
|
bool recycleFile(HWND owner,const fs::path &path)
|
|
{
|
|
const auto initialized=CoInitializeEx(nullptr,COINIT_APARTMENTTHREADED);
|
|
if(FAILED(initialized)) return false;
|
|
IFileOperation *operation{};
|
|
IShellItem *item{};
|
|
auto result=CoCreateInstance(__uuidof(FileOperation),nullptr,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&operation));
|
|
if(SUCCEEDED(result))
|
|
result=operation->SetOperationFlags(FOFX_RECYCLEONDELETE|FOF_SILENT|FOF_NOCONFIRMATION|
|
|
FOF_NOERRORUI|FOFX_EARLYFAILURE);
|
|
if(SUCCEEDED(result) && owner) result=operation->SetOwnerWindow(owner);
|
|
if(SUCCEEDED(result)) result=SHCreateItemFromParsingName(path.c_str(),nullptr,IID_PPV_ARGS(&item));
|
|
if(SUCCEEDED(result)) result=operation->DeleteItem(item,nullptr);
|
|
if(SUCCEEDED(result)) result=operation->PerformOperations();
|
|
BOOL aborted=TRUE;
|
|
if(SUCCEEDED(result)) result=operation->GetAnyOperationsAborted(&aborted);
|
|
if(item) item->Release();
|
|
if(operation) operation->Release();
|
|
CoUninitialize();
|
|
return SUCCEEDED(result) && !aborted;
|
|
}
|
|
|
|
namespace
|
|
{
|
|
constexpr size_t FrameLimit=256*1024;
|
|
constexpr DWORD SocketTimeout=5000;
|
|
|
|
struct WinSocket
|
|
{
|
|
SOCKET value=INVALID_SOCKET;
|
|
~WinSocket(){if(value!=INVALID_SOCKET) closesocket(value);}
|
|
};
|
|
|
|
void socketError()
|
|
{
|
|
throw std::system_error(WSAGetLastError(),std::system_category());
|
|
}
|
|
|
|
struct Network
|
|
{
|
|
Network()
|
|
{
|
|
WSADATA data{};
|
|
if(const auto error=WSAStartup(MAKEWORD(2,2),&data))
|
|
throw std::system_error(error,std::system_category());
|
|
}
|
|
~Network(){WSACleanup();}
|
|
};
|
|
|
|
class Wire
|
|
{
|
|
SOCKET socket;
|
|
std::unique_ptr<InputCipher> tx,rx;
|
|
void bytes(void *buffer,size_t size,bool sending)
|
|
{
|
|
auto *next=static_cast<char*>(buffer);
|
|
const auto deadline=GetTickCount64()+SocketTimeout;
|
|
while(size)
|
|
{
|
|
if(GetTickCount64()>=deadline)
|
|
throw std::system_error(WSAETIMEDOUT,std::system_category());
|
|
const auto n=sending?send(socket,next,static_cast<int>(size),0):
|
|
recv(socket,next,static_cast<int>(size),0);
|
|
if(n==SOCKET_ERROR) socketError();
|
|
if(!n) throw std::system_error(WSAECONNRESET,std::system_category());
|
|
size-=n;
|
|
next+=n;
|
|
}
|
|
}
|
|
public:
|
|
explicit Wire(SOCKET socket):socket(socket)
|
|
{
|
|
if(setsockopt(socket,SOL_SOCKET,SO_RCVTIMEO,reinterpret_cast<const char*>(&SocketTimeout),sizeof(SocketTimeout)) ||
|
|
setsockopt(socket,SOL_SOCKET,SO_SNDTIMEO,reinterpret_cast<const char*>(&SocketTimeout),sizeof(SocketTimeout)))
|
|
socketError();
|
|
const BOOL yes=TRUE;
|
|
setsockopt(socket,IPPROTO_TCP,TCP_NODELAY,reinterpret_cast<const char*>(&yes),sizeof(yes));
|
|
}
|
|
void write(const Json &message)
|
|
{
|
|
auto data=Json::to_cbor(message);
|
|
if(tx) data=tx->encryptPayload(data,FrameLimit-16);
|
|
if(data.size()>FrameLimit) throw std::runtime_error("LAN file frame too large.");
|
|
uint32_t length=htonl(static_cast<uint32_t>(data.size()));
|
|
bytes(&length,sizeof(length),true);
|
|
bytes(data.data(),data.size(),true);
|
|
}
|
|
Json read(bool idle=false)
|
|
{
|
|
if(idle)
|
|
{
|
|
fd_set ready{};
|
|
FD_SET(socket,&ready);
|
|
if(select(0,&ready,nullptr,nullptr,nullptr)==SOCKET_ERROR) socketError();
|
|
}
|
|
uint32_t length{};
|
|
bytes(&length,sizeof(length),false);
|
|
length=ntohl(length);
|
|
if(!length || length>(rx?FrameLimit:1024))
|
|
throw std::runtime_error("Invalid LAN file frame.");
|
|
Bytes data(length);
|
|
bytes(data.data(),data.size(),false);
|
|
if(rx) data=rx->decryptPayload(data,FrameLimit-16);
|
|
return Json::from_cbor(data);
|
|
}
|
|
void authenticate(const std::string &secret,const std::string &client,const std::string &server,
|
|
const std::string &challenge,const std::string &nonce,bool outbound)
|
|
{
|
|
if(!identifier(client)||!identifier(server)||client==server||!identifier(challenge)||!identifier(nonce))
|
|
throw std::runtime_error("Invalid LAN file session.");
|
|
const auto context="KSwitcher files v1|"+client+"|"+server+"|"+challenge+"|"+nonce;
|
|
tx=std::make_unique<InputCipher>(mac(secret,context+(outbound?"|request":"|response")));
|
|
rx=std::make_unique<InputCipher>(mac(secret,context+(outbound?"|response":"|request")));
|
|
}
|
|
};
|
|
|
|
void connectPeer(SOCKET socket,const FilesPeer &peer)
|
|
{
|
|
sockaddr_in address{};
|
|
address.sin_family=AF_INET;
|
|
address.sin_port=htons(peer.port);
|
|
if(InetPtonA(AF_INET,peer.address.c_str(),&address.sin_addr)!=1)
|
|
throw std::system_error(WSAEHOSTUNREACH,std::system_category());
|
|
u_long mode=1;
|
|
if(ioctlsocket(socket,FIONBIO,&mode)) socketError();
|
|
if(connect(socket,reinterpret_cast<sockaddr*>(&address),sizeof(address)))
|
|
{
|
|
if(WSAGetLastError()!=WSAEWOULDBLOCK) socketError();
|
|
fd_set writable{},failed{};
|
|
FD_SET(socket,&writable);
|
|
FD_SET(socket,&failed);
|
|
timeval timeout{2,0};
|
|
const auto result=select(0,nullptr,&writable,&failed,&timeout);
|
|
if(result==SOCKET_ERROR) socketError();
|
|
if(!result) throw std::system_error(WSAETIMEDOUT,std::system_category());
|
|
int error{},size=sizeof(error);
|
|
if(getsockopt(socket,SOL_SOCKET,SO_ERROR,reinterpret_cast<char*>(&error),&size)) socketError();
|
|
if(error) throw std::system_error(error,std::system_category());
|
|
}
|
|
mode=0;
|
|
if(ioctlsocket(socket,FIONBIO,&mode)) socketError();
|
|
}
|
|
|
|
uint64_t fileSize(DWORD high,DWORD low){return (uint64_t(high)<<32)|low;}
|
|
Json ok(){return {{"error",ERROR_SUCCESS}};}
|
|
Json failure(DWORD error=GetLastError()){return {{"error",error?error:ERROR_GEN_FAILURE}};}
|
|
|
|
struct FileHandle
|
|
{
|
|
HANDLE value=INVALID_HANDLE_VALUE;
|
|
void close(){if(value!=INVALID_HANDLE_VALUE) CloseHandle(std::exchange(value,INVALID_HANDLE_VALUE));}
|
|
~FileHandle(){close();}
|
|
};
|
|
|
|
fs::path temporaryFile(const fs::path &target)
|
|
{
|
|
return target.parent_path()/wide(".kswitcher-"+randomHex(16)+".tmp");
|
|
}
|
|
|
|
std::string hashPrefix(HANDLE file,uint64_t size,const FileProgress &progress,uint64_t offset=0)
|
|
{
|
|
struct Hash
|
|
{
|
|
BCRYPT_ALG_HANDLE algorithm{};
|
|
BCRYPT_HASH_HANDLE value{};
|
|
~Hash(){if(value) BCryptDestroyHash(value);if(algorithm) BCryptCloseAlgorithmProvider(algorithm,0);}
|
|
} hash;
|
|
const auto checked=[](NTSTATUS status)
|
|
{
|
|
if(status<0) throw std::system_error(ERROR_GEN_FAILURE,std::system_category());
|
|
};
|
|
LARGE_INTEGER position{};
|
|
position.QuadPart=offset;
|
|
if(!SetFilePointerEx(file,position,nullptr,FILE_BEGIN))
|
|
throw std::system_error(GetLastError(),std::system_category());
|
|
checked(BCryptOpenAlgorithmProvider(&hash.algorithm,BCRYPT_SHA256_ALGORITHM,nullptr,0));
|
|
checked(BCryptCreateHash(hash.algorithm,&hash.value,nullptr,0,nullptr,0,0));
|
|
Bytes buffer(FileChunk),digest(32);
|
|
const auto total=size;
|
|
auto last=GetTickCount64();
|
|
while(size)
|
|
{
|
|
const auto now=GetTickCount64();
|
|
if(progress && now-last>=100)
|
|
{
|
|
if(!progress(total-size,total)) throw std::system_error(ERROR_CANCELLED,std::system_category());
|
|
last=now;
|
|
}
|
|
const auto count=static_cast<DWORD>(std::min<uint64_t>(size,buffer.size()));
|
|
DWORD read{};
|
|
if(!ReadFile(file,buffer.data(),count,&read,nullptr) || read!=count)
|
|
throw std::system_error(ERROR_READ_FAULT,std::system_category());
|
|
checked(BCryptHashData(hash.value,buffer.data(),read,0));
|
|
size-=read;
|
|
}
|
|
checked(BCryptFinishHash(hash.value,digest.data(),static_cast<ULONG>(digest.size()),0));
|
|
std::string hex;
|
|
for(const auto byte:digest){hex+="0123456789abcdef"[byte>>4];hex+="0123456789abcdef"[byte&15];}
|
|
return hex;
|
|
}
|
|
|
|
class FileOperations
|
|
{
|
|
bool remote;
|
|
HANDLE search=INVALID_HANDLE_VALUE;
|
|
WIN32_FIND_DATAW entry{};
|
|
bool pending{};
|
|
FileHandle input,output;
|
|
fs::path temporary,target;
|
|
bool resumable{};
|
|
uint64_t appendBase{},expectedSize{};
|
|
void closeSearch()
|
|
{
|
|
if(search!=INVALID_HANDLE_VALUE) FindClose(std::exchange(search,INVALID_HANDLE_VALUE));
|
|
}
|
|
void discard(bool removePartial=false)
|
|
{
|
|
output.close();
|
|
if(resumable && !removePartial) {temporary.clear();resumable=false;return;}
|
|
resumable=false;
|
|
if(!temporary.empty() && !DeleteFileW(temporary.c_str()) && GetLastError()==ERROR_ACCESS_DENIED)
|
|
{
|
|
SetFileAttributesW(temporary.c_str(),FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFileW(temporary.c_str());
|
|
}
|
|
temporary.clear();
|
|
}
|
|
fs::path path(const Json &value) const
|
|
{
|
|
auto result=filePath(value);
|
|
const auto &name=result.native();
|
|
if(name.find(L'\0')!=name.npos) throw std::system_error(ERROR_INVALID_NAME,std::system_category());
|
|
if(remote)
|
|
{
|
|
// Only drive paths from the remote Windows namespace. Reject NT devices and streams.
|
|
if(name.size()<3 || !((name[0]>=L'A'&&name[0]<=L'Z')||(name[0]>=L'a'&&name[0]<=L'z')) ||
|
|
name[1]!=L':' || (name[2]!=L'\\' && name[2]!=L'/') || name.find(L':',2)!=name.npos)
|
|
throw std::system_error(ERROR_INVALID_NAME,std::system_category());
|
|
result=result.lexically_normal();
|
|
for(const auto &part:result.relative_path())
|
|
{
|
|
const auto &component=part.native();
|
|
if(component.empty()) continue;
|
|
const auto dosName=component.substr(0,component.find_first_of(L". "));
|
|
if(part==L".." || component.find_first_of(L"<>|?*\"")!=component.npos ||
|
|
component.back()==L' ' || component.back()==L'.' ||
|
|
std::any_of(component.begin(),component.end(),[](wchar_t ch){return ch<32;}) ||
|
|
_wcsicmp(dosName.c_str(),L"CON")==0 || _wcsicmp(dosName.c_str(),L"PRN")==0 ||
|
|
_wcsicmp(dosName.c_str(),L"AUX")==0 || _wcsicmp(dosName.c_str(),L"NUL")==0 ||
|
|
(dosName.size()==4 && (_wcsnicmp(dosName.c_str(),L"COM",3)==0 ||
|
|
_wcsnicmp(dosName.c_str(),L"LPT",3)==0) && std::wstring_view(L"123456789¹²³").find(dosName.back())!=component.npos))
|
|
throw std::system_error(ERROR_INVALID_NAME,std::system_category());
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
Json listNext()
|
|
{
|
|
auto reply=ok();
|
|
auto &entries=reply["entries"]=Json::array();
|
|
while(search!=INVALID_HANDLE_VALUE && entries.size()<64)
|
|
{
|
|
if(!pending && !FindNextFileW(search,&entry))
|
|
{
|
|
const auto error=GetLastError();
|
|
closeSearch();
|
|
if(error!=ERROR_NO_MORE_FILES) return failure(error);
|
|
break;
|
|
}
|
|
pending=false;
|
|
const std::wstring name(entry.cFileName);
|
|
if(name==L"." || name==L".." ||
|
|
((entry.dwFileAttributes&FILE_ATTRIBUTE_HIDDEN) && name.starts_with(L".kswitcher-") &&
|
|
name.ends_with(L".partial") && name.size()==83)) continue;
|
|
entries.push_back({{"name",utf8(name)},{"attributes",entry.dwFileAttributes},
|
|
{"size",fileSize(entry.nFileSizeHigh,entry.nFileSizeLow)},
|
|
{"modified",fileSize(entry.ftLastWriteTime.dwHighDateTime,entry.ftLastWriteTime.dwLowDateTime)}});
|
|
}
|
|
reply["more"]=search!=INVALID_HANDLE_VALUE;
|
|
return reply;
|
|
}
|
|
static DWORD CALLBACK copyProgress(LARGE_INTEGER total,LARGE_INTEGER transferred,LARGE_INTEGER,LARGE_INTEGER,
|
|
DWORD,DWORD,HANDLE,HANDLE,LPVOID context)
|
|
{
|
|
const auto &callback=*static_cast<const FileProgress*>(context);
|
|
try {return !callback || callback(transferred.QuadPart,total.QuadPart)?PROGRESS_CONTINUE:PROGRESS_CANCEL;}
|
|
catch(...) {return PROGRESS_CANCEL;}
|
|
}
|
|
Json copy(const fs::path &source,const fs::path &destination,bool replace,bool append,
|
|
const FileProgress &progress)
|
|
{
|
|
discard();
|
|
temporary=temporaryFile(destination);
|
|
if(!append)
|
|
{
|
|
if(!CopyFileExW(source.c_str(),temporary.c_str(),copyProgress,
|
|
const_cast<FileProgress*>(&progress),nullptr,COPY_FILE_FAIL_IF_EXISTS))
|
|
{
|
|
const auto error=GetLastError();
|
|
if(error==ERROR_FILE_EXISTS || error==ERROR_ALREADY_EXISTS) temporary.clear();
|
|
return failure(error);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FileHandle in{CreateFileW(source.c_str(),GENERIC_READ,FILE_SHARE_READ,nullptr,OPEN_EXISTING,0,nullptr)};
|
|
if(in.value==INVALID_HANDLE_VALUE){temporary.clear();return failure();}
|
|
if(!CopyFileExW(destination.c_str(),temporary.c_str(),nullptr,nullptr,nullptr,COPY_FILE_FAIL_IF_EXISTS))
|
|
{
|
|
const auto error=GetLastError();
|
|
if(error==ERROR_FILE_EXISTS || error==ERROR_ALREADY_EXISTS) temporary.clear();
|
|
return failure(error);
|
|
}
|
|
if(!SetFileAttributesW(temporary.c_str(),FILE_ATTRIBUTE_NORMAL)) return failure();
|
|
FileHandle out{CreateFileW(temporary.c_str(),FILE_APPEND_DATA,0,nullptr,OPEN_EXISTING,0,nullptr)};
|
|
if(out.value==INVALID_HANDLE_VALUE) return failure();
|
|
LARGE_INTEGER size{};
|
|
if(!GetFileSizeEx(in.value,&size)) return failure();
|
|
Bytes buffer(FileChunk);
|
|
uint64_t done=0;
|
|
for(;;)
|
|
{
|
|
DWORD read{},written{};
|
|
if(!ReadFile(in.value,buffer.data(),static_cast<DWORD>(buffer.size()),&read,nullptr)) return failure();
|
|
if(!read) break;
|
|
if(!WriteFile(out.value,buffer.data(),read,&written,nullptr)) return failure();
|
|
if(written!=read) return failure(ERROR_WRITE_FAULT);
|
|
done+=written;
|
|
if(progress && !progress(done,size.QuadPart)) return failure(ERROR_CANCELLED);
|
|
}
|
|
}
|
|
return commit(destination,replace);
|
|
}
|
|
static Json replaceFile(const fs::path &source,const fs::path &destination,bool replace)
|
|
{
|
|
const auto attributes=GetFileAttributesW(destination.c_str());
|
|
const bool readOnly=replace && attributes!=INVALID_FILE_ATTRIBUTES &&
|
|
(attributes&FILE_ATTRIBUTE_READONLY)!=0;
|
|
if(replace && attributes!=INVALID_FILE_ATTRIBUTES &&
|
|
(attributes&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT))) return failure(ERROR_ACCESS_DENIED);
|
|
if(readOnly && !SetFileAttributesW(destination.c_str(),attributes&~FILE_ATTRIBUTE_READONLY))
|
|
return failure();
|
|
if(!MoveFileExW(source.c_str(),destination.c_str(),replace?MOVEFILE_REPLACE_EXISTING:0))
|
|
{
|
|
const auto error=GetLastError();
|
|
if(readOnly) SetFileAttributesW(destination.c_str(),attributes);
|
|
return failure(error);
|
|
}
|
|
return ok();
|
|
}
|
|
Json commit(const fs::path &destination,bool replace)
|
|
{
|
|
const auto reply=replaceFile(temporary,destination,replace);
|
|
if(reply.at("error")==ERROR_SUCCESS) temporary.clear();
|
|
return reply;
|
|
}
|
|
public:
|
|
explicit FileOperations(bool remote):remote(remote){}
|
|
~FileOperations(){closeSearch();discard();}
|
|
Json call(const Json &request,const FileProgress &progress)
|
|
{
|
|
try {return perform(request,progress);}
|
|
catch(const std::system_error &e)
|
|
{
|
|
if(e.code().value()==ERROR_CANCELLED) discard(true);
|
|
return failure(static_cast<DWORD>(e.code().value()));
|
|
}
|
|
}
|
|
Json perform(const Json &request,const FileProgress &progress)
|
|
{
|
|
const auto action=request.at("action").get<std::string>();
|
|
if(action=="drives")
|
|
{
|
|
auto reply=ok();
|
|
auto &drives=reply["drives"]=Json::array();
|
|
const auto mask=GetLogicalDrives();
|
|
if(!mask) return failure();
|
|
for(int letter=0;letter<26;++letter)
|
|
{
|
|
if(!(mask&(1UL<<letter))) continue;
|
|
const wchar_t root[]{static_cast<wchar_t>(L'A'+letter),L':',L'\\',0};
|
|
const auto type=GetDriveTypeW(root);
|
|
ULARGE_INTEGER total{},free{};
|
|
if(type==DRIVE_FIXED || type==DRIVE_RAMDISK)
|
|
GetDiskFreeSpaceExW(root,&free,&total,nullptr);
|
|
drives.push_back({{"path",utf8(root)},{"type",type},{"total",total.QuadPart},{"free",free.QuadPart}});
|
|
}
|
|
return reply;
|
|
}
|
|
if(action=="listNext") return listNext();
|
|
if(action=="read")
|
|
{
|
|
Bytes data(FileChunk);
|
|
DWORD count{};
|
|
if(!ReadFile(input.value,data.data(),static_cast<DWORD>(data.size()),&count,nullptr)) return failure();
|
|
data.resize(count);
|
|
return {{"error",0},{"data",Json::binary(std::move(data))}};
|
|
}
|
|
if(action=="closeRead"){input.close();return ok();}
|
|
if(action=="abort"){discard(true);return ok();}
|
|
if(action=="hashRead")
|
|
{
|
|
if(input.value==INVALID_HANDLE_VALUE) return failure(ERROR_INVALID_HANDLE);
|
|
return {{"error",0},{"hash",hashPrefix(input.value,request.at("size"),progress)}};
|
|
}
|
|
if(action=="write")
|
|
{
|
|
const auto &data=request.at("data").get_binary();
|
|
if(data.size()>FileChunk) return failure(ERROR_INVALID_DATA);
|
|
LARGE_INTEGER zero{},start{};
|
|
if(!SetFilePointerEx(output.value,zero,&start,FILE_CURRENT)) return failure();
|
|
const auto end=uint64_t(start.QuadPart)+data.size();
|
|
if(end<appendBase || end-appendBase>expectedSize) return failure(ERROR_INVALID_DATA);
|
|
DWORD count{};
|
|
if(WriteFile(output.value,data.data(),static_cast<DWORD>(data.size()),&count,nullptr) &&
|
|
count==data.size() && FlushFileBuffers(output.value)) return ok();
|
|
const auto error=GetLastError();
|
|
if(!SetFilePointerEx(output.value,start,nullptr,FILE_BEGIN) || !SetEndOfFile(output.value))
|
|
discard(true);
|
|
return failure(error?error:ERROR_WRITE_FAULT);
|
|
}
|
|
if(action=="commit")
|
|
{
|
|
if(output.value==INVALID_HANDLE_VALUE) return failure(ERROR_INVALID_HANDLE);
|
|
LARGE_INTEGER size{};
|
|
if(!GetFileSizeEx(output.value,&size)) return failure();
|
|
if(uint64_t(size.QuadPart)!=appendBase+expectedSize) return failure(ERROR_FILE_INVALID);
|
|
const auto stamp=request.at("modified").get<uint64_t>();
|
|
const FILETIME time{static_cast<DWORD>(stamp),static_cast<DWORD>(stamp>>32)};
|
|
if(!SetFileTime(output.value,nullptr,nullptr,&time) || !FlushFileBuffers(output.value)) return failure();
|
|
output.close();
|
|
const auto reply=commit(target,request.at("replace").get<bool>());
|
|
if(reply.at("error")==ERROR_SUCCESS) SetFileAttributesW(target.c_str(),FILE_ATTRIBUTE_ARCHIVE);
|
|
return reply;
|
|
}
|
|
|
|
const auto name=path(request.at("path"));
|
|
if(action=="list")
|
|
{
|
|
closeSearch();
|
|
search=FindFirstFileW((name/L"*").c_str(),&entry);
|
|
pending=search!=INVALID_HANDLE_VALUE;
|
|
if(!pending && GetLastError()!=ERROR_FILE_NOT_FOUND) return failure();
|
|
return listNext();
|
|
}
|
|
if(action=="stat")
|
|
{
|
|
WIN32_FILE_ATTRIBUTE_DATA data{};
|
|
if(!GetFileAttributesExW(name.c_str(),GetFileExInfoStandard,&data)) return failure();
|
|
return {{"error",0},{"attributes",data.dwFileAttributes},{"size",fileSize(data.nFileSizeHigh,data.nFileSizeLow)},
|
|
{"modified",fileSize(data.ftLastWriteTime.dwHighDateTime,data.ftLastWriteTime.dwLowDateTime)}};
|
|
}
|
|
if(action=="canonical")
|
|
{
|
|
std::error_code error;
|
|
const auto canonical=fs::weakly_canonical(name,error);
|
|
return error?failure(error.value()):Json{{"error",0},{"path",utf8(canonical.native())}};
|
|
}
|
|
if(action=="mkdir") return CreateDirectoryW(name.c_str(),nullptr)?ok():failure();
|
|
if(action=="rmdir") return RemoveDirectoryW(name.c_str())?ok():failure();
|
|
if(action=="recycle") return recycleFile(nullptr,name)?ok():failure(ERROR_ACCESS_DENIED);
|
|
if(action=="remove")
|
|
{
|
|
if(request.contains("size"))
|
|
{
|
|
WIN32_FILE_ATTRIBUTE_DATA data{};
|
|
if(!GetFileAttributesExW(name.c_str(),GetFileExInfoStandard,&data)) return failure();
|
|
if((data.dwFileAttributes&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT)) ||
|
|
fileSize(data.nFileSizeHigh,data.nFileSizeLow)!=request.at("size") ||
|
|
fileSize(data.ftLastWriteTime.dwHighDateTime,data.ftLastWriteTime.dwLowDateTime)!=request.at("modified"))
|
|
return failure(ERROR_FILE_INVALID);
|
|
}
|
|
const auto attributes=GetFileAttributesW(name.c_str());
|
|
if(attributes==INVALID_FILE_ATTRIBUTES) return failure();
|
|
if(attributes&FILE_ATTRIBUTE_DIRECTORY) return RemoveDirectoryW(name.c_str())?ok():failure();
|
|
const bool clear=request.value("readOnly",false) && (attributes&FILE_ATTRIBUTE_READONLY) &&
|
|
!(attributes&FILE_ATTRIBUTE_REPARSE_POINT);
|
|
if(clear && !SetFileAttributesW(name.c_str(),attributes&~FILE_ATTRIBUTE_READONLY)) return failure();
|
|
if(DeleteFileW(name.c_str())) return ok();
|
|
const auto error=GetLastError();
|
|
if(clear) SetFileAttributesW(name.c_str(),attributes);
|
|
return failure(error);
|
|
}
|
|
if(action=="move")
|
|
{
|
|
const auto destination=path(request.at("target"));
|
|
const bool replace=request.at("replace").get<bool>();
|
|
if(!replace) return MoveFileExW(name.c_str(),destination.c_str(),0)?ok():failure();
|
|
std::error_code error;
|
|
if(fs::equivalent(name,destination,error)) return failure(ERROR_ALREADY_EXISTS);
|
|
return replaceFile(name,destination,true);
|
|
}
|
|
if(action=="copy")
|
|
{
|
|
const auto destination=path(request.at("target"));
|
|
if(remote && request.contains("size"))
|
|
{
|
|
// Both streams execute inside the serving process.
|
|
FilesConnection source,target;
|
|
streamFile(source,target,"same host",name,destination,request.at("size"),request.at("modified"),
|
|
request.at("replace"),request.at("append"),progress);
|
|
return ok();
|
|
}
|
|
return copy(name,destination,request.at("replace"),request.at("append"),progress);
|
|
}
|
|
if(action=="openRead")
|
|
{
|
|
input.close();
|
|
input.value=CreateFileW(name.c_str(),GENERIC_READ,FILE_SHARE_READ,nullptr,OPEN_EXISTING,
|
|
FILE_FLAG_OPEN_REPARSE_POINT|FILE_FLAG_SEQUENTIAL_SCAN,nullptr);
|
|
if(input.value==INVALID_HANDLE_VALUE) return failure();
|
|
BY_HANDLE_FILE_INFORMATION info{};
|
|
if(!GetFileInformationByHandle(input.value,&info)) return failure();
|
|
if(info.dwFileAttributes&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT))
|
|
return failure(ERROR_ACCESS_DENIED);
|
|
const auto size=fileSize(info.nFileSizeHigh,info.nFileSizeLow);
|
|
const auto modified=fileSize(info.ftLastWriteTime.dwHighDateTime,info.ftLastWriteTime.dwLowDateTime);
|
|
if(size!=request.at("size") || modified!=request.at("modified"))
|
|
return failure(ERROR_FILE_INVALID);
|
|
return ok();
|
|
}
|
|
if(action=="openWrite")
|
|
{
|
|
discard();
|
|
target=name;
|
|
const auto transfer=request.at("transfer").get<std::string>();
|
|
if(transfer.size()!=64 || transfer.find_first_not_of("0123456789abcdef")!=transfer.npos)
|
|
return failure(ERROR_INVALID_DATA);
|
|
expectedSize=request.at("size").get<uint64_t>();
|
|
const bool append=request.value("append",false);
|
|
appendBase=0;
|
|
auto staging=target.parent_path()/wide(".kswitcher-"+transfer+".partial");
|
|
FileHandle original;
|
|
if(append)
|
|
{
|
|
original.value=CreateFileW(target.c_str(),GENERIC_READ,FILE_SHARE_READ,nullptr,OPEN_EXISTING,0,nullptr);
|
|
if(original.value==INVALID_HANDLE_VALUE) return failure();
|
|
BY_HANDLE_FILE_INFORMATION info{};
|
|
if(!GetFileInformationByHandle(original.value,&info)) return failure();
|
|
appendBase=fileSize(info.nFileSizeHigh,info.nFileSizeLow);
|
|
}
|
|
output.value=CreateFileW(staging.c_str(),GENERIC_READ|GENERIC_WRITE,0,nullptr,OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_HIDDEN|FILE_FLAG_OPEN_REPARSE_POINT,nullptr);
|
|
if(output.value==INVALID_HANDLE_VALUE) return failure();
|
|
const bool created=GetLastError()!=ERROR_ALREADY_EXISTS;
|
|
BY_HANDLE_FILE_INFORMATION info{};
|
|
if(!GetFileInformationByHandle(output.value,&info)) return failure();
|
|
if(info.nNumberOfLinks!=1 || (info.dwFileAttributes&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT)))
|
|
return failure(ERROR_ACCESS_DENIED);
|
|
temporary=staging;
|
|
resumable=true;
|
|
if(created && appendBase)
|
|
{
|
|
Bytes buffer(FileChunk);
|
|
for(uint64_t left=appendBase;left;)
|
|
{
|
|
const auto count=static_cast<DWORD>(std::min<uint64_t>(left,buffer.size()));
|
|
DWORD read{},written{};
|
|
if(!ReadFile(original.value,buffer.data(),count,&read,nullptr) || read!=count ||
|
|
!WriteFile(output.value,buffer.data(),read,&written,nullptr) || written!=read)
|
|
{
|
|
discard(true);
|
|
return failure(ERROR_WRITE_FAULT);
|
|
}
|
|
left-=written;
|
|
}
|
|
}
|
|
const auto size=created?appendBase:fileSize(info.nFileSizeHigh,info.nFileSizeLow);
|
|
const bool valid=size>=appendBase && size-appendBase<=expectedSize &&
|
|
(!appendBase || hashPrefix(original.value,appendBase,progress)==hashPrefix(output.value,appendBase,progress));
|
|
if(!valid)
|
|
{
|
|
discard(true);
|
|
return {{"error",0},{"restart",true}};
|
|
}
|
|
const auto offset=size-appendBase;
|
|
return {{"error",0},{"offset",offset},{"hash",hashPrefix(output.value,offset,progress,appendBase)}};
|
|
}
|
|
return failure(ERROR_INVALID_FUNCTION);
|
|
}
|
|
};
|
|
}
|
|
|
|
struct FilesConnection::Impl
|
|
{
|
|
std::optional<Network> network;
|
|
WinSocket socket;
|
|
std::unique_ptr<Wire> wire;
|
|
FileOperations local{false};
|
|
Impl()=default;
|
|
explicit Impl(const FilesPeer *peer)
|
|
{
|
|
if(!peer) return;
|
|
const auto pairing=Json::parse(unprotect(readFile(dataDirectory()/L"lan-pairing.bin",256*1024)));
|
|
if(!pairing.value("enabled",false) || !pairing.at("trusted").contains(peer->id))
|
|
throw std::system_error(ERROR_ACCESS_DENIED,std::system_category());
|
|
const auto id=pairing.at("id").get<std::string>();
|
|
const auto key=pairing.at("trusted").at(peer->id).at("key").get<std::string>();
|
|
connect(*peer,id,key);
|
|
}
|
|
void connect(const FilesPeer &peer,const std::string &id,const std::string &key)
|
|
{
|
|
network.emplace();
|
|
socket.value=::socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
|
|
if(socket.value==INVALID_SOCKET) socketError();
|
|
connectPeer(socket.value,peer);
|
|
wire=std::make_unique<Wire>(socket.value);
|
|
const auto nonce=randomHex(16);
|
|
wire->write({{"version",1},{"client",id},{"server",peer.id},{"nonce",nonce}});
|
|
const auto challenge=wire->read().at("challenge").get<std::string>();
|
|
wire->authenticate(key,id,peer.id,challenge,nonce,true);
|
|
wire->write({{"action","authenticate"}});
|
|
checkFileReply(wire->read());
|
|
}
|
|
};
|
|
|
|
FilesConnection::FilesConnection(const FilesPeer *peer):impl(std::make_unique<Impl>(peer)){}
|
|
FilesConnection::FilesConnection(const FilesPeer &peer,const std::string &local,const std::string &key):
|
|
impl(std::make_unique<Impl>())
|
|
{
|
|
impl->connect(peer,local,key);
|
|
}
|
|
FilesConnection::~FilesConnection()=default;
|
|
Json FilesConnection::call(const Json &request,const FileProgress &progress)
|
|
{
|
|
if(!impl->wire) return impl->local.call(request,progress);
|
|
impl->wire->write(request);
|
|
for(;;)
|
|
{
|
|
auto reply=impl->wire->read();
|
|
if(!reply.contains("progress")) return reply;
|
|
const auto &value=reply.at("progress");
|
|
const bool proceed=!progress || progress(value[0].get<uint64_t>(),value[1].get<uint64_t>());
|
|
impl->wire->write({{"continue",proceed}});
|
|
}
|
|
}
|
|
|
|
void streamFile(FilesConnection &source,FilesConnection &target,const std::string &sourceId,
|
|
const std::filesystem::path &from,const std::filesystem::path &to,uint64_t size,uint64_t modified,
|
|
bool replace,bool append,const FileProgress &progress)
|
|
{
|
|
auto openSource=fileRequest("openRead",from);
|
|
openSource["size"]=size;
|
|
openSource["modified"]=modified;
|
|
checkFileReply(source.call(openSource));
|
|
auto upload=fileRequest("openWrite",to);
|
|
upload["append"]=append;
|
|
upload["size"]=size;
|
|
const auto identity=Json::array({sourceId,ks::utf8(from.native()),ks::utf8(to.native()),
|
|
size,modified,append});
|
|
upload["transfer"]=ks::lan::mac("KSwitcher partial v1",identity.dump());
|
|
uint64_t done=0;
|
|
const auto resumeProgress=[&](uint64_t,uint64_t){return !progress || progress(done,size);};
|
|
try
|
|
{
|
|
for(int attempt=0;;++attempt)
|
|
{
|
|
auto reply=target.call(upload,resumeProgress);
|
|
checkFileReply(reply);
|
|
if(!reply.value("restart",false))
|
|
{
|
|
done=reply.at("offset");
|
|
const auto sourceHash=source.call({{"action","hashRead"},{"size",done}},resumeProgress);
|
|
checkFileReply(sourceHash);
|
|
if(sourceHash.at("hash")==reply.at("hash")) break;
|
|
checkFileReply(target.call({{"action","abort"}}));
|
|
}
|
|
if(attempt>0) throw std::system_error(ERROR_FILE_INVALID,std::system_category());
|
|
}
|
|
while(!progress || progress(done,size))
|
|
{
|
|
auto packet=source.call({{"action","read"}});
|
|
checkFileReply(packet);
|
|
auto &data=packet.at("data").get_binary();
|
|
if(data.empty())
|
|
{
|
|
if(done!=size) throw std::system_error(ERROR_FILE_INVALID,std::system_category());
|
|
checkFileReply(target.call({{"action","commit"},{"replace",replace},{"modified",modified}}));
|
|
checkFileReply(source.call({{"action","closeRead"}}));
|
|
return;
|
|
}
|
|
const auto chunkSize=data.size();
|
|
checkFileReply(target.call({{"action","write"},{"data",std::move(packet.at("data"))}}));
|
|
done+=chunkSize;
|
|
}
|
|
throw std::system_error(ERROR_CANCELLED,std::system_category());
|
|
}
|
|
catch(const std::system_error &error)
|
|
{
|
|
if(error.code().value()==ERROR_CANCELLED)
|
|
checkFileReply(target.call({{"action","abort"}}));
|
|
throw;
|
|
}
|
|
}
|
|
|
|
struct FilesListener::Impl
|
|
{
|
|
struct Client
|
|
{
|
|
WinSocket socket;
|
|
std::atomic<bool> done{};
|
|
std::thread worker;
|
|
~Client()
|
|
{
|
|
shutdown(socket.value,SD_BOTH);
|
|
if(worker.joinable()) worker.join();
|
|
}
|
|
};
|
|
std::string local;
|
|
PairKey key;
|
|
WinSocket listener;
|
|
std::vector<std::unique_ptr<Client>> clients;
|
|
uint16_t boundPort{};
|
|
Impl(std::string id,PairKey lookup,uint16_t port):local(std::move(id)),key(std::move(lookup))
|
|
{
|
|
listener.value=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
|
|
if(listener.value==INVALID_SOCKET) return;
|
|
BOOL exclusive=TRUE;
|
|
u_long mode=1;
|
|
sockaddr_in address{};
|
|
address.sin_family=AF_INET;
|
|
address.sin_port=htons(port);
|
|
if(setsockopt(listener.value,SOL_SOCKET,SO_EXCLUSIVEADDRUSE,reinterpret_cast<const char*>(&exclusive),sizeof(exclusive)) ||
|
|
ioctlsocket(listener.value,FIONBIO,&mode) ||
|
|
bind(listener.value,reinterpret_cast<sockaddr*>(&address),sizeof(address)) ||
|
|
listen(listener.value,8))
|
|
{
|
|
closesocket(std::exchange(listener.value,INVALID_SOCKET));
|
|
return;
|
|
}
|
|
int length=sizeof(address);
|
|
if(!getsockname(listener.value,reinterpret_cast<sockaddr*>(&address),&length))
|
|
boundPort=ntohs(address.sin_port);
|
|
}
|
|
void serve(SOCKET socket)
|
|
{
|
|
Wire wire(socket);
|
|
const auto hello=wire.read();
|
|
const auto peer=hello.at("client").get<std::string>();
|
|
const auto nonce=hello.at("nonce").get<std::string>();
|
|
if(hello.at("version")!=1 || hello.at("server")!=local || !identifier(peer) || !identifier(nonce)) return;
|
|
const auto secret=key(peer);
|
|
if(secret.empty()) return;
|
|
const auto challenge=randomHex(16);
|
|
wire.write({{"challenge",challenge}});
|
|
wire.authenticate(secret,peer,local,challenge,nonce,false);
|
|
if(wire.read().at("action")!="authenticate") return;
|
|
wire.write(ok());
|
|
FileOperations operations(true);
|
|
for(;;)
|
|
{
|
|
const auto request=wire.read(true);
|
|
if(!equal(key(peer),secret)) return;
|
|
wire.write(operations.call(request,[&](uint64_t done,uint64_t total)
|
|
{
|
|
if(!equal(key(peer),secret))
|
|
throw std::system_error(ERROR_ACCESS_DENIED,std::system_category());
|
|
wire.write({{"progress",{done,total}}});
|
|
const bool proceed=wire.read(true).value("continue",false);
|
|
if(!equal(key(peer),secret)) throw std::system_error(ERROR_ACCESS_DENIED,std::system_category());
|
|
return proceed;
|
|
}));
|
|
}
|
|
}
|
|
void poll()
|
|
{
|
|
std::erase_if(clients,[](const auto &client){return client->done.load();});
|
|
if(listener.value==INVALID_SOCKET || clients.size()>=16) return;
|
|
sockaddr_in address{};
|
|
int size=sizeof(address);
|
|
WinSocket accepted{accept(listener.value,reinterpret_cast<sockaddr*>(&address),&size)};
|
|
const auto ip=ntohl(address.sin_addr.s_addr);
|
|
if((ip>>24)!=10 && (ip>>24)!=127 && (ip>>20)!=0xac1 && (ip>>16)!=0xc0a8 && (ip>>16)!=0xa9fe)
|
|
return;
|
|
if(accepted.value==INVALID_SOCKET) return;
|
|
u_long mode=0;
|
|
if(ioctlsocket(accepted.value,FIONBIO,&mode)) return;
|
|
auto client=std::make_unique<Client>();
|
|
client->socket.value=std::exchange(accepted.value,INVALID_SOCKET);
|
|
auto *connection=client.get();
|
|
connection->worker=std::thread([this,connection]
|
|
{
|
|
try {serve(connection->socket.value);} catch(const std::exception &) {}
|
|
connection->done=true;
|
|
});
|
|
clients.push_back(std::move(client));
|
|
}
|
|
};
|
|
|
|
FilesListener::FilesListener(std::string local,PairKey key,uint16_t port):
|
|
impl(std::make_unique<Impl>(std::move(local),std::move(key),port)){}
|
|
FilesListener::~FilesListener()=default;
|
|
uint16_t FilesListener::port()const{return impl->boundPort;}
|
|
void FilesListener::poll(){impl->poll();}
|
|
}
|