float ServerSettings::parseTimeDet(std::string t)
{
if(t.find(":")!=std::string::npos)
{
std::string h=getuntil(":", t);
std::string m=getafter(":", t);
return (float)atoi(h.c_str())+(float)atoi(m.c_str())*(1.f/60.f);
}
else
{
return (float)atoi(t.c_str());
}
}
STimeSpan ServerSettings::parseTime(std::string t)
{
if(t.find("-")!=std::string::npos)
{
std::string f=trim(getuntil("-", t));
std::string b=trim(getafter("-", t));
return STimeSpan(parseTimeDet(f), parseTimeDet(b) );
}
else
{
return STimeSpan();
}
}
bool is_volume(std::string target)
{
if (next(target, 0, "\\??\\"))
{
target = target.substr(4);
}
target = strlower(target);
if (next(target, 0, "volume")
&& getafter("\\", target).empty())
{
return true;
}
return false;
}
std::vector<SLogLine> Connector::getLogdata(int logid, int loglevel)
{
std::string d=getResponse("GET LOGDATA","logid="+nconvert(logid)+"&loglevel="+nconvert(loglevel));
std::vector<std::string> lines;
TokenizeMail(d, lines, "\n");
std::vector<SLogLine> ret;
for(size_t i=0; i<lines.size(); ++i)
{
std::string l=lines[i];
if(l.empty())continue;
SLogLine ll;
ll.loglevel=atoi(getuntil("-", l).c_str());
ll.msg=wxString::FromUTF8(getafter("-", l).c_str());
ret.push_back(ll);
}
return ret;
}
std::vector<SLogEntry> Connector::getLogEntries(void)
{
std::string d=getResponse("GET LOGPOINTS","");
int lc=linecount(d);
std::vector<SLogEntry> ret;
for(int i=0; i<lc; ++i)
{
std::string l=getline(i, d);
if(l.empty())continue;
SLogEntry le;
le.logid=atoi(getuntil("-", l).c_str() );
std::string lt=getafter("-", l);
le.logtime=wxString::FromUTF8(lt.c_str());
ret.push_back(le);
}
return ret;
}
std::vector<SBackupDir> Connector::getSharedPaths(void)
{
std::vector<SBackupDir> ret;
std::string d=getResponse("1GET BACKUP DIRS","");
int lc=linecount(d);
for(int i=0; i<lc; i+=2)
{
SBackupDir bd;
bd.id=atoi(getline(i, d).c_str() );
std::string path=getline(i+1, d);
bd.path=wxString::FromUTF8(path.c_str() );
if(path.find("|")!=std::string::npos)
{
bd.path=ConvertToUnicode(getafter("|", path));
bd.name=ConvertToUnicode(getuntil("|", path));
}
ret.push_back( bd );
}
return ret;
}
bool TreeReader::readTree(const std::string &fn)
{
std::fstream in;
in.open(fn.c_str(), std::ios::in | std::ios::binary );
if (!in.is_open())
{
Log("Cannot read file tree from file \"" + fn + "\"");
return false;
}
size_t read;
char buffer[buffer_size];
int state=0;
size_t lines=0;
size_t stringbuffer_size=0;
std::string name;
char ltype=0;
do
{
in.read(buffer, buffer_size);
read=(size_t)in.gcount();
for(size_t i=0;i<read;++i)
{
const char ch=buffer[i];
switch(state)
{
case 0:
if(ch=='f' || ch=='d')
{
ltype = ch;
state = 1;
}
else if(ch=='u')
{
state = 10;
ltype = 'd';
name = "..";
}
else
{
Log("Error parsing file readTree - 0. Expected 'f', 'd', or 'u'. Got '"+std::string(1, ch)+"' at line "+convert(lines)+" while reading "+fn);
return false;
}
break;
case 1:
//"
state=2;
break;
case 2:
if(ch=='"')
{
state=3;
}
else if(ch=='\\')
{
state=5;
}
else
{
name+=ch;
}
break;
case 5:
if(ch!='\"' && ch!='\\')
{
name+='\\';
}
name+=ch;
state=2;
break;
case 3:
if(ch==' ')
{
state=4;
break;
}
else
{
state=10;
}
case 4:
if(state==4)
{
if(ch!='\n')
{
break;
}
}
case 10:
if(ch=='\n')
{
state=0;
if(ltype=='f')
{
stringbuffer_size+=2*sizeof(int64);
}
if(ltype!='d' || name!="..")
{
if(ltype=='d')
{
stringbuffer_size+=sizeof(int64);
}
++lines;
stringbuffer_size+=name.size()+1;
}
name.clear();
ltype=0;
}
}
}
}
while(read>0);
in.clear();
name.clear();
in.seekg(0, std::ios::beg);
size_t stringbuffer_pos=0;
stringbuffer.resize(stringbuffer_size+5);
state=0;
bool isdir=false;
std::string data;
std::stack<TreeNode*> parents;
std::stack<TreeNode*> lastNodes;
bool firstChild=true;
size_t idx=1;
nodes.resize(lines+1);
std::string root_str = "root";
memcpy(&stringbuffer[0], root_str.c_str(), root_str.size()+1);
stringbuffer_pos+=root_str.size()+1;
nodes[0].setName(&stringbuffer[0]);
parents.push(&nodes[0]);
lastNodes.push(&nodes[0]);
lines=0;
do
{
in.read(buffer, buffer_size);
read=(size_t)in.gcount();
for(size_t i=0;i<read;++i)
{
const char ch=buffer[i];
switch(state)
{
case 0:
if(ch=='f')
{
data+='f';
state=1;
}
else if(ch=='d')
{
data+='d';
state=1;
}
else if(ch=='u')
{
name="..";
state=10;
}
else
{
Log("Error parsing file readTree - 1. Expected 'f', 'd', or 'u'. Got '" + std::string(1, ch) + "' at line " + convert(lines)+" while reading "+fn);
return false;
}
break;
case 1:
//"
state=2;
break;
case 2:
if(ch=='"')
{
state=3;
}
else if(ch=='\\')
{
state=5;
}
else
{
name+=ch;
}
break;
case 5:
if(ch!='\"' && ch!='\\')
{
name+='\\';
}
name+=ch;
state=2;
break;
case 3:
if(ch==' ')
{
state=4;
break;
}
else
{
state=10;
}
case 4:
if(state==4)
{
if(ch!='\n')
{
data+=ch;
break;
}
}
case 10:
if(ch=='\n')
{
if(name!="..")
{
memcpy(&stringbuffer[stringbuffer_pos], name.c_str(), name.size()+1);
nodes[idx].setName(&stringbuffer[stringbuffer_pos]);
stringbuffer_pos+=name.size()+1;
nodes[idx].setId(lines);
char ch=data[0];
nodes[idx].setType(ch);
if(ch=='f')
{
std::string sdata=data.substr(1);
std::string filesize=getuntil(" ", sdata);
std::string last_mod=getafter(" ", sdata);
_i64 ifilesize=os_atoi64(filesize);
_i64 ilast_mod=os_atoi64(last_mod);
char* ndata=&stringbuffer[stringbuffer_pos];
memcpy(&stringbuffer[stringbuffer_pos], &ifilesize, sizeof(_i64));
stringbuffer_pos+=sizeof(_i64);
memcpy(&stringbuffer[stringbuffer_pos], &ilast_mod, sizeof(_i64));
stringbuffer_pos+=sizeof(_i64);
nodes[idx].setData(ndata);
}
else
{
std::string sdata=data.substr(1);
std::string last_mod=getafter(" ", sdata);
_i64 ilast_mod=os_atoi64(last_mod);
char* ndata=&stringbuffer[stringbuffer_pos];
memcpy(&stringbuffer[stringbuffer_pos], &ilast_mod, sizeof(_i64));
stringbuffer_pos+=sizeof(_i64);
nodes[idx].setData(ndata);
}
if(firstChild)
{
lastNodes.push(&nodes[idx]);
firstChild=false;
}
else
{
lastNodes.top()->setNextSibling(&nodes[idx]);
lastNodes.pop();
lastNodes.push(&nodes[idx]);
}
if(!parents.empty())
{
parents.top()->incrementNumChildren();
nodes[idx].setParent(parents.top());
}
if(ch=='d')
{
parents.push(&nodes[idx]);
firstChild=true;
}
++idx;
}
else
{
if(!parents.empty())
{
parents.pop();
}
else
{
Log("TreeReader: parents empty");
return false;
}
if(!firstChild)
{
if(lastNodes.empty())
{
Log("TreeReader: lastNodes empty");
return false;
}
lastNodes.top()->setNextSibling(NULL);
lastNodes.pop();
}
firstChild=false;
}
name.clear();
data.clear();
state=0;
++lines;
}
}
}
}
while(read==buffer_size);
assert(idx == nodes.size());
assert(stringbuffer_pos == stringbuffer.size());
nodes[0].setNextSibling(NULL);
return true;
}
void CWorkerThread::ProcessRequest(CClient *client, FCGIRequest *req)
{
if( req->keep_connection )
{
keep_alive=true;
}
else
{
keep_alive=false;
}
if( req->role != FCGIRequest::RESPONDER )
{
Server->Log("Role ist not Responder", LL_ERROR);
return;
}
str_map GET,POST;
str_nmap::iterator iter=req->params.find("QUERY_STRING");
if( iter!=req->params.end() )
{
for(size_t i=0,size=iter->second.size();i<size;++i)
{
if( iter->second[i]=='+' )
iter->second[i]=' ';
}
ParseParamStr(iter->second, &GET );
req->params.erase( iter );
}
std::string ct=req->params["CONTENT_TYPE"];
std::string lct=ct;
strlower(lct);
bool postfile=false;
POSTFILE_KEY pfkey;
if(lct.find("multipart/form-data")==std::string::npos)
{
if( req->stdin_stream.size()>0 && req->stdin_stream.size()<1048576 )
{
for(size_t i=0,size=req->stdin_stream.size();i<size;++i)
{
if( req->stdin_stream[i]=='+' )
req->stdin_stream[i]=' ';
}
ParseParamStr(req->stdin_stream, &POST );
}
}
else
{
std::string boundary=getafter("boundary=",ct);
pfkey=ParseMultipartData(req->stdin_stream, boundary);
req->params["POSTFILEKEY"]=nconvert(pfkey);
postfile=true;
}
str_map::iterator iter2=GET.find(L"a");
if( iter2!=GET.end() )
{
int starttime=Server->getTimeMS();
str_map::iterator iter3=GET.find(L"c");
std::wstring context;
if( iter3!=GET.end() )
context=iter3->second;
THREAD_ID tid=Server->Execute(iter2->second, context, GET, POST, req->params, req );
if( tid==0 )
{
std::wstring error=L"Error: Unknown action ["+iter2->second+L"]";
Server->Log(error, LL_WARNING);
req->write("Content-type: text/html; charset=UTF-8\r\n\r\n"+wnarrow(error));
}
starttime=Server->getTimeMS()-starttime;
Server->Log("Execution Time: "+nconvert(starttime)+" ms - time="+nconvert(Server->getTimeMS() ), LL_INFO);
}
else
{
std::string error="Error: Parameter 'action' not given.";
req->write("Content-type: text/html; charset=UTF-8\r\n\r\n"+error);
}
if(postfile)
{
Server->clearPostFiles(pfkey);
}
req->end_request(0, FCGIRequest::REQUEST_COMPLETE);
}
std::vector<STimeSpan> ServerSettings::getWindow(std::string window)
{
std::vector<std::string> toks;
Tokenize(window, toks, ";");
std::vector<STimeSpan> ret;
for(size_t i=0;i<toks.size();++i)
{
std::string c_tok=trim(toks[i]);
std::string f_o=getuntil("/", c_tok);
std::string b_o=getafter("/", c_tok);
std::vector<std::string> dow_toks;
Tokenize(f_o, dow_toks, ",");
std::vector<std::string> time_toks;
Tokenize(b_o, time_toks, ",");
for(size_t l=0;l<dow_toks.size();++l)
{
f_o=trim(dow_toks[l]);
if(f_o.find("-")!=std::string::npos)
{
std::string f1=trim(getuntil("-", f_o));
std::string b2=trim(getafter("-", f_o));
int start=parseDayOfWeek(f1);
int stop=parseDayOfWeek(b2);
if(stop<start) { int t=start; start=stop; stop=t; }
if(start<1 || start>7 || stop<1 || stop>7)
{
ret.clear();
return ret;
}
for(size_t o=0;o<time_toks.size();++o)
{
b_o=trim(time_toks[o]);
STimeSpan ts=parseTime(b_o);
if(ts.dayofweek==-1)
{
ret.clear();
return ret;
}
for(int j=start;j<=stop;++j)
{
ts.dayofweek=j;
ret.push_back(ts);
}
}
}
else
{
int j=parseDayOfWeek(f_o);
if(j<1 || j>7)
{
ret.clear();
return ret;
}
for(size_t o=0;o<time_toks.size();++o)
{
b_o=trim(time_toks[o]);
STimeSpan ts=parseTime(b_o);
if(ts.dayofweek==-1)
{
ret.clear();
return ret;
}
ts.dayofweek=j;
ret.push_back(ts);
}
}
}
}
return ret;
}
