void Unpack::unzip(const QString* const PIG_PATH, const QString *path, const QString *sum)
{
int exitCode = 0;
QFile origin(*path);
if ((origin.open(QIODevice::ReadOnly)) &&
(*sum == (QCryptographicHash::hash(origin.readAll(), QCryptographicHash::Md5).toHex()))) {
origin.close();
QuaZip zip(*path);
if (zip.open(QuaZip::mdUnzip)) {
QuaZipFile zipFile(&zip);
for (bool f = zip.goToFirstFile(); f; f = zip.goToNextFile()) {
zipFile.open(QIODevice::ReadOnly);
QFile target(*PIG_PATH+"/tmp/update/"+zipFile.getActualFileName());
target.open(QIODevice::WriteOnly);
if (target.write(zipFile.readAll()) == -1) {
zipFile.close();
zip.close();
target.close();
exitCode = -1;
}
zipFile.close();
target.close();
}
zip.close();
} else {
exitCode = -1;
}
} else {
if (origin.isOpen())
origin.close();
exitCode = -1;
}
emit sendExitCode(exitCode);
}
int ConnectionHandler::doCommand(QCString buf)
{
if((uid_t)peerUid() != getuid())
{
kdWarning(1205) << "Peer uid not equal to me\n";
kdWarning(1205) << "Peer: " << peerUid() << " Me: " << getuid() << endl;
return -1;
}
QCString key, command, pass, name, user, value, env_check;
Data_entry data;
Lexer *l = new Lexer(buf);
int tok = l->lex();
switch(tok)
{
case Lexer::Tok_pass: // "PASS password:string timeout:int\n"
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
m_Pass.fill('x');
m_Pass = l->lval();
tok = l->lex();
if(tok != Lexer::Tok_num)
goto parse_error;
m_Timeout = l->lval().toInt();
if(l->lex() != '\n')
goto parse_error;
if(m_Pass.isNull())
m_Pass = "";
kdDebug(1205) << "Password set!\n";
respond(Res_OK);
break;
case Lexer::Tok_host: // "HOST host:string\n"
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
m_Host = l->lval();
if(l->lex() != '\n')
goto parse_error;
kdDebug(1205) << "Host set to " << m_Host << endl;
respond(Res_OK);
break;
case Lexer::Tok_prio: // "PRIO priority:int\n"
tok = l->lex();
if(tok != Lexer::Tok_num)
goto parse_error;
m_Priority = l->lval().toInt();
if(l->lex() != '\n')
goto parse_error;
kdDebug(1205) << "priority set to " << m_Priority << endl;
respond(Res_OK);
break;
case Lexer::Tok_sched: // "SCHD scheduler:int\n"
tok = l->lex();
if(tok != Lexer::Tok_num)
goto parse_error;
m_Scheduler = l->lval().toInt();
if(l->lex() != '\n')
goto parse_error;
kdDebug(1205) << "Scheduler set to " << m_Scheduler << endl;
respond(Res_OK);
break;
case Lexer::Tok_exec: // "EXEC command:string user:string [options:string (env:string)*]\n"
{
QCString options;
KStringList env;
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
command = l->lval();
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
user = l->lval();
tok = l->lex();
if(tok != '\n')
{
if(tok != Lexer::Tok_str)
goto parse_error;
options = l->lval();
tok = l->lex();
while(tok != '\n')
{
if(tok != Lexer::Tok_str)
goto parse_error;
QCString env_str = l->lval();
env.append(env_str);
if(strncmp(env_str, "DESKTOP_STARTUP_ID=", strlen("DESKTOP_STARTUP_ID=")) != 0)
env_check += "*" + env_str;
tok = l->lex();
}
}
QCString auth_user;
if((m_Scheduler != SuProcess::SchedNormal) || (m_Priority > 50))
auth_user = "******";
else
auth_user = user;
key = makeKey(2, m_Host, auth_user, command);
// We only use the command if the environment is the same.
if(repo->find(key) == env_check)
{
key = makeKey(0, m_Host, auth_user, command);
pass = repo->find(key);
}
if(pass.isNull()) // isNull() means no password, isEmpty() can mean empty password
{
if(m_Pass.isNull())
{
respond(Res_NO);
break;
}
data.value = env_check;
data.timeout = m_Timeout;
key = makeKey(2, m_Host, auth_user, command);
repo->add(key, data);
data.value = m_Pass;
data.timeout = m_Timeout;
key = makeKey(0, m_Host, auth_user, command);
repo->add(key, data);
pass = m_Pass;
}
// Execute the command asynchronously
kdDebug(1205) << "Executing command: " << command << endl;
pid_t pid = fork();
if(pid < 0)
{
kdDebug(1205) << "fork(): " << strerror(errno) << endl;
respond(Res_NO);
break;
}
else if(pid > 0)
{
m_pid = pid;
respond(Res_OK);
break;
}
// Ignore SIGCHLD because "class SuProcess" needs waitpid()
signal(SIGCHLD, SIG_DFL);
int ret;
if(m_Host.isEmpty())
{
SuProcess proc;
proc.setCommand(command);
proc.setUser(user);
if(options.contains('x'))
proc.setXOnly(true);
if(options.contains('f'))
proc.setDCOPForwarding(true);
proc.setPriority(m_Priority);
proc.setScheduler(m_Scheduler);
proc.setEnvironment(env);
ret = proc.exec(pass.data());
}
else
{
SshProcess proc;
proc.setCommand(command);
proc.setUser(user);
proc.setHost(m_Host);
ret = proc.exec(pass.data());
}
kdDebug(1205) << "Command completed: " << command << endl;
_exit(ret);
}
case Lexer::Tok_delCmd: // "DEL command:string user:string\n"
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
command = l->lval();
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
user = l->lval();
if(l->lex() != '\n')
goto parse_error;
key = makeKey(0, m_Host, user, command);
if(repo->remove(key) < 0)
{
kdDebug(1205) << "Unknown command: " << command << endl;
respond(Res_NO);
}
else
{
kdDebug(1205) << "Deleted command: " << command << ", user = "******"DELV name:string \n"
{
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
name = l->lval();
tok = l->lex();
if(tok != '\n')
goto parse_error;
key = makeKey(1, name);
if(repo->remove(key) < 0)
{
kdDebug(1205) << "Unknown name: " << name << endl;
respond(Res_NO);
}
else
{
kdDebug(1205) << "Deleted name: " << name << endl;
respond(Res_OK);
}
break;
}
case Lexer::Tok_delGroup: // "DELG group:string\n"
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
name = l->lval();
if(repo->removeGroup(name) < 0)
{
kdDebug(1205) << "No keys found under group: " << name << endl;
respond(Res_NO);
}
else
{
kdDebug(1205) << "Removed all keys under group: " << name << endl;
respond(Res_OK);
}
break;
case Lexer::Tok_delSpecialKey: // "DELS special_key:string\n"
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
name = l->lval();
if(repo->removeSpecialKey(name) < 0)
respond(Res_NO);
else
respond(Res_OK);
break;
case Lexer::Tok_set: // "SET name:string value:string group:string timeout:int\n"
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
name = l->lval();
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
data.value = l->lval();
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
data.group = l->lval();
tok = l->lex();
if(tok != Lexer::Tok_num)
goto parse_error;
data.timeout = l->lval().toInt();
if(l->lex() != '\n')
goto parse_error;
key = makeKey(1, name);
repo->add(key, data);
kdDebug(1205) << "Stored key: " << key << endl;
respond(Res_OK);
break;
case Lexer::Tok_get: // "GET name:string\n"
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
name = l->lval();
if(l->lex() != '\n')
goto parse_error;
key = makeKey(1, name);
kdDebug(1205) << "Request for key: " << key << endl;
value = repo->find(key);
if(!value.isEmpty())
respond(Res_OK, value);
else
respond(Res_NO);
break;
case Lexer::Tok_getKeys: // "GETK groupname:string\n"
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
name = l->lval();
if(l->lex() != '\n')
goto parse_error;
kdDebug(1205) << "Request for group key: " << name << endl;
value = repo->findKeys(name);
if(!value.isEmpty())
respond(Res_OK, value);
else
respond(Res_NO);
break;
case Lexer::Tok_chkGroup: // "CHKG groupname:string\n"
tok = l->lex();
if(tok != Lexer::Tok_str)
goto parse_error;
name = l->lval();
if(l->lex() != '\n')
goto parse_error;
kdDebug(1205) << "Checking for group key: " << name << endl;
if(repo->hasGroup(name) < 0)
respond(Res_NO);
else
respond(Res_OK);
break;
case Lexer::Tok_ping: // "PING\n"
tok = l->lex();
if(tok != '\n')
goto parse_error;
respond(Res_OK);
break;
case Lexer::Tok_exit: // "EXIT\n"
tok = l->lex();
if(tok != '\n')
goto parse_error;
m_needExitCode = true;
if(m_hasExitCode)
sendExitCode();
break;
case Lexer::Tok_stop: // "STOP\n"
tok = l->lex();
if(tok != '\n')
goto parse_error;
kdDebug(1205) << "Stopping by command" << endl;
respond(Res_OK);
kdesud_cleanup();
exit(0);
default:
kdWarning(1205) << "Unknown command: " << l->lval() << endl;
respond(Res_NO);
goto parse_error;
}
delete l;
return 0;
parse_error:
kdWarning(1205) << "Parse error" << endl;
delete l;
return -1;
}