QString Adb::getVersion()
{
Process::Result r = exec("version");
QRegularExpression rgx(REGEX_ADB_VERSION);
for (const QString &l : r.output)
{
QRegularExpressionMatch m = rgx.match(l);
if (m.hasMatch())
{
QString v("%1.%2.%3");
for (int i = 1; i <= 3; i++)
{
v = v.arg(m.captured(i));
}
return v;
}
}
return QString();
}
bool CCssSoap::GetUsernameForUsernameOrCallsign(char * szCharacterName, char * szUsername, char * szReason)
{
char szHdrs[512];
sprintf(szHdrs, "Content-Type: text/xml;charset=UTF-8\r\nSOAPAction: \"http://tempuri.org/IClientService/GetUsernameFromCallsignOrUsername\"");
char soapBody[4092];
sprintf(soapBody,
"<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:tem=\"http://tempuri.org/\"> \
<soapenv:Header/> \
<soapenv:Body> \
<tem:GetUsernameFromCallsignOrUsername> \
<tem:callsignOrUsername><![CDATA[%s]]></tem:callsignOrUsername> \
</tem:GetUsernameFromCallsignOrUsername> \
</soapenv:Body> \
</soapenv:Envelope>", szCharacterName);
int soapLength = strlen(soapBody);
ZString Response = UTL::DoHTTP(szHdrs, m_szCssServerDomain, "POST", m_szCssClientServicePath, soapBody, soapLength, true);
char * szToken;
char * szResponse = (char*)_alloca(10000);
Strcpy(szResponse, (PCC)Response);
// Parse results
std::tr1::regex rgx("<GetUsernameFromCallsignOrUsernameResult.*?>.*?<a:Username>(.*?)</a:Username>.*?</GetUsernameFromCallsignOrUsernameResult>");
std::tr1::smatch result;
std::string strResponse(szResponse);
if (std::tr1::regex_search(strResponse, result, rgx) == true && result.size() > 1)
{
sprintf(szUsername, result[1].str().c_str());
return true;
}
else
{
sprintf(szReason, "Your primary login couldn't be found from this callsign. Please log in with your main account. Please visit www.freeallegiance.org to request help in the forums.");
return false;
}
sprintf(szReason, "A general sign in error occurred. Please visit www.freeallegiance.org to request help in the forums.");
return false;
}
string extract_domain_from_url(string* url) {
if (NULL == url || url->length() == 0)
return "";
int start_pos = 0;
int tmp_pos = url->find("://");
if (tmp_pos != -1)
start_pos = tmp_pos + 3;
#if 0
boost::regex rgx("^([0-9A-Za-z.-]+)[^0-9A-Za-z.-]?");
boost::match_results<std::string::iterator> match;
boost::match_flag_type flags = boost::match_default;
if (regex_search(url->begin() + start_pos, url->end(), match, rgx, flags))
return std::string(match[1].first, match[1].second);
#endif
int end_pos = min(url->find("/", start_pos), url->size());
return url->substr(0, end_pos);
}
QString _parseSetImageUrl(Site* site, QString setting, QString ret, QMap<QString,QString> *d, bool replaces = true)
{
if (site->contains(setting) && replaces)
{
if (site->value(setting).contains("->"))
{
QStringList replaces = site->value(setting).split('&');
for (QString rep : replaces)
{
QRegExp rgx(rep.left(rep.indexOf("->")));
ret.replace(rgx, rep.right(rep.size() - rep.indexOf("->") - 2));
}
}
else
{
ret = site->value(setting);
ret.replace("{id}", d->value("id"))
.replace("{md5}", d->value("md5"))
.replace("{ext}", d->value("ext"));
}
}
return site->fixUrl(ret).toString();
}
bool CCssSoap::ValidateUserLogin(char *username, char *password, char * szReason, int & iID)
{
char szHdrs[512];
sprintf(szHdrs, "Content-Type: text/xml;charset=UTF-8\r\nSOAPAction: \"http://tempuri.org/IClientService/LauncherSignIn\"");
char soapBody[4092];
sprintf(soapBody,
"<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:tem=\"http://tempuri.org/\" xmlns:all=\"http://schemas.datacontract.org/2004/07/Allegiance.CommunitySecuritySystem.Server.Contracts\"> \
<soapenv:Header/> \
<soapenv:Body> \
<tem:LauncherSignIn> \
<tem:data> \
<all:Password><![CDATA[%s]]></all:Password> \
<all:Username><![CDATA[%s]]></all:Username> \
</tem:data> \
</tem:LauncherSignIn> \
</soapenv:Body> \
</soapenv:Envelope>", password, username);
int soapLength = strlen(soapBody);
ZString Response = UTL::DoHTTP(szHdrs, m_szCssServerDomain, "POST", m_szCssClientServicePath, soapBody, soapLength, true);
char * szToken;
char * szResponse = (char*)_alloca(10000);
Strcpy(szResponse, (PCC)Response);
puts(szHdrs);
puts("\r\n");
puts(soapBody);
puts("\r\n");
puts(szResponse);
puts("\r\n");
// Parse results
std::tr1::regex rgx("<LauncherSignInResult.*?>.*?<a:Status>(.*?)</a:Status>.*?</LauncherSignInResult>");
std::tr1::regex rgxLoginID("<LauncherSignInResult.*?>.*?<a:LoginID>(.*?)</a:LoginID>.*?</LauncherSignInResult>");
std::tr1::smatch result;
std::string strResponse(szResponse);
if (std::tr1::regex_search(strResponse, result, rgxLoginID) == true && result.size() > 1)
{
char szLoginID[50];
sprintf(szLoginID, result[1].str().c_str());
iID = atoi(szLoginID);
}
if (std::tr1::regex_search(strResponse, result, rgx) == true && result.size() > 1)
{
char status[50];
sprintf(status, result[1].str().c_str());
if (stricmp(status, "Ok") == 0)
{
return true;
}
else if (stricmp(status, "InvalidCredentials") == 0)
{
sprintf(szReason, "Your user name or password are invalid. Go to acss.alleg.net to create an account, or reset a forgotten password.");
return false;
}
else if (stricmp(status, "AccountLinked") == 0)
{
sprintf(szReason, "Your account has been linked to another user's account. Please log in with your main account. Please visit www.freeallegiance.org to request help in the forums.");
return false;
}
else if (stricmp(status, "PermissionDenied") == 0)
{
sprintf(szReason, "Your account access has been denied. Please visit www.freeallegiance.org to request help in the forums.");
return false;
}
else if (stricmp(status, "AccountLocked") == 0)
{
sprintf(szReason, "Your account has been locked. Please visit www.freeallegiance.org to request help in the forums.");
return false;
}
else
{
sprintf(szReason, "Login failed with status: %s. Please visit www.freeallegiance.org to request help in the forums.", status);
return false;
}
}
sprintf(szReason, "A general sign in error occurred. Please visit www.freeallegiance.org to request help in the forums.");
return false;
}
void client_connection(ConexaoPtr conexao) {
bool logado = false;
bool lista_foi_preparada = false;
std::vector<UsuarioPtr> copia_lista_usuarios;
std::string comando, arg1, arg2;
UsuarioPtr usuario;
PartidaPtr partida;
/* Armazena linhas recebidas do cliente */
char recvline[MAXLINE + 1];
/* Armazena o tamanho da string lida do cliente */
ssize_t n;
while ((n=conexao->recebe_mensagem(recvline)) > 0) {
recvline[n] = '\0';
printf ("Recebeu: %s\n", recvline);
std::string recvline_string(recvline);
std::regex rgx("([A-Z_]*)(\\s+(\\w*))?(\\s+(\\w*))?");
std::smatch resultado;
std::regex_search(recvline_string, resultado, rgx);
comando = resultado[1];
arg1 = resultado[3];
arg2 = resultado[5];
std::string stringaux;
if (logado)
{
if (usuario->esta_em_jogo())
{
if (comando == "PLAY")
{
comando_play(usuario, arg1, arg2);
}
else if (comando == "FINISH")
{
comando_finish(usuario);
}
else if (comando == "LOGOUT")
{
logado = false;
comando_logout(usuario);
}
else
conexao->envia_mensagem("REPLY 099\n"); // comando inválido
}
else // quando não está em jogo
{
if (comando == "PREPARE_LIST")
{
lista_foi_preparada = true;
comando_prepare_list(copia_lista_usuarios, usuario);
}
else if (comando == "LIST")
{
if(lista_foi_preparada) {
comando_list(copia_lista_usuarios, usuario);
lista_foi_preparada = false;
}
else
usuario->escreve("REPLY 032\n");
}
else if (comando == "LOGOUT")
{
logado = false;
comando_logout(usuario);
}
else if (comando == "QUIT")
{
break;
}
else if (comando == "REQUEST")
{
comando_request(usuario, arg1);
}
else if (comando == "ANSWER")
{
comando_answer(usuario, arg1, arg2);
}
else
conexao->envia_mensagem("REPLY 098\n"); // comando inválido
}
}
else // comandos quando não está logado
{
if (comando == "LOGIN")
{
usuario = comando_login(conexao, arg1, arg2);
if (usuario == nullptr) {
logado = false;
}
else {
logado = true;
}
}
else if (comando == "NEWUSR")
{
usuario = comando_newusr(conexao, arg1, arg2);
if (usuario == nullptr) {
logado = false;
}
else {
logado = true;
}
}
else
{
conexao->envia_mensagem("REPLY 097\n"); // comando inválido
}
}
strcpy (recvline, "");
}
if (logado)
usuario->desconecta();
}
std::string DescriptionParser::prepare_item(const std::string& item) const {
// no space around '='
std::regex rgx("\\s*=\\s*");
std::string filtered = std::regex_replace(item, rgx, "=");
return filtered;
}
std::string DescriptionParser::restore_space_in_quote(const std::string& param) const {
std::regex rgx(spaceReplacement);
return std::regex_replace(param, rgx, " ");
}
DescriptionParser::DescriptionParser(const std::string& description,
const std::vector<std::string>& valid_types)
: is_valid_(parse_description(description, valid_types)) {
if (!is_valid_) return;
// check if placeholders in connections_ refer to existing quiddity
for (auto& it : connections_) {
std::string placeholder;
if (!it.src.empty() && *it.src.begin() == '.') {
// removing the '.'
placeholder = std::string(it.src.begin() + 1, it.src.end());
// saving appropriate name instead of placeholder
it.src = placeholder;
} else if (!it.sink.empty() && *it.sink.begin() == '.') {
// removing the '.'
placeholder = std::string(it.sink.begin() + 1, it.sink.end());
// saving appropriate name instead of placeholder
it.sink = placeholder;
}
if (placeholder.empty()) continue;
if (quiddities_.cend() ==
std::find_if(quiddities_.begin(), quiddities_.end(), [&](const quiddity_spec_t& quid_spec) {
if (quid_spec.name == placeholder) return true;
return false;
})) {
parsing_error_ =
std::string("placeholder name ") + placeholder + " is not a valid quiddity name";
is_valid_ = false;
return;
}
}
// read connections_ and feed data into quiddities_
for (auto& it : connections_) {
auto quid = std::find_if(quiddities_.begin(),
quiddities_.end(),
[&](const quiddity_spec_t& quid) { return it.src == quid.name; });
if (quid == quiddities_.end()) {
parsing_error_ = "BUG during analysis of connections";
is_valid_ = false;
return;
}
quid->connects_to_.push_back(it.sink);
}
// check params, build blacklist and remove prefixed '_' if found
std::regex rgx("_.+");
for (auto& it : quiddities_) {
std::vector<std::pair<std::string, std::string>> tmp_params;
for (auto& prop : it.params) {
std::string actual_param_name;
if (std::regex_match(prop.first, rgx)) { // blacklist '_' if properties are exposed
actual_param_name = std::string(prop.first.begin() + 1, prop.first.end());
if (it.expose_prop)
it.blacklisted_params.push_back(actual_param_name);
else
it.whitelisted_params.push_back(actual_param_name);
} else {
actual_param_name = std::string(prop.first.begin(), prop.first.end());
}
tmp_params.push_back(std::make_pair(actual_param_name, prop.second));
}
std::swap(it.params, tmp_params);
}
}
bool DescriptionParser::parse_item(const std::string& raw_item,
const std::vector<std::string>& valid_types) {
// start with some filtering
std::string item = prepare_item(raw_item);
item = protect_space_in_quote(item);
// split by space' ', but can be escaped with '\\ '
std::regex rgx("\\s");
std::sregex_token_iterator iter(item.begin(), item.end(), rgx, -1);
bool type_found = false;
static const std::string shmr("<shmr");
static const std::string shmw("<shmw");
static const std::string noprop("<no_prop");
static const std::string addtostart("<add_to_start");
static const std::string top_level("<top_level");
quiddity_spec_t quid;
for (; iter != std::sregex_token_iterator(); ++iter) {
if (static_cast<std::string>(*iter).empty()) continue;
// first thing to do is to find quiddity type
if (!type_found) {
const auto& str = static_cast<std::string>(*iter);
if (*str.begin() == '.') {
if (str.size() == 1) {
parsing_error_ = "wrong placeholder name (\".\")";
return false;
}
// save the name with the '.' for later check
if (!previous_quid_.empty()) {
if (*previous_quid_.begin() == '.') {
parsing_error_ = "placeholders cannot be connected to each others (" + previous_quid_ +
" and " + str + ")";
return false;
}
connections_.push_back(shm_connection_t(previous_quid_, str));
}
previous_quid_ = str;
return true;
} else {
if (!valid_types.empty() &&
valid_types.end() == std::find(valid_types.begin(), valid_types.end(), *iter)) {
parsing_error_ = static_cast<std::string>(*iter) + " is not a valid quiddity type";
return false;
}
quid.type = *iter;
}
type_found = true;
continue;
}
if (*iter == shmr) {
if (!reader_quid_.empty()) {
std::string current = quid.name.empty() ? "an other unknown quiddity" : quid.name;
parsing_error_ = std::string("bundle description can get only one shmdata reader (") +
reader_quid_ + " and " + current + " are labelled as shmreader)";
return false;
}
quid.expose_shmr = true;
continue;
}
if (*iter == shmw) {
quid.expose_shmw = true;
continue;
}
if (*iter == noprop) {
quid.expose_prop = false;
continue;
}
if (*iter == addtostart) {
quid.expose_start = true;
continue;
}
if (*iter == top_level) {
quid.top_level = true;
continue;
}
if (!parse_param(*iter, quid)) return false;
}
if (quiddities_.end() !=
std::find_if(quiddities_.begin(), quiddities_.end(), [&](const quiddity_spec_t& quiddity) {
return quiddity.name == quid.name;
})) {
parsing_error_ =
std::string("quiddity name ") + quid.name + " is not unique in bundle description";
return false;
}
if (std::string::npos != quid.name.find('_')) {
parsing_error_ = std::string("underscores are not allowed in quiddity names ") + quid.name;
return false;
}
if (quid.name.empty()) {
parsing_error_ =
std::string("quiddity name is missing for quiddity specified with type ") + quid.type;
return false;
}
if (!previous_quid_.empty()) connections_.push_back(shm_connection_t(previous_quid_, quid.name));
if (quid.expose_shmr) reader_quid_ = quid.name;
previous_quid_ = quid.name;
quiddities_.push_back(quid);
return true;
}
void gerbil::Application::parseParams(const int &argc, char** argv) {
uint i;
for (i = 1; i < argc && argv[i][0] == '-'; i++) {
switch (argv[i][1]) {
case 'k':
_k = atoi(argv[++i]);
break;
case 'm':
_m = atoi(argv[++i]);
break;
case 'f':
_tempFilesNumber = atoi(argv[++i]);
break;
case 'l':
_thresholdMin = atoi(argv[++i]);
break;
case 't':
_threadsNumber = atoi(argv[++i]);
break;
case 'e': {
std::string s(argv[++i]);
boost::regex rgx("(0*[1-9][0-9]*)(M|G)B?");
boost::smatch match;
if (!boost::regex_match(s, match, rgx)) {
std::cout
<< "invalid value for parameter -e\nuse -h for help\n";
exit(0);
}
_memSize = atoi(match.str(1).c_str());
if (match.str(2) == "G")
_memSize *= 1024;
break;
}
case 'd':
_norm = false;
break;
case 'i':
verbose = true;
break;
case 'o': {
std::string s(argv[++i]);
if (s == "fasta")
_outputFormat = of_fasta;
else if (s == "none")
_outputFormat = of_none;
else
_outputFormat = of_gerbil;
break;
}
case 'x':
switch(argv[++i][0]) {
case '1': _singleStep = 1; break;
case '2': _singleStep = 2; break;
case 'b': _leaveBinStat = true; break;
case 'h': _histogram = true; break;
}
break;
#ifdef GPU
case 'g': {
// determine number of gpus to use
int num;
auto err = cudaGetDeviceCount(&num);
if (err != cudaSuccess) {
std::cerr << "Error while searching for GPU's: " << cudaGetErrorString(err) << std::endl;
std::cerr << "Disabling GPU support." << std::endl;
_numGPUs = 0;
} else {
_numGPUs = (uint8_t) std::min(num, 2);
}
break;
}
#endif
case 's':
checkSystem();
exit(0);
case 'v':
std::cout << VERSION_MAJOR << "." << VERSION_MINOR << std::endl;
exit(0);
case 'h':
printf("_________________________________________________________________\n");
printf("Gerbil version %i.%i\n", VERSION_MAJOR, VERSION_MINOR);
printf("-----------------------------------------------------------------\n");
printf("usage: gerbil [<option>|<flag>]* <input> <temp> <output>\n");
printf("<option>:\n");
printf(" -k <size> size of kmers (default: 28)\n");
printf(" -m <size> size of minimizers (default: auto)\n");
printf(" -e <size>(M|G)B size of ram usage (default: auto)\n");
printf(" -f <number> number of temporary files (default: %u)\n",
DEF_TEMPFILES_NUMBER);
printf(" -t <number> number of threads (default: auto)\n");
printf(" -l <count> minimal count of k-mers (default: %u)\n",
DEF_THRESHOLD_MIN);
printf("<flag>:\n");
printf(" -h show help\n");
printf(" -v version\n");
printf(" -h help\n");
printf(" -d disable normalization\n");
printf(" -i verbose output\n");
printf(" -s system check\n");
printf(" -o <outputFormat> output format\n");
printf(" outputFormat:\n");
printf(" gerbil gerbil format\n");
printf(" fasta fasta format\n");
printf(" none no output\n");
#ifdef GPU
printf(" -g enable gpu\n");
#endif
printf(" . . . . . . . . . . . . . . . . . . . . . \n");
printf(" -x <mode> Debugging and testing purposes\n");
printf(" (can be specified multiple times)\n");
printf(" modes:\n");
printf(" 1 only step 1, leaves temporary files and a\n");
printf(" binStatFile (with statistical stuff)\n");
printf(" !Watch out: no <output>\n");
printf(" 2 only step 2, requires temporary files and\n");
printf(" the binStatFile\n");
printf(" !Watch out: no <input>\n");
printf(" b leaves the binStatFile\n");
printf(" h saves the data for a histogram of the\n");
printf(" uk-mers in the output folder\n");
printf("-----------------------------------------------------------------\n");
exit(0);
}
}
IF_REL(if (argc < 4) {
std::cout << "missing parameters\nuse -h for help\n"
;
exit(0)
;
});
