mirrors/urbackup_backend
2
0
Fork 0
mirror of https://github.com/uroni/urbackup_backend.git synced 2025-10-26 11:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity
fe33d9b31d
urbackup_backend/urbackupclient/ClientService.cpp
Martin Raiber fe33d9b31d Reorganized directory structure
2012-02-25 02:45:06 +01:00

2792 lines
66 KiB
C++
Raw Blame History

/*************************************************************************
* UrBackup - Client/Server backup system
* Copyright (C) 2011 Martin Raiber
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
**************************************************************************/
#include "ClientService.h"
#include "client.h"
#include "../Interface/Server.h"
#include "../Interface/Database.h"
#include "../Interface/Query.h"
#include "../Interface/SettingsReader.h"
#include "../Interface/File.h"
#include "../Interface/ThreadPool.h"
#include "../stringtools.h"
#include "../urbackupcommon/escape.h"
#include "database.h"
#include "../urbackupcommon/fileclient/data.h"
#include "../fsimageplugin/IFSImageFactory.h"
#include "../fsimageplugin/IFilesystem.h"
#include "../cryptoplugin/ICryptoFactory.h"
#include "../urbackupcommon/sha2/sha2.h"
#include "ClientSend.h"
#include "ServerIdentityMgr.h"
#include "../urbackupcommon/settings.h"
#include "../urbackupcommon/capa_bits.h"
#ifdef _WIN32
#include "win_sysvol.h"
#else
std::wstring getSysVolume(std::wstring &mpath){ return L""; }
#endif
#include <memory.h>
#include <stdlib.h>
#include <limits.h>
#ifndef _WIN32
#define _atoi64 atoll
#endif
extern IFSImageFactory *image_fak;
extern ICryptoFactory *crypto_fak;
extern unsigned char *zero_hash;
extern std::string time_format_str;
ICustomClient* ClientService::createClient()
{
return new ClientConnector();
}
void ClientService::destroyClient( ICustomClient * pClient)
{
delete ((ClientConnector*)pClient);
}
RunningAction ClientConnector::backup_running=RUNNING_NONE;
volatile bool ClientConnector::backup_done=false;
IMutex *ClientConnector::backup_mutex=NULL;
unsigned int ClientConnector::incr_update_intervall=0;
unsigned int ClientConnector::last_pingtime=0;
IPipe *ClientConnector::channel_pipe=NULL;
int ClientConnector::pcdone=0;
int ClientConnector::pcdone2=0;
std::vector<IPipe*> ClientConnector::channel_pipes;
std::vector<IPipe*> ClientConnector::channel_exit;
std::vector<IPipe*> ClientConnector::channel_ping;
std::vector<int> ClientConnector::channel_capa;
IMutex *ClientConnector::progress_mutex=NULL;
volatile bool ClientConnector::img_download_running=false;
db_results ClientConnector::cached_status;
std::string ClientConnector::backup_source_token;
std::map<std::string, unsigned int> ClientConnector::last_token_times;
int ClientConnector::last_capa=0;
const unsigned int x_pingtimeout=180000;
#ifdef _WIN32
const std::string pw_file="pw.txt";
#else
const std::string pw_file="urbackup/pw.txt";
#endif
void ClientConnector::init_mutex(void)
{
if(backup_mutex==NULL)
{
backup_mutex=Server->createMutex();
progress_mutex=Server->createMutex();
}
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_CLIENT);
db_results res=db->Read("SELECT tvalue FROM misc WHERE tkey='last_capa'");
if(!res.empty())
{
last_capa=watoi(res[0][L"last_capa"]);
}
else
{
db->Write("INSERT INTO misc (tkey, tvalue) VALUES ('last_capa', '0');");
last_capa=0;
}
}
bool ClientConnector::wantReceive(void)
{
return want_receive;
}
void ClientConnector::Init(THREAD_ID pTID, IPipe *pPipe)
{
tid=pTID;
pipe=pPipe;
state=CCSTATE_NORMAL;
thread_action=TA_NONE;
mempipe=Server->createMemoryPipe();
lasttime=Server->getTimeMS();
do_quit=false;
is_channel=false;
want_receive=true;
last_channel_ping=0;
file_version=1;
}
ClientConnector::~ClientConnector(void)
{
mempipe->Write("exit");
}
bool ClientConnector::Run(void)
{
if(do_quit)
{
if(is_channel)
{
IScopedLock lock(backup_mutex);
if(channel_pipe==pipe)
{
channel_pipe=NULL;
}
for(size_t i=0;i<channel_pipes.size();++i)
{
if(channel_pipes[i]==pipe)
{
channel_pipes.erase(channel_pipes.begin()+i);
channel_capa.erase(channel_capa.begin()+i);
break;
}
}
for(size_t i=0;i<channel_ping.size();++i)
{
if(channel_ping[i]==pipe)
{
channel_ping.erase(channel_ping.begin()+i);
break;
}
}
}
if(waitForThread())
{
Server->wait(10);
do_quit=true;
return true;
}
return false;
}
switch(state)
{
case CCSTATE_NORMAL:
if(Server->getTimeMS()-lasttime>10000)
{
Server->Log("Client timeout in ClientConnector::Run", LL_DEBUG);
if(waitForThread())
{
do_quit=true;
return true;
}
return false;
}
return true;
case CCSTATE_START_FILEBACKUP:
{
std::string msg;
mempipe->Read(&msg, 0);
if(msg=="exit")
{
mempipe->Write(msg);
if(waitForThread())
{
do_quit=true;
return true;
}
IScopedLock lock(backup_mutex);
backup_running=RUNNING_NONE;
backup_done=true;
return false;
}
else if(msg=="done")
{
tcpstack.Send(pipe, "DONE");
lasttime=Server->getTimeMS();
state=CCSTATE_NORMAL;
}
else if(!msg.empty())
{
tcpstack.Send(pipe, msg);
lasttime=Server->getTimeMS();
state=CCSTATE_NORMAL;
IScopedLock lock(backup_mutex);
backup_running=RUNNING_NONE;
backup_done=true;
}
else if(file_version>1 && Server->getTimeMS()-last_update_time>30000)
{
last_update_time=Server->getTimeMS();
tcpstack.Send(pipe, "BUSY");
}
}break;
case CCSTATE_SHADOWCOPY:
{
std::string msg;
mempipe->Read(&msg, 0);
if(msg=="exit")
{
mempipe->Write(msg);
if(waitForThread())
{
do_quit=true;
return true;
}
return false;
}
else if(msg.find("done")==0)
{
tcpstack.Send(pipe, "DONE");
lasttime=Server->getTimeMS();
state=CCSTATE_NORMAL;
}
else if(msg.find("failed")==0)
{
tcpstack.Send(pipe, "FAILED");
lasttime=Server->getTimeMS();
state=CCSTATE_NORMAL;
}
}break;
case CCSTATE_CHANNEL: //Channel
{
IScopedLock lock(backup_mutex);
if(Server->getTimeMS()-lasttime>180000)
{
Server->Log("Client timeout in ClientConnector::Run - Channel", LL_DEBUG);
{
if(channel_pipe==pipe)
channel_pipe=NULL;
for(size_t i=0;i<channel_pipes.size();++i)
{
if(channel_pipes[i]==pipe)
{
channel_pipes.erase(channel_pipes.begin()+i);
channel_capa.erase(channel_capa.begin()+i);
break;
}
}
for(size_t i=0;i<channel_ping.size();++i)
{
if(channel_ping[i]==pipe)
{
channel_ping.erase(channel_ping.begin()+i);
break;
}
}
}
if(waitForThread())
{
do_quit=true;
return true;
}
return false;
}
for(size_t i=0;i<channel_exit.size();++i)
{
if(channel_exit[i]==pipe)
{
do_quit=true;
channel_exit.erase(channel_exit.begin()+i);
break;
}
}
if(Server->getTimeMS()-last_channel_ping>60000)
{
bool found=false;
for(size_t i=0;i<channel_ping.size();++i)
{
if(channel_ping[i]==pipe)
{
found=true;
break;
}
}
if(!found)
{
channel_ping.push_back(pipe);
}
tcpstack.Send(pipe, "PING");
last_channel_ping=Server->getTimeMS();
}
}break;
case CCSTATE_IMAGE:
case CCSTATE_IMAGE_HASHDATA:
{
if(Server->getThreadPool()->isRunning(thread_ticket)==false )
{
return false;
}
}break;
case CCSTATE_UPDATE_DATA:
case CCSTATE_UPDATE_FINISH:
{
if(Server->getTimeMS()-lasttime>10000)
{
Server->Log("Client timeout in ClientConnector::Run-update(state6|7)", LL_DEBUG);
if(waitForThread())
{
do_quit=true;
return true;
}
return false;
}
if(state==CCSTATE_UPDATE_FINISH)
{
if(hashdataok)
{
hashdatafile->Seek(0);
writeUpdateFile(hashdatafile, "version_new.txt");
writeUpdateFile(hashdatafile, "UrBackupUpdate.sig");
writeUpdateFile(hashdatafile, "UrBackupUpdate_untested.exe");
if(crypto_fak!=NULL)
{
IFile *updatefile=Server->openFile("UrBackupUpdate_untested.exe");
if(updatefile!=NULL)
{
if(checkHash(getSha512Hash(updatefile)))
{
Server->destroy(updatefile);
if(crypto_fak->verifyFile("urbackup_dsa.pub", "UrBackupUpdate_untested.exe", "UrBackupUpdate.sig"))
{
Server->deleteFile("version.txt");
Server->deleteFile("UrBackupUpdate.exe");
moveFile(L"UrBackupUpdate_untested.exe", L"UrBackupUpdate.exe");
moveFile(L"version_new.txt", L"version.txt");
tcpstack.Send(pipe, "ok");
}
else
{
Server->Log("Verifying update file failed. Signature did not match", LL_ERROR);
tcpstack.Send(pipe, "verify_sig_err");
}
}
else
{
Server->destroy(updatefile);
Server->Log("Verifing update file failed. Update was installed previously", LL_ERROR);
tcpstack.Send(pipe, "verify_sig_already_used_err");
}
}
}
else
{
Server->Log("Verifing update file failed. Cryptomodule not present", LL_ERROR);
tcpstack.Send(pipe, "verify_cryptmodule_err");
}
}
else
{
do_quit=true;
}
}
return true;
}break;
case CCSTATE_WAIT_FOR_CONTRACTORS: // wait for contractors
{
for(size_t i=0;i<contractors.size();++i)
{
std::string resp;
contractors[i]->Read(&resp, 0);
if(!resp.empty())
{
contractors[i]->Write("exit");
contractors.erase(contractors.begin()+i);
break;
}
}
if(contractors.empty())
{
return false;
}
}break;
}
return true;
}
std::string ClientConnector::getSha512Hash(IFile *fn)
{
sha512_ctx ctx;
char buf[4096];
_u32 r;
sha512_init(&ctx);
while((r=fn->Read(buf, 4096))!=0)
{
sha512_update(&ctx, (unsigned char*)buf, r);
}
unsigned char digest[64];
sha512_final(&ctx,digest);
return bytesToHex(digest, 64);
}
bool ClientConnector::checkHash(std::string shah)
{
std::string prev_h=getFile("updates_h.dat");
int lc=linecount(prev_h);
for(int i=0;i<lc;++i)
{
std::string l=strlower(trim(getline(i, prev_h)));
if(l==shah)
{
return false;
}
}
return true;
}
bool ClientConnector::writeUpdateFile(IFile *datafile, std::string outfn)
{
unsigned int size;
if(datafile->Read((char*)&size, sizeof(unsigned int))!=sizeof(unsigned int))
return false;
IFile *out=Server->openFile(outfn, MODE_WRITE);
if(out==NULL)
return false;
size_t read=0;
char buf[4096];
while(true)
{
size_t tr=(std::min)((size_t)4096, size-read);
if(tr==0)
break;
if(datafile->Read(buf, (_u32)tr)!=tr)
{
Server->destroy(out);
return false;
}
if(out->Write(buf, (_u32)tr)!=tr)
{
Server->destroy(out);
return false;
}
read+=tr;
}
Server->destroy(out);
return true;
}
void ClientConnector::ReceivePackets(void)
{
if(state==CCSTATE_WAIT_FOR_CONTRACTORS)
{
return;
}
IMutex *l_mutex=NULL;
if(is_channel)
{
l_mutex=backup_mutex;
}
IScopedLock g_lock(l_mutex);
std::string cmd;
size_t rc=pipe->Read(&cmd, is_channel?0:-1);
if(rc==0 )
{
Server->Log("rc=0 hasError="+nconvert(pipe->hasError())+" state="+nconvert(state), LL_DEBUG);
#ifdef _WIN32
#ifdef _DEBUG
Server->Log("Err: "+nconvert((int)GetLastError()), LL_DEBUG);
#endif
#endif
if(is_channel && pipe->hasError())
{
do_quit=true;
}
else if(!is_channel)
{
do_quit=true;
}
else
{
lasttime=Server->getTimeMS();
}
return;
}
if(state==CCSTATE_IMAGE_HASHDATA || state==CCSTATE_UPDATE_DATA)
{
lasttime=Server->getTimeMS();
if(hashdatafile->Write(cmd)!=cmd.size())
{
Server->Log("Error writing to hashdata temporary file", LL_ERROR);
do_quit=true;
return;
}
if(hashdataleft>=cmd.size())
{
hashdataleft-=(_u32)cmd.size();
Server->Log("Hashdataleft: "+nconvert(hashdataleft), LL_DEBUG);
}
else
{
Server->Log("Too much hashdata - error", LL_ERROR);
}
if(hashdataleft==0)
{
hashdataok=true;
if(state==CCSTATE_IMAGE_HASHDATA)
state=CCSTATE_IMAGE;
else if(state==CCSTATE_UPDATE_DATA)
state=CCSTATE_UPDATE_FINISH;
return;
}
}
tcpstack.AddData((char*)cmd.c_str(), cmd.size());
size_t packetsize;
char *ccstr;
while( (ccstr=tcpstack.getPacket(&packetsize))!=NULL)
{
cmd.resize(packetsize);
if(packetsize>0)
{
memcpy(&cmd[0], ccstr, packetsize);
}
delete [] ccstr;
Server->Log("ClientService cmd: "+cmd, LL_DEBUG);
bool pw_ok=false;
std::string identity;
bool ident_ok=false;
str_map params;
size_t hashpos;
if(cmd.size()>3 && cmd[0]=='#' && cmd[1]=='I' )
{
identity=getbetween("#I", "#", cmd);
cmd.erase(0, identity.size()+3);
size_t tp=cmd.find("#token=");
if(tp!=std::string::npos)
{
server_token=cmd.substr(tp+7);
cmd.erase(tp, cmd.size()-tp);
}
}
else if((hashpos=cmd.find("#"))!=std::string::npos)
{
ParseParamStr(getafter("#", cmd), &params);
cmd.erase(hashpos, cmd.size()-hashpos);
if(!checkPassword(params[L"pw"]))
{
Server->Log("Password wrong!", LL_ERROR);
break;
}
else
{
pw_ok=true;
}
}
if(!identity.empty() && ServerIdentityMgr::checkServerIdentity(identity)==true)
{
ident_ok=true;
}
if(cmd=="ADD IDENTITY")
{
if(identity.empty())
{
tcpstack.Send(pipe, "Identity empty");
}
else
{
if(Server->getServerParameter("restore_mode")=="true" && !ident_ok )
{
ServerIdentityMgr::addServerIdentity(identity);
tcpstack.Send(pipe, "OK");
}
else if( ident_ok )
{
tcpstack.Send(pipe, "OK");
}
else
{
if( ServerIdentityMgr::numServerIdentities()==0 )
{
ServerIdentityMgr::addServerIdentity(identity);
tcpstack.Send(pipe, "OK");
}
else
{
tcpstack.Send(pipe, "failed");
}
}
}
}
else if( (cmd=="START BACKUP" || cmd=="2START BACKUP") && ident_ok==true)
{
if(cmd=="2START BACKUP") file_version=2;
state=CCSTATE_START_FILEBACKUP;
CWData data;
data.addChar(0);
data.addVoidPtr(mempipe);
data.addString(server_token);
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
lasttime=Server->getTimeMS();
IScopedLock lock(backup_mutex);
backup_running=RUNNING_INCR_FILE;
last_pingtime=Server->getTimeMS();
pcdone=0;
backup_source_token=server_token;
}
else if( (cmd=="START FULL BACKUP" || cmd=="2START FULL BACKUP") && ident_ok==true)
{
if(cmd=="2START FULL BACKUP") file_version=2;
state=CCSTATE_START_FILEBACKUP;
CWData data;
data.addChar(1);
data.addVoidPtr(mempipe);
data.addString(server_token);
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
lasttime=Server->getTimeMS();
IScopedLock lock(backup_mutex);
backup_running=RUNNING_FULL_FILE;
last_pingtime=Server->getTimeMS();
pcdone=0;
backup_source_token=server_token;
}
else if(cmd.find("START SC \"")!=std::string::npos && ident_ok==true)
{
#ifdef _WIN32
if(cmd[cmd.size()-1]=='"')
{
state=CCSTATE_SHADOWCOPY;
std::string dir=cmd.substr(10, cmd.size()-11);
CWData data;
data.addChar(2);
data.addVoidPtr(mempipe);
data.addString(dir);
data.addString(server_token);
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
lasttime=Server->getTimeMS();
}
else
{
Server->Log("Invalid command", LL_ERROR);
}
#else
tcpstack.Send(pipe, "DONE");
#endif
}
else if(cmd.find("STOP SC \"")!=std::string::npos && ident_ok==true)
{
#ifdef _WIN32
if(cmd[cmd.size()-1]=='"')
{
state=CCSTATE_SHADOWCOPY;
std::string dir=cmd.substr(9, cmd.size()-10);
CWData data;
data.addChar(3);
data.addVoidPtr(mempipe);
data.addString(dir);
data.addString(server_token);
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
lasttime=Server->getTimeMS();
}
else
{
Server->Log("Invalid command", LL_ERROR);
}
#else
tcpstack.Send(pipe, "DONE");
#endif
}
else if(cmd.find("INCRINTERVALL \"")!=std::string::npos && ident_ok==true)
{
if(cmd[cmd.size()-1]=='"')
{
std::string intervall=cmd.substr(15, cmd.size()-16);
incr_update_intervall=atoi(intervall.c_str());
tcpstack.Send(pipe, "OK");
lasttime=Server->getTimeMS();
}
else
{
Server->Log("Invalid command", LL_ERROR);
}
}
else if(cmd.find("1GET BACKUP DIRS")==0 && pw_ok==true)
{
getBackupDirs(1);
lasttime=Server->getTimeMS();
}
else if(cmd.find("GET BACKUP DIRS")==0 && pw_ok==true)
{
getBackupDirs();
lasttime=Server->getTimeMS();
}
else if(cmd.find("SAVE BACKUP DIRS")==0 && pw_ok==true)
{
if(saveBackupDirs(params))
{
tcpstack.Send(pipe, "OK");
}
lasttime=Server->getTimeMS();
}
else if(cmd.find("GET INCRINTERVALL")==0 && pw_ok==true)
{
if(incr_update_intervall==0 )
{
tcpstack.Send(pipe, nconvert(0));
}
else
{
tcpstack.Send(pipe, nconvert(incr_update_intervall+10*60) );
}
lasttime=Server->getTimeMS();
}
else if(cmd=="DID BACKUP" && ident_ok==true)
{
updateLastBackup();
tcpstack.Send(pipe, "OK");
{
IScopedLock lock(backup_mutex);
if(backup_running==RUNNING_INCR_FILE || backup_running==RUNNING_FULL_FILE)
{
backup_running=RUNNING_NONE;
backup_done=true;
}
lasttime=Server->getTimeMS();
}
IndexThread::execute_postbackup_hook();
}
else if(cmd.find("STATUS")==0 && pw_ok==true)
{
getBackupStatus();
lasttime=Server->getTimeMS();
}
else if(cmd.find("SETTINGS ")==0 && ident_ok==true)
{
std::string s_settings=cmd.substr(9);
unescapeMessage(s_settings);
updateSettings( s_settings );
tcpstack.Send(pipe, "OK");
lasttime=Server->getTimeMS();
}
else if(cmd.find("PING RUNNING")==0 && ident_ok==true)
{
tcpstack.Send(pipe, "OK");
IScopedLock lock(backup_mutex);
lasttime=Server->getTimeMS();
last_pingtime=Server->getTimeMS();
int pcdone_new=atoi(getbetween("-","-", cmd).c_str());
if(backup_source_token.empty() || backup_source_token==server_token )
{
pcdone=pcdone_new;
}
last_token_times[server_token]=Server->getTimeSeconds();
#ifdef _WIN32
SetThreadExecutionState(ES_SYSTEM_REQUIRED);
#endif
}
else if( (cmd=="CHANNEL" || cmd.find("1CHANNEL")==0 ) && ident_ok==true)
{
if(!img_download_running)
{
g_lock.relock(backup_mutex);
channel_pipe=pipe;
channel_pipes.push_back(pipe);
is_channel=true;
state=CCSTATE_CHANNEL;
last_channel_ping=Server->getTimeMS();
lasttime=Server->getTimeMS();
Server->Log("New channel: Number of Channels: "+nconvert((int)channel_pipes.size()), LL_DEBUG);
int capa=0;
if(cmd.find("1CHANNEL ")==0)
{
std::string s_params=cmd.substr(9);
str_map params;
ParseParamStr(s_params, &params);
capa=watoi(params[L"capa"]);
}
channel_capa.push_back(capa);
}
}
else if(cmd=="PONG" && is_channel==true )
{
lasttime=Server->getTimeMS();
IScopedLock lock(backup_mutex);
for(size_t i=0;i<channel_ping.size();++i)
{
if(channel_ping[i]==pipe)
{
channel_ping.erase(channel_ping.begin()+i);
break;
}
}
}
else if(cmd=="PING" && is_channel==true )
{
lasttime=Server->getTimeMS();
if(tcpstack.Send(pipe, "PONG")==0)
{
do_quit=true;
}
}
else if(cmd.find("START BACKUP INCR")==0 && pw_ok==true )
{
IScopedLock lock(backup_mutex);
lasttime=Server->getTimeMS();
if(backup_running!=RUNNING_NONE && Server->getTimeMS()-last_pingtime<x_pingtimeout)
tcpstack.Send(pipe, "RUNNING");
else
{
bool ok=false;
if(channel_pipe!=NULL)
{
_u32 rc=(_u32)tcpstack.Send(channel_pipe, "START BACKUP INCR");
if(rc!=0)
ok=true;
}
if(!ok)
{
tcpstack.Send(pipe, "FAILED");
}
else
{
tcpstack.Send(pipe, "OK");
}
}
}
else if(cmd.find("START BACKUP FULL")==0 && pw_ok==true )
{
IScopedLock lock(backup_mutex);
lasttime=Server->getTimeMS();
if(backup_running!=RUNNING_NONE && Server->getTimeMS()-last_pingtime<x_pingtimeout)
tcpstack.Send(pipe, "RUNNING");
else
{
bool ok=false;
if(channel_pipe!=NULL)
{
_u32 rc=(_u32)tcpstack.Send(channel_pipe, "START BACKUP FULL");
if(rc!=0)
ok=true;
}
if(!ok)
{
tcpstack.Send(pipe, "FAILED");
}
else
{
tcpstack.Send(pipe, "OK");
}
}
}
else if(cmd.find("START IMAGE FULL")==0 && pw_ok==true )
{
IScopedLock lock(backup_mutex);
lasttime=Server->getTimeMS();
if(backup_running!=RUNNING_NONE && Server->getTimeMS()-last_pingtime<x_pingtimeout )
tcpstack.Send(pipe, "RUNNING");
else
{
bool ok=false;
if(channel_pipe!=NULL)
{
_u32 rc=(_u32)tcpstack.Send(channel_pipe, "START IMAGE FULL");
if(rc!=0)
ok=true;
}
if(!ok)
{
tcpstack.Send(pipe, "FAILED");
}
else
{
tcpstack.Send(pipe, "OK");
}
}
}
else if(cmd.find("START IMAGE INCR")==0 && pw_ok==true )
{
IScopedLock lock(backup_mutex);
lasttime=Server->getTimeMS();
if(backup_running!=RUNNING_NONE && Server->getTimeMS()-last_pingtime<x_pingtimeout)
tcpstack.Send(pipe, "RUNNING");
else
{
bool ok=false;
if(channel_pipe!=NULL)
{
_u32 rc=(_u32)tcpstack.Send(channel_pipe, "START IMAGE INCR");
if(rc!=0)
ok=true;
}
if(!ok)
{
tcpstack.Send(pipe, "FAILED");
}
else
{
tcpstack.Send(pipe, "OK");
}
}
}
else if(cmd.find("UPDATE SETTINGS ")==0 && pw_ok==true )
{
std::string s_settings=cmd.substr(16);
lasttime=Server->getTimeMS();
unescapeMessage(s_settings);
replaceSettings( s_settings );
IScopedLock lock(backup_mutex);
bool ok=false;
for(size_t o=0;o<channel_pipes.size();++o)
{
_u32 rc=(_u32)tcpstack.Send(channel_pipes[o], "UPDATE SETTINGS");
if(rc!=0)
ok=true;
}
if(!ok)
{
tcpstack.Send(pipe, "FAILED");
}
else
{
tcpstack.Send(pipe, "OK");
}
}
else if(cmd.find("2LOGDATA ")==0 && ident_ok==true)
{
std::string ldata=cmd.substr(9);
size_t cpos=ldata.find(" ");
std::string created=getuntil(" ", ldata);
lasttime=Server->getTimeMS();
saveLogdata(created, getafter(" ",ldata));
tcpstack.Send(pipe, "OK");
}
else if(cmd.find("PAUSE ")==0 && pw_ok==true)
{
lasttime=Server->getTimeMS();
std::string b=cmd.substr(6);
bool ok=false;
if(b=="true")
{
ok=true;
IdleCheckerThread::setPause(true);
IndexThread::getFileSrv()->setPause(true);
}
else if(b=="false")
{
ok=true;
IdleCheckerThread::setPause(false);
IndexThread::getFileSrv()->setPause(false);
}
if(ok) tcpstack.Send(pipe, "OK");
else tcpstack.Send(pipe, "FAILED");
}
else if(cmd.find("GET LOGPOINTS")==0 && pw_ok==true)
{
lasttime=Server->getTimeMS();
tcpstack.Send(pipe, getLogpoints() );
}
else if(cmd.find("GET LOGDATA")==0 && pw_ok==true )
{
lasttime=Server->getTimeMS();
int logid=watoi(params[L"logid"]);
int loglevel=watoi(params[L"loglevel"]);
std::string ret;
getLogLevel(logid, loglevel, ret);
tcpstack.Send(pipe, ret);
}
else if(cmd.find("FULL IMAGE ")==0)
{
if(ident_ok==true)
{
lasttime=Server->getTimeMS();
std::string s_params=cmd.substr(11);
str_map params;
ParseParamStr(s_params, &params);
server_token=Server->ConvertToUTF8(params[L"token"]);
image_letter=Server->ConvertToUTF8(params[L"letter"]);
shadowdrive=Server->ConvertToUTF8(params[L"shadowdrive"]);
if(params.find(L"start")!=params.end())
{
startpos=(uint64)_atoi64(Server->ConvertToUTF8(params[L"start"]).c_str());
}
else
{
startpos=0;
}
if(params.find(L"shadowid")!=params.end())
{
shadow_id=watoi(params[L"shadowid"]);
}
else
{
shadow_id=-1;
}
no_shadowcopy=false;
if(image_letter=="SYSVOL")
{
std::wstring mpath;
std::wstring sysvol=getSysVolume(mpath);
if(!mpath.empty())
{
image_letter=Server->ConvertToUTF8(mpath);
}
else
{
image_letter=Server->ConvertToUTF8(sysvol);
no_shadowcopy=true;
}
}
if(startpos==0 && !no_shadowcopy)
{
CWData data;
data.addChar(2);
data.addVoidPtr(mempipe);
data.addString(image_letter);
data.addString(server_token);
data.addUChar(1); //image backup
data.addUChar(0); //filesrv
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
}
else if(shadow_id!=-1)
{
shadowdrive.clear();
CWData data;
data.addChar(4);
data.addVoidPtr(mempipe);
data.addInt(shadow_id);
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
}
if(no_shadowcopy)
{
shadowdrive=image_letter;
if(!shadowdrive.empty() && shadowdrive[0]!='\\')
{
shadowdrive="\\\\.\\"+image_letter;
}
}
lasttime=Server->getTimeMS();
sendFullImage();
}
else
{
ImageErr("Ident reset (1)");
}
}
else if(cmd.find("INCR IMAGE ")==0 && ident_ok==true)
{
if(ident_ok==true)
{
lasttime=Server->getTimeMS();
std::string s_params=cmd.substr(11);
str_map params;
ParseParamStr(s_params, &params);
server_token=Server->ConvertToUTF8(params[L"token"]);
str_map::iterator f_hashsize=params.find(L"hashsize");
if(f_hashsize!=params.end())
{
hashdataok=false;
hashdataleft=watoi(f_hashsize->second);
image_letter=Server->ConvertToUTF8(params[L"letter"]);
shadowdrive=Server->ConvertToUTF8(params[L"shadowdrive"]);
if(params.find(L"start")!=params.end())
{
startpos=(uint64)_atoi64(Server->ConvertToUTF8(params[L"start"]).c_str());
}
else
{
startpos=0;
}
if(params.find(L"shadowid")!=params.end())
{
shadow_id=watoi(params[L"shadowid"]);
}
else
{
shadow_id=-1;
}
no_shadowcopy=false;
if(startpos==0)
{
CWData data;
data.addChar(2);
data.addVoidPtr(mempipe);
data.addString(image_letter);
data.addString(server_token);
data.addUChar(1); //image backup
data.addUChar(0); //file serv?
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
}
else if(shadow_id!=-1)
{
shadowdrive.clear();
CWData data;
data.addChar(4);
data.addVoidPtr(mempipe);
data.addInt(shadow_id);
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
}
hashdatafile=Server->openTemporaryFile();
if(hashdatafile==NULL)
continue;
if(tcpstack.getBuffersize()>0)
{
if(hashdatafile->Write(tcpstack.getBuffer(), (_u32)tcpstack.getBuffersize())!=tcpstack.getBuffersize())
{
Server->Log("Error writing to hashdata temporary file -1", LL_ERROR);
do_quit=true;
return;
}
if(hashdataleft>=tcpstack.getBuffersize())
{
hashdataleft-=(_u32)tcpstack.getBuffersize();
//Server->Log("Hashdataleft: "+nconvert(hashdataleft), LL_DEBUG);
}
else
{
Server->Log("Too much hashdata - error -1", LL_ERROR);
}
if(hashdataleft==0)
{
hashdataok=true;
state=CCSTATE_IMAGE;
return;
}
}
lasttime=Server->getTimeMS();
sendIncrImage();
}
else
{
ImageErr("Ident reset (2)");
}
}
}
else if( cmd.find("MBR ")==0 && ident_ok==true )
{
lasttime=Server->getTimeMS();
std::string s_params=cmd.substr(4);
str_map params;
ParseParamStr(s_params, &params);
std::wstring dl=params[L"driveletter"];
if(dl==L"SYSVOL")
{
std::wstring mpath;
dl=getSysVolume(mpath);
}
bool b=false;
if(!dl.empty())
{
b=sendMBR(dl);
}
if(!b)
{
CWData r;r.addChar(0);
tcpstack.Send(pipe, r);
}
}
else if( cmd.find("GET BACKUPCLIENTS")==0 && pw_ok==true )
{
lasttime=Server->getTimeMS();
IScopedLock lock(backup_mutex);
waitForPings(&lock);
if(channel_pipes.size()==0)
{
tcpstack.Send(pipe, "0");
}
else
{
std::string clients;
for(size_t i=0;i<channel_pipes.size();++i)
{
tcpstack.Send(channel_pipes[i], "GET BACKUPCLIENTS");
if(channel_pipes[i]->hasError())
Server->Log("Channel has error after request -1", LL_DEBUG);
std::string nc=receivePacket(channel_pipes[i]);
if(channel_pipes[i]->hasError())
Server->Log("Channel has error after read -1", LL_DEBUG);
Server->Log("Client "+nconvert(i)+"/"+nconvert(channel_pipes.size())+": --"+nc+"--", LL_DEBUG);
if(!nc.empty())
{
clients+=nc+"\n";
}
}
tcpstack.Send(pipe, "1"+clients);
}
}
else if( cmd.find("GET BACKUPIMAGES ")==0 && pw_ok==true )
{
lasttime=Server->getTimeMS();
IScopedLock lock(backup_mutex);
waitForPings(&lock);
if(channel_pipes.size()==0)
{
tcpstack.Send(pipe, "0");
}
else
{
std::string imgs;
for(size_t i=0;i<channel_pipes.size();++i)
{
tcpstack.Send(channel_pipes[i], cmd);
std::string nc=receivePacket(channel_pipes[i]);
if(!nc.empty())
{
imgs+=nc+"\n";
}
}
tcpstack.Send(pipe, "1"+imgs);
}
}
else if( cmd.find("DOWNLOAD IMAGE")==0 && pw_ok==true )
{
lasttime=Server->getTimeMS();
Server->Log("Downloading image...", LL_DEBUG);
IScopedLock lock(backup_mutex);
waitForPings(&lock);
Server->Log("In mutex...",LL_DEBUG);
img_download_running=true;
downloadImage(params);
img_download_running=false;
Server->Log("Donwload done -2", LL_DEBUG);
do_quit=true;
}
else if( cmd.find("GET DOWNLOADPROGRESS")==0 && pw_ok==true)
{
Server->Log("Sending progress...", LL_DEBUG);
lasttime=Server->getTimeMS();
if(img_download_running==false)
{
pipe->Write("100");
do_quit=true;
}
else
{
while(img_download_running)
{
{
int progress=0;
{
IScopedLock lock(progress_mutex);
progress=pcdone;
}
if(!pipe->Write(nconvert(progress)+"\n", 10000))
{
break;
}
}
{
Server->wait(1000);
}
}
do_quit=true;
}
}
else if( cmd.find("VERSION ")==0 && ident_ok==true )
{
int n_version=atoi(cmd.substr(8).c_str());
std::string version_1=getFile("version.txt");
std::string version_2=getFile("curr_version.txt");
if(version_1.empty() ) version_1="0";
if(version_2.empty() ) version_2="0";
#ifdef _WIN32
if( atoi(version_1.c_str())<n_version && atoi(version_2.c_str())<n_version )
{
tcpstack.Send(pipe, "update");
}
else
{
#endif
tcpstack.Send(pipe, "noop");
#ifdef _WIN32
}
#endif
}
else if( cmd.find("CLIENTUPDATE ")==0 && ident_ok==true )
{
hashdatafile=Server->openTemporaryFile();
if(hashdatafile==NULL)
continue;
hashdataleft=atoi(cmd.substr(13).c_str());
hashdataok=false;
state=CCSTATE_UPDATE_DATA;
if(tcpstack.getBuffersize()>0)
{
if(hashdatafile->Write(tcpstack.getBuffer(), (_u32)tcpstack.getBuffersize())!=tcpstack.getBuffersize())
{
Server->Log("Error writing to hashdata temporary file -1update", LL_ERROR);
do_quit=true;
return;
}
if(hashdataleft>=tcpstack.getBuffersize())
{
hashdataleft-=(_u32)tcpstack.getBuffersize();
//Server->Log("Hashdataleft: "+nconvert(hashdataleft), LL_DEBUG);
}
else
{
Server->Log("Too much hashdata - error -1update", LL_ERROR);
}
if(hashdataleft==0)
{
hashdataok=true;
state=CCSTATE_UPDATE_FINISH;
return;
}
}
return;
}
else if(cmd.find("CAPA")==0 && ident_ok==true)
{
#ifdef _WIN32
tcpstack.Send(pipe, "FILE=2&IMAGE=1&UPDATE=1&MBR=1&FILESRV=1");
#else
tcpstack.Send(pipe, "FILE=2&FILESRV=1");
#endif
}
else
{
tcpstack.Send(pipe, "ERR");
}
}
}
bool ClientConnector::checkPassword(const std::wstring &pw)
{
static std::string stored_pw=getFile(pw_file);
return stored_pw==Server->ConvertToUTF8(pw);
}
void ClientConnector::getBackupDirs(int version)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_CLIENT);
IQuery *q=db->Prepare("SELECT id,name,path FROM backupdirs");
int timeoutms=300;
db_results res=q->Read(&timeoutms);
if(timeoutms==0)
{
std::string msg;
for(size_t i=0;i<res.size();++i)
{
if(res[i][L"name"]==L"*") continue;
msg+=Server->ConvertToUTF8(res[i][L"id"])+"\n";
if(version!=0)
{
msg+=Server->ConvertToUTF8(res[i][L"name"])+"|";
}
msg+=Server->ConvertToUTF8(res[i][L"path"]);
if(i+1<res.size())
msg+="\n";
}
tcpstack.Send(pipe, msg);
}
else
{
pipe->shutdown();
}
db->destroyAllQueries();
}
std::wstring removeChars(std::wstring in)
{
wchar_t illegalchars[] = {'*', ':', '/' , '\\'};
std::wstring ret;
for(size_t i=0;i<in.size();++i)
{
bool found=false;
for(size_t j=0;j<sizeof(illegalchars);++j)
{
if(illegalchars[j]==in[i])
{
found=true;
break;
}
}
if(!found)
{
ret+=in[i];
}
}
return ret;
}
bool ClientConnector::saveBackupDirs(str_map &args, bool server_default)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_CLIENT);
db->BeginTransaction();
db_results backupdirs=db->Prepare("SELECT name, path FROM backupdirs")->Read();
db->Prepare("DELETE FROM backupdirs")->Write();
IQuery *q=db->Prepare("INSERT INTO backupdirs (name, path, server_default) VALUES (?, ? ,"+nconvert(server_default?1:0)+")");
if(server_default==false)
{
q->Bind(L"*"); q->Bind(L"*");;
q->Write();
q->Reset();
}
IQuery *q2=db->Prepare("SELECT id FROM backupdirs WHERE name=?");
std::wstring dir;
size_t i=0;
std::vector<std::wstring> new_watchdirs;
do
{
dir=args[L"dir_"+convert(i)];
if(!dir.empty())
{
std::wstring name;
str_map::iterator name_arg=args.find(L"dir_"+convert(i)+L"_name");
if(name_arg!=args.end() && !name_arg->second.empty())
name=name_arg->second;
else
name=ExtractFileName(dir);
name=removeChars(name);
if(dir[dir.size()-1]=='\\' || dir[dir.size()-1]=='/' )
dir.erase(dir.size()-1,1);
q2->Bind(name);
if(q2->Read().empty()==false)
{
for(int k=0;k<100;++k)
{
q2->Reset();
q2->Bind(name+L"_"+convert(k));
if(q2->Read().empty()==true)
{
name+=L"_"+convert(k);
break;
}
}
}
q2->Reset();
bool found=false;
for(size_t i=0;i<backupdirs.size();++i)
{
if(backupdirs[i][L"path"]==dir)
{
backupdirs[i][L"need"]=L"1";
found=true;
break;
}
}
if(!found)
{
//It's not already watched. Add it
new_watchdirs.push_back(dir);
}
q->Bind(name);
q->Bind(dir);
q->Write();
q->Reset();
}
++i;
}
while(!dir.empty());
db->EndTransaction();
#ifdef _WIN32
for(size_t i=0;i<new_watchdirs.size();++i)
{
//Add watch
IPipe *contractor=Server->createMemoryPipe();
CWData data;
data.addChar(5);
data.addVoidPtr(contractor);
data.addString(Server->ConvertToUTF8(new_watchdirs[i]));
IndexThread::stopIndex();
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
contractors.push_back(contractor);
state=CCSTATE_WAIT_FOR_CONTRACTORS;
want_receive=false;
}
for(size_t i=0;i<backupdirs.size();++i)
{
if(backupdirs[i][L"need"]!=L"1")
{
//Delete the watch
IPipe *contractor=Server->createMemoryPipe();
CWData data;
data.addChar(6);
data.addVoidPtr(contractor);
data.addString(Server->ConvertToUTF8(backupdirs[i][L"path"]));
IndexThread::stopIndex();
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
contractors.push_back(contractor);
state=CCSTATE_WAIT_FOR_CONTRACTORS;
want_receive=false;
}
}
#endif
db->destroyAllQueries();
return true;
}
std::string ClientConnector::replaceChars(std::string in)
{
char legalchars[] = {'_', '-'};
for(size_t i=0;i<in.size();++i)
{
bool found=false;
for(size_t j=0;j<sizeof(legalchars);++j)
{
if(legalchars[j]==in[i])
{
found=true;
break;
}
}
if( !isletter(in[i]) && !isnumber(in[i]) && !found )
{
in[i]='_';
}
}
return in;
}
void ClientConnector::updateLastBackup(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_CLIENT);
IQuery *q=db->Prepare("UPDATE status SET last_backup=CURRENT_TIMESTAMP WHERE id=1");
IQuery *q2=db->Prepare("SELECT last_backup FROM status WHERE id=1");
if(q!=NULL && q2!=NULL)
{
if(q2->Read().size()>0)
{
q->Write();
}
else
{
q=db->Prepare("INSERT INTO status (last_backup, id) VALUES (CURRENT_TIMESTAMP, 1)");
if(q!=NULL)
q->Write();
}
}
db->destroyAllQueries();
}
void ClientConnector::getBackupStatus(void)
{
IScopedLock lock(backup_mutex);
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_CLIENT);
IQuery *q=db->Prepare("SELECT strftime('"+time_format_str+"',last_backup, 'localtime') AS last_backup FROM status");
if(q==NULL)
return;
int timeoutms=300;
db_results res=q->Read(&timeoutms);
if(timeoutms==1)
{
res=cached_status;
}
else
{
cached_status=res;
}
std::string ret;
if(res.size()>0)
{
ret+=Server->ConvertToUTF8(res[0][L"last_backup"]);
}
if(backup_running==RUNNING_NONE)
{
if(backup_done)
ret+="#DONE";
else
ret+="#NOA";
backup_done=false;
}
else if(backup_running==RUNNING_INCR_FILE)
{
if(last_pingtime!=0 && Server->getTimeMS()-last_pingtime>x_pingtimeout )
ret+="#NOA";
else
ret+="#INCR";
}
else if(backup_running==RUNNING_FULL_FILE)
{
if(last_pingtime!=0 && Server->getTimeMS()-last_pingtime>x_pingtimeout )
ret+="#NOA";
else
ret+="#FULL";
}
else if(backup_running==RUNNING_FULL_IMAGE)
{
if(last_pingtime!=0 && Server->getTimeMS()-last_pingtime>x_pingtimeout )
ret+="#NOA";
else
ret+="#FULLI";
}
else if(backup_running==RUNNING_INCR_IMAGE)
{
if(last_pingtime!=0 && Server->getTimeMS()-last_pingtime>x_pingtimeout )
ret+="#NOA";
else
ret+="#INCRI";
}
if(backup_running!=RUNNING_INCR_IMAGE)
ret+="#"+nconvert(pcdone);
else
ret+="#"+nconvert(pcdone2);
if(IdleCheckerThread::getPause())
{
ret+="#P";
}
else
{
ret+="#NP";
}
int capa=0;
if(channel_capa.size()==0)
{
capa=last_capa;
capa|=DONT_ALLOW_STARTING_FILE_BACKUPS;
capa|=DONT_ALLOW_STARTING_IMAGE_BACKUPS;
}
else
{
capa=INT_MAX;
for(size_t i=0;i<channel_capa.size();++i)
{
capa=capa & channel_capa[i];
}
if(capa!=last_capa)
{
IQuery *cq=db->Prepare("UPDATE misc SET tvalue=? WHERE tkey='last_capa'");
if(cq!=NULL)
{
cq->Bind(capa);
cq->Write();
cq->Reset();
last_capa=capa;
}
}
}
ret+="#capa="+nconvert(capa);
tcpstack.Send(pipe, ret);
db->destroyAllQueries();
}
std::vector<std::wstring> getSettingsList(void);
void ClientConnector::updateSettings(const std::string &pData)
{
ISettingsReader *curr_settings=Server->createFileSettingsReader("urbackup/data/settings.cfg");
ISettingsReader *new_settings=Server->createMemorySettingsReader(pData);
std::vector<std::wstring> settings_names=getSettingsList();
std::wstring new_settings_str=L"";
bool mod=false;
for(size_t i=0;i<settings_names.size();++i)
{
std::wstring key=settings_names[i];
std::wstring v;
if(!curr_settings->getValue(key, &v) )
{
std::wstring nv;
if(new_settings->getValue(key, &nv) )
{
new_settings_str+=key+L"="+nv+L"\n";
mod=true;
}
else if(new_settings->getValue(key+L"_def", &nv) )
{
new_settings_str+=key+L"_def="+nv+L"\n";
mod=true;
}
}
else
{
new_settings_str+=key+L"="+v+L"\n";
}
}
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_CLIENT);
IQuery *q=db->Prepare("SELECT id FROM backupdirs WHERE server_default=0", false);
db_results res=q->Read();
db->destroyQuery(q);
if(res.empty())
{
std::wstring default_dirs;
if(!new_settings->getValue(L"default_dirs", &default_dirs) )
new_settings->getValue(L"default_dirs_def", &default_dirs);
if(!default_dirs.empty())
{
std::vector<std::wstring> def_dirs_toks;
Tokenize(default_dirs, def_dirs_toks, L";");
str_map args;
for(size_t i=0;i<def_dirs_toks.size();++i)
{
std::wstring path=trim(def_dirs_toks[i]);
std::wstring name;
if(path.find(L"|")!=std::string::npos)
{
name=trim(getafter(L"|", path));
path=trim(getuntil(L"|", path));
}
args[L"dir_"+convert(i)]=path;
if(!name.empty())
args[L"dir_"+convert(i)+L"_name"]=name;
}
saveBackupDirs(args, true);
}
}
Server->destroy(curr_settings);
Server->destroy(new_settings);
if(mod)
{
IFile *sf=Server->openFile("urbackup/data/settings.cfg", MODE_WRITE );
if(sf==NULL)
{
Server->Log("Error opening settings file!", LL_ERROR);
return;
}
sf->Write(Server->ConvertToUTF8(new_settings_str));
Server->destroy(sf);
}
}
void ClientConnector::replaceSettings(const std::string &pData)
{
ISettingsReader *new_settings=Server->createMemorySettingsReader(pData);
std::wstring ncname=new_settings->getValue(L"computername", L"");
if(!ncname.empty() && ncname!=IndexThread::getFileSrv()->getServerName())
{
CWData data;
data.addChar(7);
data.addVoidPtr(NULL);
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
}
Server->destroy(new_settings);
IFile *sf=Server->openFile("urbackup/data/settings.cfg", MODE_WRITE);
if(sf==NULL)
{
Server->Log("Error opening settings file!", LL_ERROR);
return;
}
sf->Write(pData);
Server->destroy(sf);
}
void ClientConnector::saveLogdata(const std::string &created, const std::string &pData)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_CLIENT);
IQuery *q_p=db->Prepare("INSERT INTO logs (ttime) VALUES (datetime(?, 'unixepoch'))");
q_p->Bind(created);
q_p->Write();
_i64 logid=db->getLastInsertID();
while(!db->Write("BEGIN IMMEDIATE;"))
Server->wait(500);
IQuery *q=db->Prepare("INSERT INTO logdata (logid, loglevel, message, idx, ltime) VALUES (?, ?, ?, ?, datetime(?, 'unixepoch'))");
std::vector<std::string> lines;
TokenizeMail(pData, lines, "\n");
for(size_t i=0,lc=lines.size();i<lc;++i)
{
std::string l=lines[i];
int loglevel=atoi(getuntil("-",l).c_str());
std::string u_msg=getafter("-", l);
unsigned int ltime=0;
if(u_msg.find("-")!=std::string::npos)
{
std::string s_ltime=getuntil("-", u_msg);
bool isnum=true;
for(size_t j=0;j<s_ltime.size();++j)
{
if(!isnumber(s_ltime[j]))
{
isnum=false;
break;
}
}
if(isnum)
{
ltime=atoi(s_ltime.c_str());
u_msg=getafter("-", u_msg);
}
}
std::wstring msg=Server->ConvertToUnicode(u_msg);
q->Bind(logid);
q->Bind(loglevel);
q->Bind(msg);
q->Bind(i);
q->Bind(ltime);
q->Write();
q->Reset();
}
db->EndTransaction();
db->destroyAllQueries();
}
std::string ClientConnector::getLogpoints(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_CLIENT);
int timeoutms=300;
IQuery *q=db->Prepare("SELECT id, strftime('"+time_format_str+"',ttime, 'localtime') AS ltime FROM logs ORDER BY ttime DESC LIMIT 100");
db_results res=q->Read(&timeoutms);
std::string ret;
for(size_t i=0;i<res.size();++i)
{
ret+=Server->ConvertToUTF8(res[i][L"id"])+"-";
ret+=Server->ConvertToUTF8(res[i][L"ltime"])+"\n";
}
db->destroyAllQueries();
return ret;
}
void ClientConnector::getLogLevel(int logid, int loglevel, std::string &data)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_CLIENT);
IQuery *q=db->Prepare("SELECT loglevel, message FROM logdata WHERE logid=? AND loglevel>=? ORDER BY idx ASC");
q->Bind(logid);
q->Bind(loglevel);
int timeoutms=300;
db_results res=q->Read(&timeoutms);
for(size_t i=0;i<res.size();++i)
{
data+=Server->ConvertToUTF8(res[i][L"loglevel"])+"-";
data+=Server->ConvertToUTF8(res[i][L"message"])+"\n";
}
db->destroyAllQueries();
}
bool ClientConnector::sendFullImage(void)
{
thread_action=TA_FULL_IMAGE;
thread_ticket=Server->getThreadPool()->execute(this);
state=CCSTATE_IMAGE;
IScopedLock lock(backup_mutex);
backup_running=RUNNING_FULL_IMAGE;
pcdone=0;
backup_source_token=server_token;
return true;
}
bool ClientConnector::sendIncrImage(void)
{
thread_action=TA_INCR_IMAGE;
thread_ticket=Server->getThreadPool()->execute(this);
state=CCSTATE_IMAGE_HASHDATA;
IScopedLock lock(backup_mutex);
backup_running=RUNNING_INCR_IMAGE;
pcdone=0;
pcdone2=0;
backup_source_token=server_token;
return true;
}
void ClientConnector::operator ()(void)
{
#ifdef _WIN32
#ifdef THREAD_MODE_BACKGROUND_BEGIN
SetThreadPriority( GetCurrentThread(), THREAD_MODE_BACKGROUND_BEGIN);
#endif
#endif
if(thread_action==TA_FULL_IMAGE)
{
sendFullImageThread();
}
else if(thread_action==TA_INCR_IMAGE)
{
int timeouts=1800;
while(hashdataok==false)
{
Server->wait(1000);
--timeouts;
if(timeouts<=0 || do_quit==true )
{
break;
}
}
if(timeouts>0 || do_quit==true )
{
sendIncrImageThread();
}
}
{
IScopedLock lock(backup_mutex);
if(backup_running==RUNNING_FULL_IMAGE || backup_running==RUNNING_INCR_IMAGE)
{
backup_running=RUNNING_NONE;
}
}
#ifdef _WIN32
#ifdef THREAD_MODE_BACKGROUND_END
SetThreadPriority( GetCurrentThread(), THREAD_MODE_BACKGROUND_END);
#endif
#endif
}
bool ClientConnector::waitForThread(void)
{
if(thread_action!=TA_NONE && Server->getThreadPool()->isRunning(thread_ticket ) )
return true;
else
return false;
}
void ClientConnector::ImageErr(const std::string &msg)
{
/*Server->Log(msg, LL_ERROR);
unsigned int bs=0xFFFFFFFF;
char *buffer=new char[sizeof(unsigned int)+msg.size()];
memcpy(buffer, &bs, sizeof(unsigned int) );
memcpy(&buffer[sizeof(unsigned int)], msg.c_str(), msg.size());
pipe->Write(buffer, sizeof(unsigned int)+msg.size());
delete [] buffer;*/
Server->Log(msg, LL_ERROR);
#ifdef _WIN32
uint64 bs=0xFFFFFFFFFFFFFFFF;
#else
uint64 bs=0xFFFFFFFFFFFFFFFFLLU;
#endif
char *buffer=new char[sizeof(uint64)+msg.size()];
memcpy(buffer, &bs, sizeof(uint64) );
memcpy(&buffer[sizeof(uint64)], msg.c_str(), msg.size());
pipe->Write(buffer, sizeof(uint64)+msg.size());
delete [] buffer;
}
void ClientConnector::ImageErrRunning(const std::string &msg)
{
Server->Log(msg, LL_ERROR);
int64 bs=-124;
char *buffer=new char[sizeof(int64)+msg.size()];
memcpy(buffer, &bs, sizeof(int64) );
memcpy(&buffer[sizeof(int64)], msg.c_str(), msg.size());
pipe->Write(buffer, sizeof(int64)+msg.size());
delete [] buffer;
}
void ClientConnector::sendFullImageThread(void)
{
bool has_error=true;
int save_id=-1;
bool run=true;
while(run)
{
if(shadowdrive.empty() && !no_shadowcopy)
{
std::string msg;
mempipe->Read(&msg);
if(msg.find("done")==0)
{
shadowdrive=getafter("-", msg);
save_id=atoi(getuntil("-", shadowdrive).c_str());
shadowdrive=getafter("-", shadowdrive);
if(shadowdrive.size()>0 && shadowdrive[shadowdrive.size()-1]=='\\')
shadowdrive.erase(shadowdrive.begin()+shadowdrive.size()-1);
if(shadowdrive.empty())
{
ImageErr("Creating Shadow drive failed. Stopping. -2");
run=false;
}
}
else
{
ImageErr("Creating Shadow drive failed. Stopping.");
run=false;
}
mempipe->Write("exit");
mempipe=Server->createMemoryPipe();
}
else
{
IFilesystem *fs=image_fak->createFilesystem(Server->ConvertToUnicode(shadowdrive));
if(fs==NULL)
{
ImageErr("Opening Shadow drive filesystem failed. Stopping.");
run=false;
break;
}
unsigned int blocksize=(unsigned int)fs->getBlocksize();
int64 drivesize=fs->getSize();
int64 blockcnt=fs->calculateUsedSpace()/blocksize;
int64 ncurrblocks=0;
if(startpos==0)
{
char *buffer=new char[sizeof(unsigned int)+sizeof(int64)*2+1+sizeof(unsigned int)+shadowdrive.size()+sizeof(int)];
char *cptr=buffer;
memcpy(cptr, &blocksize, sizeof(unsigned int));
cptr+=sizeof(unsigned int);
memcpy(cptr, &drivesize, sizeof(int64) );
cptr+=sizeof(int64);
memcpy(cptr, &blockcnt, sizeof(int64) );
cptr+=sizeof(int64);
#ifndef VSS_XP //persistence
#ifndef VSS_S03
*cptr=1;
#else
*cptr=0;
#endif
#else
*cptr=0;
#endif
if(no_shadowcopy)
{
*cptr=0;
}
++cptr;
unsigned int shadowdrive_size=(unsigned int)shadowdrive.size();
memcpy(cptr, &shadowdrive_size, sizeof(unsigned int));
cptr+=sizeof(unsigned int);
memcpy(cptr, &shadowdrive[0], shadowdrive.size());
cptr+=shadowdrive.size();
memcpy(cptr, &save_id, sizeof(int));
cptr+=sizeof(int);
bool b=pipe->Write(buffer, sizeof(unsigned int)+sizeof(int64)*2+1+sizeof(unsigned int)+shadowdrive.size()+sizeof(int) );
if(!b)
{
Server->Log("Pipe broken -1", LL_ERROR);
run=false;
break;
}
}
ClientSend *cs=new ClientSend(pipe, blocksize+sizeof(int64), 2000);
THREADPOOL_TICKET send_ticket=Server->getThreadPool()->execute(cs);
unsigned int needed_bufs=64;
std::vector<char*> bufs;
for(int64 i=startpos,blocks=drivesize/blocksize;i<blocks;i+=64)
{
std::vector<char*> n_bufs=cs->getBuffers(needed_bufs);
bufs.insert(bufs.end(), n_bufs.begin(), n_bufs.end() );
needed_bufs=0;
unsigned int n=(unsigned int)(std::min)(blocks-i, (int64)64);
std::vector<int64> secs=fs->readBlocks(i, n, bufs, sizeof(int64));
needed_bufs+=(_u32)secs.size();
for(size_t j=0;j<secs.size();++j)
{
memcpy(bufs[j], &secs[j], sizeof(int64) );
cs->sendBuffer(bufs[j], sizeof(int64)+blocksize);
}
if(!secs.empty())
bufs.erase(bufs.begin(), bufs.begin()+secs.size() );
if(cs->hasError() )
{
Server->Log("Pipe broken -2", LL_ERROR);
run=false;
has_error=true;
break;
}
ncurrblocks+=secs.size();
if(IdleCheckerThread::getPause())
{
Server->wait(5000);
}
}
for(size_t i=0;i<bufs.size();++i)
{
cs->freeBuffer(bufs[i]);
}
cs->doExit();
std::vector<THREADPOOL_TICKET> wf;
wf.push_back(send_ticket);
Server->getThreadPool()->waitFor(wf);
delete cs;
if(!run)break;
char lastbuffer[sizeof(int64)];
int64 lastn=-123;
memcpy(lastbuffer,&lastn, sizeof(int64));
bool b=pipe->Write(lastbuffer, sizeof(int64));
if(!b)
{
Server->Log("Pipe broken -3", LL_ERROR);
run=false;
has_error=true;
break;
}
has_error=false;
run=false;
}
}
Server->Log("Sending full image done", LL_INFO);
#ifdef VSS_XP //persistence
has_error=false;
#endif
#ifdef VSS_S03
has_error=false;
#endif
if(!has_error && !no_shadowcopy)
{
removeShadowCopyThread(save_id);
std::string msg;
mempipe->Read(&msg);
if(msg.find("done")!=0)
{
Server->Log("Removing shadow copy failed in image streaming: "+msg, LL_ERROR);
}
mempipe->Write("exit");
mempipe=Server->createMemoryPipe();
}
do_quit=true;
}
const unsigned int c_vhdblocksize=(1024*1024/2);
const unsigned int c_hashsize=32;
void ClientConnector::sendIncrImageThread(void)
{
char *blockbuf=NULL;
char *blockdatabuf=NULL;
bool *has_blocks=NULL;
char *zeroblockbuf=NULL;
bool has_error=true;
int save_id=-1;
int update_cnt=0;
unsigned int lastsendtime=Server->getTimeMS();
bool run=true;
while(run)
{
if(shadowdrive.empty())
{
std::string msg;
mempipe->Read(&msg);
if(msg.find("done")==0)
{
shadowdrive=getafter("-", msg);
save_id=atoi(getuntil("-", shadowdrive).c_str());
shadowdrive=getafter("-", shadowdrive);
if(shadowdrive.size()>0 && shadowdrive[shadowdrive.size()-1]=='\\')
shadowdrive.erase(shadowdrive.begin()+shadowdrive.size()-1);
if(shadowdrive.empty())
{
ImageErr("Creating Shadow drive failed. Stopping. -2");
run=false;
}
}
else
{
ImageErr("Creating Shadow drive failed. Stopping.");
run=false;
}
mempipe->Write("exit");
mempipe=Server->createMemoryPipe();
}
else
{
IFilesystem *fs=image_fak->createFilesystem(Server->ConvertToUnicode(shadowdrive));
if(fs==NULL)
{
ImageErr("Opening Shadow drive filesystem failed. Stopping.");
run=false;
break;
}
sha256_ctx shactx;
unsigned int vhdblocks;
unsigned int blocksize=(unsigned int)fs->getBlocksize();
int64 drivesize=fs->getSize();
int64 blockcnt=fs->calculateUsedSpace()/blocksize;
vhdblocks=c_vhdblocksize/blocksize;
int64 currvhdblock=0;
int64 numblocks=drivesize/blocksize;
if(startpos==0)
{
char *buffer=new char[sizeof(unsigned int)+sizeof(int64)*2+1+sizeof(unsigned int)+shadowdrive.size()+sizeof(int)];
char *cptr=buffer;
memcpy(cptr, &blocksize, sizeof(unsigned int));
cptr+=sizeof(unsigned int);
memcpy(cptr, &drivesize, sizeof(int64) );
cptr+=sizeof(int64);
memcpy(cptr, &blockcnt, sizeof(int64) );
cptr+=sizeof(int64);
#ifndef VSS_XP //persistence
#ifndef VSS_S03
*cptr=1;
#else
*cptr=0;
#endif
#else
*cptr=0;
#endif
++cptr;
unsigned int shadowdrive_size=(unsigned int)shadowdrive.size();
memcpy(cptr, &shadowdrive_size, sizeof(unsigned int));
cptr+=sizeof(unsigned int);
memcpy(cptr, &shadowdrive[0], shadowdrive.size());
cptr+=shadowdrive.size();
memcpy(cptr, &save_id, sizeof(int));
cptr+=sizeof(int);
bool b=pipe->Write(buffer, sizeof(unsigned int)+sizeof(int64)*2+1+sizeof(unsigned int)+shadowdrive.size()+sizeof(int) );
if(!b)
{
Server->Log("Pipe broken -1", LL_ERROR);
run=false;
break;
}
}
delete []blockbuf;
blockbuf=new char[vhdblocks*blocksize];
delete []has_blocks;
has_blocks=new bool[vhdblocks];
delete []zeroblockbuf;
zeroblockbuf=new char[blocksize];
memset(zeroblockbuf, 0, blocksize);
ClientSend *cs=new ClientSend(pipe, blocksize+sizeof(int64), 2000);
THREADPOOL_TICKET send_ticket=Server->getThreadPool()->execute(cs);
for(int64 i=startpos,blocks=drivesize/blocksize;i<blocks;i+=vhdblocks)
{
++update_cnt;
if(update_cnt>10)
{
IScopedLock lock(backup_mutex);
pcdone2=(int)(((float)i/(float)blocks)*100.f+0.5f);
update_cnt=0;
}
currvhdblock=i/vhdblocks;
bool has_data=false;
for(int64 j=i;j<blocks && j<i+vhdblocks;++j)
{
if( fs->readBlock(j, NULL) )
{
has_data=true;
break;
}
}
if(has_data)
{
sha256_init(&shactx);
bool mixed=false;
for(int64 j=i;j<blocks && j<i+vhdblocks;++j)
{
char *dpos=blockbuf+(j-i)*blocksize;
if( fs->readBlock(j, dpos) )
{
if(IdleCheckerThread::getPause())
{
Server->wait(5000);
}
sha256_update(&shactx, (unsigned char*)dpos, blocksize);
has_blocks[j-i]=true;
}
else
{
sha256_update(&shactx, (unsigned char*)zeroblockbuf, blocksize);
has_blocks[j-i]=false;
mixed=true;
}
}
unsigned char digest[c_hashsize];
sha256_final(&shactx, digest);
if(hashdatafile->Size()>=(currvhdblock+1)*c_hashsize)
{
hashdatafile->Seek(currvhdblock*c_hashsize);
char hashdata_buf[c_hashsize];
if( hashdatafile->Read(hashdata_buf, c_hashsize)!=c_hashsize )
{
Server->Log("Reading hashdata failed!", LL_ERROR);
}
if(memcmp(hashdata_buf, digest, c_hashsize)!=0)
{
//Server->Log("Block did change: "+nconvert(i)+" mixed="+nconvert(mixed), LL_DEBUG);
for(int64 j=i;j<blocks && j<i+vhdblocks;++j)
{
if(has_blocks[j-i])
{
char* cb=cs->getBuffer();
memcpy(&cb[sizeof(int64)], blockbuf+(j-i)*blocksize, blocksize);
memcpy(cb, &j, sizeof(int64) );
cs->sendBuffer(cb, sizeof(int64)+blocksize);
lastsendtime=Server->getTimeMS();
if(cs->hasError())
{
Server->Log("Pipe broken -2", LL_ERROR);
run=false;
break;
}
}
}
}
else
{
//Server->Log("Block didn't change: "+nconvert(i), LL_DEBUG);
unsigned int tt=Server->getTimeMS();
if(tt-lastsendtime>10000)
{
int64 bs=-125;
char* buffer=cs->getBuffer();
memcpy(buffer, &bs, sizeof(int64) );
cs->sendBuffer(buffer, sizeof(int64));
lastsendtime=tt;
}
}
}
else
{
ImageErrRunning("Hashdata from server too small");
run=false;
break;
}
if(!run)break;
}
else
{
unsigned int tt=Server->getTimeMS();
if(tt-lastsendtime>10000)
{
int64 bs=-125;
char* buffer=cs->getBuffer();
memcpy(buffer, &bs, sizeof(int64) );
cs->sendBuffer(buffer, sizeof(int64));
lastsendtime=tt;
}
}
}
cs->doExit();
std::vector<THREADPOOL_TICKET> wf;
wf.push_back(send_ticket);
Server->getThreadPool()->waitFor(wf);
delete cs;
if(!run)break;
char lastbuffer[sizeof(int64)];
int64 lastn=-123;
memcpy(lastbuffer,&lastn, sizeof(int64));
bool b=pipe->Write(lastbuffer, sizeof(int64));
if(!b)
{
Server->Log("Pipe broken -3", LL_ERROR);
run=false;
break;
}
has_error=false;
run=false;
}
}
delete [] blockbuf;
delete [] has_blocks;
delete [] zeroblockbuf;
Server->destroy(hashdatafile);
Server->Log("Sending image done", LL_INFO);
#ifdef VSS_XP //persistence
has_error=false;
#endif
#ifdef VSS_S03
has_error=false;
#endif
if(!has_error)
{
removeShadowCopyThread(save_id);
std::string msg;
mempipe->Read(&msg);
if(msg.find("done")!=0)
{
Server->Log("Removing shadow copy failed in image streaming: "+msg, LL_ERROR);
}
mempipe->Write("exit");
mempipe=Server->createMemoryPipe();
}
do_quit=true;
}
void ClientConnector::removeShadowCopyThread(int save_id)
{
if(!no_shadowcopy)
{
CWData data;
data.addChar(3);
data.addVoidPtr(mempipe);
data.addString(image_letter);
data.addString(server_token);
data.addUChar(1);
data.addInt(save_id);
IndexThread::getMsgPipe()->Write(data.getDataPtr(), data.getDataSize());
}
}
bool ClientConnector::sendMBR(std::wstring dl)
{
#ifdef _WIN32
std::wstring vpath=dl;
if(!vpath.empty() && vpath[0]!='\\')
{
dl+=L":";
vpath=L"\\\\.\\"+dl;
}
HANDLE hVolume=CreateFileW(vpath.c_str(), GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(hVolume==INVALID_HANDLE_VALUE)
{
Server->Log(L"CreateFile of volume '"+dl+L"' failed. - sendMBR", LL_ERROR);
return false;
}
STORAGE_DEVICE_NUMBER dev_num;
DWORD ret_bytes;
BOOL b=DeviceIoControl(hVolume, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0, &dev_num, sizeof(STORAGE_DEVICE_NUMBER), &ret_bytes, NULL);
CloseHandle(hVolume);
if(b==0)
{
Server->Log(L"DeviceIoControl IOCTL_STORAGE_GET_DEVICE_NUMBER failed. Volume: '"+dl+L"'", LL_ERROR);
return false;
}
wchar_t voln[MAX_PATH+1];
DWORD voln_size=MAX_PATH+1;
DWORD voln_sern;
wchar_t fsn[MAX_PATH+1];
DWORD fsn_size=MAX_PATH+1;
b=GetVolumeInformationW((dl+L"\\").c_str(), voln, voln_size, &voln_sern, NULL, NULL, fsn, fsn_size);
if(b==0)
{
Server->Log(L"GetVolumeInformationW failed. Volume: '"+dl+L"'", LL_ERROR);
return false;
}
CWData mbr;
mbr.addChar(1);
mbr.addChar(0);
mbr.addInt(dev_num.DeviceNumber);
mbr.addInt(dev_num.PartitionNumber);
mbr.addString(nconvert((_i64)voln_sern));
mbr.addString(Server->ConvertToUTF8((std::wstring)voln));
mbr.addString(Server->ConvertToUTF8((std::wstring)fsn));
IFile *dev=Server->openFile(L"\\\\.\\PhysicalDrive"+convert((int)dev_num.DeviceNumber), MODE_READ);
if(dev==NULL)
{
Server->Log(L"Error opening Device "+convert((int)dev_num.DeviceNumber), LL_ERROR);
return false;
}
std::string mbr_bytes=dev->Read(512);
mbr.addString(mbr_bytes);
tcpstack.Send(pipe, mbr);
return true;
#endif //WIN_32
}
const unsigned int receive_timeouttime=60000;
std::string ClientConnector::receivePacket(IPipe *p)
{
unsigned int starttime=Server->getTimeMS();
while(Server->getTimeMS()-starttime<=receive_timeouttime)
{
std::string ret;
size_t rc=p->Read(&ret, 10000);
if(rc==0)
{
return "";
}
tcpstack.AddData((char*)ret.c_str(), ret.size());
size_t packetsize;
char *pck=tcpstack.getPacket(&packetsize);
if(pck!=NULL)
{
ret.resize(packetsize);
if(packetsize>0)
{
memcpy(&ret[0], pck, packetsize);
}
delete [] pck;
return ret;
}
}
return "";
}
void ClientConnector::removeChannelpipe(IPipe *cp)
{
channel_exit.push_back(cp);
}
void ClientConnector::downloadImage(str_map params)
{
_i64 imgsize=-1;
if(channel_pipes.size()==0)
{
pipe->Write((char*)&imgsize, sizeof(_i64), (int)receive_timeouttime);
Server->Log("No channel found!", LL_DEBUG);
return;
}
int l_pcdone=0;
{
IScopedLock lock(progress_mutex);
pcdone=0;
}
for(size_t i=0;i<channel_pipes.size();++i)
{
IPipe *c=channel_pipes[i];
std::string offset;
if(params.find(L"offset")!=params.end())
{
offset="&offset="+wnarrow(params[L"offset"]);
}
tcpstack.Send(c, "DOWNLOAD IMAGE img_id="+wnarrow(params[L"img_id"])+"&time="+wnarrow(params[L"time"])+"&mbr="+wnarrow(params[L"mbr"])+offset);
Server->Log("Downloading from channel "+nconvert((int)i), LL_DEBUG);
_i64 imgsize=-1;
c->Read((char*)&imgsize, sizeof(_i64), 60000);
Server->Log("Imagesize "+nconvert(imgsize), LL_DEBUG);
if(imgsize==-1)
{
Server->Log("Error reading size", LL_ERROR);
continue;
}
if(!pipe->Write((char*)&imgsize, sizeof(_i64), (int)receive_timeouttime))
{
Server->Log("Could not write to pipe! downloadImage-1", LL_ERROR);
return;
}
char buf[4096];
_i64 read=0;
if(params[L"mbr"]==L"true")
{
Server->Log("Downloading MBR...", LL_DEBUG);
while(read<imgsize)
{
size_t c_read=c->Read(buf, 4096, 60000);
if(c_read==0)
{
Server->Log("Read Timeout", LL_ERROR);
removeChannelpipe(c);
return;
}
if(!pipe->Write(buf, (_u32)c_read, (int)receive_timeouttime*5))
{
Server->Log("Could not write to pipe! downloadImage-5", LL_ERROR);
removeChannelpipe(c);
return;
}
read+=c_read;
}
Server->Log("Downloading MBR done");
return;
}
unsigned int blockleft=0;
unsigned int off=0;
_i64 pos=0;
while(pos<imgsize)
{
size_t r=c->Read(&buf[off], 4096-off, 180000);
if( r==0 )
{
Server->Log("Read Timeout -2 CS", LL_ERROR);
removeChannelpipe(c);
return;
}
if(!pipe->Write(&buf[off], r, (int)receive_timeouttime*5))
{
Server->Log("Could not write to pipe! downloadImage-3 size "+nconvert(r)+" off "+nconvert(off), LL_ERROR);
removeChannelpipe(c);
return;
}
if(r!=0)
r+=off;
off=0;
while(true)
{
if( blockleft==0 )
{
if(r-off>=sizeof(_i64) )
{
blockleft=4096;
_i64 s;
memcpy((char*)&s, &buf[off], sizeof(_i64) );
if(s>imgsize)
{
Server->Log("invalid seek value: "+nconvert(s), LL_ERROR);
}
off+=sizeof(_i64);
pos=s;
}
else if(r-off>0)
{
char buf2[4096];
memcpy(buf2, &buf[off], r-off);
memcpy(buf, buf2, r-off);
off=(_u32)r-off;
break;
}
else
{
off=0;
break;
}
}
else
{
unsigned int available=(std::min)((unsigned int)r-off, blockleft);
read+=available;
blockleft-=available;
off+=available;
if(off>=r)
{
off=0;
break;
}
}
}
int t_pcdone=(int)(((float)pos/(float)imgsize)*100.f+0.5f);
if(t_pcdone!=l_pcdone)
{
l_pcdone=t_pcdone;
IScopedLock lock(progress_mutex);
pcdone=l_pcdone;
}
lasttime=Server->getTimeMS();
}
Server->Log("Downloading image done", LL_DEBUG);
return;
}
imgsize=-1;
pipe->Write((char*)&imgsize, sizeof(_i64), (int)receive_timeouttime);
}
void ClientConnector::waitForPings(IScopedLock *lock)
{
Server->Log("Waiting for pings...", LL_DEBUG);
while(!channel_ping.empty())
{
lock->relock(NULL);
Server->wait(10);
lock->relock(backup_mutex);
}
Server->Log("done. (Waiting for pings)", LL_DEBUG);
}
unsigned int ClientConnector::getLastTokenTime(const std::string & tok)
{
IScopedLock lock(backup_mutex);
std::map<std::string, unsigned int>::iterator it=last_token_times.find(tok);
if(it!=last_token_times.end())
{
return it->second;
}
else
{
return 0;
}
}
Reference in New Issue View Git Blame Copy Permalink