void
reply_and_free (command_context * ctx, sbuf * reply)
{
command_manager *mgr = ctx->my_mgr;
// "delay" and "pgs_del" commands are not cancelable, because these commands
// have post action after receiving responses from workers. If cmd_cancel()
// function is called due to client disconnection, these commands with
// unable-to-cancel flag continue the execution and just swallow the reply
// after execution finishes and reply_and_free() is called.
if (ctx->swallow)
{
assert (ctx->unable_to_cancel);
cmd_free (ctx);
return;
}
ctx->reply_cb (reply, ctx->cbarg);
mgr->stat.numcommands++;
if (ctx->local)
{
mgr->stat.numcommands_local++;
}
cmd_free (ctx);
}
void
cmd_tcp_write(evutil_socket_t fd, short which, void *arg)
{
struct tcp_con *con = arg;
int len;
TRACE(fd, len = write(fd, con->readbuf, con->rlen));
if (len == -1) {
if (errno == EINTR || errno == EAGAIN)
goto again;
cmd_free(&con->cmd);
return;
} else if (len == 0) {
cmd_free(&con->cmd);
return;
}
memmove(con->readbuf, con->readbuf + len, con->rlen - len);
con->rlen -= len;
/* Shut down the connection if we received a FIN and sent all data */
if (con->rlen == 0 && con->cmd.fdgotfin)
TRACE(con->cmd_pfd, shutdown(con->cmd_pfd, SHUT_WR));
again:
cmd_trigger_write(&con->cmd, con->rlen);
}
void bye(void)
{
cliLogCommand("End Session");
//Set flag for thread to terminate
terminate_cli_check_session_thread = ACD_TRUE;
//Reset EditLine (useful if el_gets() did not complete normally)
if (el != NULL)
el_end(el);
//Free dynamically-allocated data
cli_command_cleanup(CLEAR_STATIC_DATA);
cli_free_command_cleanup_arr();
//Kill session
if (session_id)
cli_delete_session();
//Free IPC handles
cmd_free(&cli_backend_handle);
cmd_free(&cli_check_session_thread_ipc_handle);
#ifdef ACCEDIAN_CONFIG_DISCOVERY_ENABLED
if (acd_cap_discovery())
{
discovery_module_cleanup();
}
#endif
}
int __cdecl compare(const void *arg1,const void *arg2)
{
FileName * File1;
FileName * File2;
INT ret;
File1 = cmd_alloc(sizeof(FileName));
if (!File1)
return 0;
File2 = cmd_alloc(sizeof(FileName));
if (!File2)
{
cmd_free(File1);
return 0;
}
memcpy(File1,arg1,sizeof(FileName));
memcpy(File2,arg2,sizeof(FileName));
/* ret = _tcsicmp(File1->Name, File2->Name); */
ret = lstrcmpi(File1->Name, File2->Name);
cmd_free(File1);
cmd_free(File2);
return ret;
}
void
cmd_udp_write(int fd, short which, void *arg)
{
struct udp_con *con = arg;
struct conbuffer *buf;
ssize_t len;
buf = TAILQ_FIRST(&con->incoming);
if (buf == NULL)
return;
TRACE(fd, len = write(fd, buf->buf, buf->len));
if (len == -1) {
if (errno == EINTR || errno == EAGAIN)
goto again;
cmd_free(&con->cmd);
return;
} else if (len == 0) {
cmd_free(&con->cmd);
return;
}
TAILQ_REMOVE(&con->incoming, buf, next);
con->nincoming--;
free(buf->buf);
free(buf);
again:
cmd_trigger_write(&con->cmd, TAILQ_FIRST(&con->incoming) != NULL);
}
static
VOID del(LPHIST_ENTRY item)
{
if (item==NULL || item==Top || item==Bottom)
{
TRACE ("del in " __FILE__ ": returning\n"
"item is 0x%08x (Bottom is0x%08x)\n",
item, Bottom);
return;
}
/*free string's mem*/
if (item->string)
cmd_free(item->string);
/*set links in prev and next item*/
item->next->prev=item->prev;
item->prev->next=item->next;
cmd_free(item);
size--;
}
VOID CleanHistory(VOID)
{
while (Bottom->next!=Top)
del(Bottom->next);
cmd_free(Top);
cmd_free(Bottom);
}
static INT
PrintAllAssociations()
{
DWORD return_val = 0;
HKEY hKey = NULL;
DWORD numKeys = 0;
DWORD extLength = 0;
LPTSTR extName = NULL;
DWORD keyCtr = 0;
return_val = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE\\Classes"), 0, KEY_READ, &hKey);
if (return_val != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return -1;
}
return_val = RegQueryInfoKey(hKey, NULL, NULL, NULL, &numKeys, &extLength, NULL, NULL, NULL, NULL, NULL, NULL);
if (return_val != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return -2;
}
extLength++;
extName = cmd_alloc(extLength * sizeof(TCHAR));
for(keyCtr = 0; keyCtr < numKeys; keyCtr++)
{
DWORD buffer_size = extLength;
return_val = RegEnumKeyEx(hKey, keyCtr, extName, &buffer_size, NULL, NULL, NULL, NULL);
if (return_val == ERROR_SUCCESS || return_val == ERROR_MORE_DATA)
{
if (*extName == _T('.'))
PrintAssociation(extName);
}
else
{
cmd_free(extName);
RegCloseKey(hKey);
return -1;
}
}
RegCloseKey(hKey);
if (extName)
cmd_free(extName);
return numKeys;
}
/*
* free the allocated memory of a batch file
*/
VOID ClearBatch()
{
TRACE ("ClearBatch mem = %08x free = %d\n", bc->mem, bc->memfree);
if (bc->mem && bc->memfree)
cmd_free(bc->mem);
if (bc->raw_params)
cmd_free(bc->raw_params);
if (bc->params)
cmd_free(bc->params);
}
static int cmd_wpas_parse_cipher(const char *value)
{
int val = 0, last;
char *start, *end, *buf;
buf = cmd_strdup(value);
if (buf == NULL)
return -1;
start = buf;
while (*start != '\0') {
while (*start == ' ' || *start == '\t')
start++;
if (*start == '\0')
break;
end = start;
while (*end != ' ' && *end != '\t' && *end != '\0')
end++;
last = *end == '\0';
*end = '\0';
if (cmd_strcmp(start, "CCMP-256") == 0)
val |= WPA_CIPHER_CCMP_256;
else if (cmd_strcmp(start, "GCMP-256") == 0)
val |= WPA_CIPHER_GCMP_256;
else if (cmd_strcmp(start, "CCMP") == 0)
val |= WPA_CIPHER_CCMP;
else if (cmd_strcmp(start, "GCMP") == 0)
val |= WPA_CIPHER_GCMP;
else if (cmd_strcmp(start, "TKIP") == 0)
val |= WPA_CIPHER_TKIP;
else if (cmd_strcmp(start, "WEP104") == 0)
val |= WPA_CIPHER_WEP104;
else if (cmd_strcmp(start, "WEP40") == 0)
val |= WPA_CIPHER_WEP40;
else if (cmd_strcmp(start, "NONE") == 0)
val |= WPA_CIPHER_NONE;
else if (cmd_strcmp(start, "GTK_NOT_USED") == 0)
val |= WPA_CIPHER_GTK_NOT_USED;
else {
cmd_free(buf);
return -1;
}
if (last)
break;
start = end + 1;
}
cmd_free(buf);
return val;
}
void
cmd_free(command_t *cmd)
{
int i;
// It's OK to cmd_free(NULL).
if (!cmd)
return;
/* Your code here. */
cmd_free(cmd->subshell);
cmd_free(cmd->next);
free(cmd);
}
INT cmd_path (LPTSTR param)
{
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_PATH_HELP1);
return 0;
}
nErrorLevel = 0;
/* if param is empty, display the PATH environment variable */
if (!param || !*param)
{
DWORD dwBuffer;
LPTSTR pszBuffer;
pszBuffer = (LPTSTR)cmd_alloc (ENV_BUFFER_SIZE * sizeof(TCHAR));
dwBuffer = GetEnvironmentVariable (_T("PATH"), pszBuffer, ENV_BUFFER_SIZE);
if (dwBuffer == 0)
{
cmd_free(pszBuffer);
ConOutResPrintf(STRING_VOL_HELP2, _T("PATH"));
return 0;
}
else if (dwBuffer > ENV_BUFFER_SIZE)
{
pszBuffer = (LPTSTR)cmd_realloc (pszBuffer, dwBuffer * sizeof (TCHAR));
GetEnvironmentVariable (_T("PATH"), pszBuffer, dwBuffer);
}
ConOutPrintf (_T("PATH=%s\n"), pszBuffer);
cmd_free (pszBuffer);
return 0;
}
/* skip leading '=' */
if (*param == _T('='))
param++;
/* set PATH environment variable */
if (!SetEnvironmentVariable (_T("PATH"), param))
{
nErrorLevel = 1;
return 1;
}
return 0;
}
/*
* By Tuwei
* Here is big problem which is the father process cannot
* get the return value of the child process. so we cannot
* know the command itself is right or not.
*
* in the next version.we need to add the waitpid() function
* which can tell the result of the child process. but then
* we should use the multi-process technology.
*/
int
os_run(char* command)
{
int ret = -1;
char** p = cmd_getsegs(command);
if (p == NULL)
{
return -1;
}
signal(SIGCHLD, sig_handle);
pid_t pid = fork();
if (pid == 0)
{
if (execvp(p[0], p) == -1)
{
exit(-1);
}
}
else if (pid > 0)
{
ret = pid;
}
else
{
ret = -1;
}
cmd_free(p);
return ret;
}
void
cmd_tcp_connect_cb(evutil_socket_t fd, short which, void *arg)
{
struct tcp_con *con = arg;
int error = 0;
socklen_t errsz = sizeof(error);
/* Everything is ready */
cmd_ready_fd(&con->cmd, &cb_tcp, con);
if (which == EV_TIMEOUT)
goto out;
/* Check if the connection completed */
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &errsz) == -1) {
warn("%s: getsockopt for %d", __FUNCTION__, fd);
goto out;
}
if (error) {
warnx("%s: getsockopt: %s", __FUNCTION__, strerror(error));
goto out;
}
cmd_trigger_read(&con->cmd, con->psize - con->plen);
cmd_trigger_write(&con->cmd, con->rlen);
return;
out:
/* Connection failed, bring this down gracefully */
cmd_free(&con->cmd);
tcp_sendfin(con);
}
static VOID
PrintAlias (VOID)
{
LPTSTR Aliases;
LPTSTR ptr;
DWORD len;
len = GetConsoleAliasesLength(_T("cmd.exe"));
if (len == 0)
return;
/* allocate memory for an extra \0 char to make parsing easier */
ptr = cmd_alloc(len + sizeof(TCHAR));
if (!ptr)
{
WARN("Cannot allocate memory for ptr!\n");
return;
}
Aliases = ptr;
ZeroMemory(Aliases, len + sizeof(TCHAR));
if (GetConsoleAliases(Aliases, len, _T("cmd.exe")) != 0)
{
while (*Aliases != '\0')
{
ConOutPrintf(_T("%s\n"), Aliases);
Aliases = Aliases + lstrlen(Aliases);
Aliases++;
}
}
cmd_free(ptr);
}
void
do_raw (char *cmd) {
int argc;
char **argv;
int c;
int n_args;
printf ("$ %s\n", cmd);
argv = cmd_to_argc_argv (cmd, &argc);
while ((c = cmd_get_next_option (argc, argv, options)) > 0);
if (c == CMD_NOT_ALLOWED_OPTION ||
c == CMD_MISSING_ARGUMENT) {
cmd_print_error_message ();
return;
}
n_args = argc - optind;
cmd_free (argv);
free (cmd);
return;
}
void
cmd_tcp_eread(evutil_socket_t fd, short which, void *arg)
{
extern FILE *honeyd_servicefp;
struct tcp_con *con = arg;
char line[1024];
int nread;
struct command *cmd = &con->cmd;
TRACE(fd, nread = read(fd, line, sizeof(line)));
if (nread <= 0) {
if (cmd->fdwantclose) {
/* Stdin is already closed */
cmd_free(&con->cmd);
tcp_sendfin(con);
} else {
/* Now stdin will takes us down */
cmd->fdwantclose = 1;
}
return;
}
if (nread == sizeof(line))
nread--;
line[nread] = '\0';
honeyd_log_service(honeyd_servicefp, IP_PROTO_TCP, &con->conhdr, line);
TRACE(event_get_fd(cmd->peread), event_add(cmd->peread, NULL));
}
static VOID ConWrite(TCHAR *str, DWORD len, DWORD nStdHandle)
{
DWORD dwWritten;
HANDLE hOutput = GetStdHandle(nStdHandle);
if (WriteConsole(hOutput, str, len, &dwWritten, NULL))
return;
/* We're writing to a file or pipe instead of the console. Convert the
* string from TCHARs to the desired output format, if the two differ */
if (bUnicodeOutput)
{
#ifndef _UNICODE
WCHAR *buffer = cmd_alloc(len * sizeof(WCHAR));
if (!buffer)
{
error_out_of_memory();
return;
}
len = MultiByteToWideChar(OutputCodePage, 0, str, len, buffer, len);
str = (PVOID)buffer;
#endif
WriteFile(hOutput, str, len * sizeof(WCHAR), &dwWritten, NULL);
#ifndef _UNICODE
cmd_free(buffer);
#endif
}
else
{
#ifdef _UNICODE
CHAR *buffer = cmd_alloc(len * MB_LEN_MAX * sizeof(CHAR));
if (!buffer)
{
error_out_of_memory();
return;
}
len = WideCharToMultiByte(OutputCodePage, 0, str, len, buffer, len * MB_LEN_MAX, NULL, NULL);
str = (PVOID)buffer;
#endif
WriteFile(hOutput, str, len, &dwWritten, NULL);
#ifdef _UNICODE
cmd_free(buffer);
#endif
}
}
static int cmd_wpas_parse_proto(const char *value)
{
int val = 0, last, errors = 0;
char *start, *end, *buf;
buf = cmd_strdup(value);
if (buf == NULL)
return -1;
start = buf;
while (*start != '\0') {
while (*start == ' ' || *start == '\t')
start++;
if (*start == '\0')
break;
end = start;
while (*end != ' ' && *end != '\t' && *end != '\0')
end++;
last = *end == '\0';
*end = '\0';
/* softAP work on open mode. */
if (cmd_strcmp(start, "NONE") == 0) {
val = 0;
break;
}
if (cmd_strcmp(start, "WPA") == 0)
val |= WPA_PROTO_WPA;
else if (cmd_strcmp(start, "RSN") == 0 ||
cmd_strcmp(start, "WPA2") == 0)
val |= WPA_PROTO_RSN;
else if (cmd_strcmp(start, "OSEN") == 0)
val |= WPA_PROTO_OSEN;
else {
CMD_DBG("Invalid proto '%s'\n", start);
errors++;
}
if (last)
break;
start = end + 1;
}
cmd_free(buf);
/* softAP work on open mode. */
#if 0
if (val == 0) {
CMD_DBG("No proto values configured\n");
errors++;
}
#endif
CMD_DBG("proto: 0x%x\n", val);
return errors ? -1 : val;
}
void
cmd_cancel (command_context * ctx)
{
if (ctx->unable_to_cancel)
{
ctx->swallow = 1;
return;
}
cmd_free (ctx);
}
/* t_parse: test parse */
int t_parse(const char *line)
{
struct command *cmd;
fprintf(stderr, "t_parse input line: |%s|\n", line);
if ((cmd = cmd_creat(line)) == (struct command *)0)
err_quit("parse error");
cmd_write(cmd);
cmd_free(cmd);
return 0;
}
static enum cmd_status cmd_mqtt_deinit_exec(char *cmd)
{
if (connectData.username.lenstring.len != 0)
cmd_free(connectData.username.lenstring.data);
if (connectData.password.lenstring.len != 0)
cmd_free(connectData.password.lenstring.data);
cmd_free(send_buf);
cmd_free(recv_buf);
cmd_free(client_name);
OS_MutexDelete(&lock);
connectData = (MQTTPacket_connectData)MQTTPacket_connectData_initializer;
return CMD_STATUS_OK;
}
VOID
FreeRedirection(REDIRECTION *Redir)
{
REDIRECTION *Next;
for (; Redir; Redir = Next)
{
Next = Redir->Next;
ASSERT(Redir->OldHandle == INVALID_HANDLE_VALUE);
cmd_free(Redir);
}
}
void server_eof(struct connection *server, const char *reason)
{
LOG(WARN, "server eof");
struct command *c;
while (!STAILQ_EMPTY(&server->info->ready_queue)) {
c = STAILQ_FIRST(&server->info->ready_queue);
STAILQ_REMOVE_HEAD(&server->info->ready_queue, ready_next);
STAILQ_NEXT(c, ready_next) = NULL;
if (c->stale) {
cmd_free(c);
} else {
cmd_mark_fail(c, reason);
}
}
// remove unprocessed data
struct mbuf *b = TAILQ_LAST(&server->info->data, mhdr);
if (b != NULL && b->pos < b->last) {
b->pos = b->last;
}
while (!STAILQ_EMPTY(&server->info->waiting_queue)) {
c = STAILQ_FIRST(&server->info->waiting_queue);
STAILQ_REMOVE_HEAD(&server->info->waiting_queue, waiting_next);
STAILQ_NEXT(c, waiting_next) = NULL;
mbuf_range_clear(server->ctx, c->rep_buf);
if (c->stale) {
cmd_free(c);
} else {
cmd_mark_fail(c, reason);
}
}
event_deregister(&server->ctx->loop, server);
// drop all unsent requests
cmd_iov_free(&server->info->iov);
conn_free(server);
slot_create_job(SLOT_UPDATE);
}
void
cmd_list_free(struct cmd_list *cmdlist)
{
struct cmd *cmd;
while (!TAILQ_EMPTY(cmdlist)) {
cmd = TAILQ_FIRST(cmdlist);
TAILQ_REMOVE(cmdlist, cmd, qentry);
cmd_free(cmd);
}
xfree(cmdlist);
}
int
seq_delete_cmd(
seq_t seq,
cmd_t cmd)
{
cmd_t prev = seq->s_first;
if (cmd == seq->s_first) {
seq->s_first = seq->s_first->c_next;
cmd_free(cmd);
return 0;
}
while (prev != NULL && prev->c_next != cmd)
prev = prev->c_next;
if (prev == NULL)
return -1;
if (cmd == seq->s_last)
seq->s_last = prev;
prev->c_next = cmd->c_next;
cmd_free(cmd);
return 0;
}
int
seq_free(
seq_t seq)
{
cmd_t cmd = seq->s_first;
while (cmd) {
seq->s_first = seq->s_first->c_next;
cmd_free(cmd);
cmd = seq->s_first;
}
free(seq);
return 0;
}
void
cmd_tcp_read(evutil_socket_t fd, short which, void *arg)
{
struct tcp_con *con = arg;
int len, space;
struct command *cmd = &con->cmd;
space = con->psize - con->plen;
if (space <= 0)
return;
TRACE(fd, len = read(fd, con->payload + con->plen, space));
if (len == -1) {
if (errno == EINTR || errno == EAGAIN)
goto again;
cmd_free(&con->cmd);
tcp_sendfin(con);
return;
} else if (len == 0) {
if (cmd->perrfd != -1 && !cmd->fdwantclose) {
cmd->fdwantclose = 1;
return;
}
cmd_free(&con->cmd);
tcp_sendfin(con);
return;
}
con->plen += len;
if (con->plen == con->psize)
tcp_increase_buf(&con->payload, &con->psize, TCP_MAX_SIZE);
/* XXX - Trigger write */
tcp_senddata(con, TH_ACK);
again:
cmd_trigger_read(&con->cmd, con->psize - con->plen);
}
INT CommandAssoc (LPTSTR param)
{
/* print help */
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_ASSOC_HELP);
return 0;
}
nErrorLevel = 0;
if (_tcslen(param) == 0)
PrintAllAssociations();
else
{
LPTSTR lpEqualSign = _tcschr(param, _T('='));
if (lpEqualSign != NULL)
{
LPTSTR fileType = lpEqualSign + 1;
LPTSTR extension = cmd_alloc((lpEqualSign - param + 1) * sizeof(TCHAR));
_tcsncpy(extension, param, lpEqualSign - param);
extension[lpEqualSign - param] = (TCHAR)0;
if (_tcslen(fileType) == 0)
/* if the equal sign is the last character
in the string, then delete the key */
{
RemoveAssociation(extension);
}
else
/* otherwise, add the key and print out the association*/
{
AddAssociation( extension, fileType);
PrintAssociation(extension);
}
cmd_free(extension);
}
else
{
/* no equal sign, print all associations */
INT retval = PrintAssociation(param);
if (retval == 0) /* if nothing printed out */
ConOutResPrintf(STRING_ASSOC_ERROR, param);
}
}
return 0;
}
/* parse: pares input line into cmd
free with free_cmd() */
struct command *cmd_creat(const char *input)
{
struct command *cmd;
char *s, *t;
int background = 0; /* 1 if background process */
cmd = Malloc(sizeof(struct command));
bzero(cmd, sizeof(struct command));
s = s_dup(input);
if (*(s+strlen(s)-1) == '&') {
*(s+strlen(s)-1) = '\0';
background = 1;
}
if (strchr(s, '|') != '\0') {
if (pipeline_parse(cmd, s) == -1) {
cmd_free(cmd);
free(s);
DP("%s", "pipeline_parse error");
return (struct command *)0;
}
} else {
/* remove redirection options from s */
t = io_parse(cmd, s);
if (argv_parse(cmd, t) == -1) {
cmd_free(cmd);
free(s);
DP("%s", "argv_parse error");
return (struct command *)0;
}
}
free(s);
free(t);
cmd->background = background;
return cmd;
}
