/*
Close a command channel. Must be able to be called redundantly.
*/
PUBLIC void mprCloseCmdFd(MprCmd *cmd, int channel)
{
assert(cmd);
assert(0 <= channel && channel <= MPR_CMD_MAX_PIPE);
if (cmd->handlers[channel]) {
assert(cmd->handlers[channel]->fd >= 0);
mprDestroyWaitHandler(cmd->handlers[channel]);
cmd->handlers[channel] = 0;
}
if (cmd->files[channel].fd != -1) {
close(cmd->files[channel].fd);
cmd->files[channel].fd = -1;
#if ME_WIN_LIKE
cmd->files[channel].handle = 0;
#endif
if (channel != MPR_CMD_STDIN) {
cmd->eofCount++;
if (cmd->eofCount >= cmd->requiredEof) {
#if VXWORKS || XCODE_DEBUG
reapCmd(cmd, 0);
#endif
if (cmd->pid == 0) {
completeCommand(cmd);
}
}
}
}
}
bool RCommandLine::event(QEvent* event) {
if (event->type() == QEvent::KeyPress) {
QKeyEvent* ke = dynamic_cast<QKeyEvent*> (event);
if (ke->key() == Qt::Key_Tab) {
emit completeCommand(text());
return true;
}
}
return QLineEdit::event(event);
}
static HelperCommand *
dequeueCommand(void)
{
HelperCommand *command = NULL;
CommandQueue *queue = &commandQueue;
jint size;
debugMonitorEnter(commandQueueLock);
while (command == NULL) {
while (holdEvents || (queue->head == NULL)) {
debugMonitorWait(commandQueueLock);
}
JDI_ASSERT(queue->head);
command = queue->head;
queue->head = command->next;
if (queue->tail == command) {
queue->tail = NULL;
}
log_debugee_location("dequeueCommand(): command being dequeued", NULL, NULL, 0);
size = commandSize(command);
/*
* Immediately close out any commands enqueued from a
* previously attached debugger.
*/
if (command->sessionID != currentSessionID) {
log_debugee_location("dequeueCommand(): command session removal", NULL, NULL, 0);
completeCommand(command);
command = NULL;
}
/*
* There's room in the queue for more.
*/
currentQueueSize -= size;
debugMonitorNotifyAll(commandQueueLock);
}
debugMonitorExit(commandQueueLock);
return command;
}
void executeCommandAndWaitForResponse (const char *command, const char *response) {
command = completeCommand(command);
int res = fputs(command, file);
if (res == EOF) {
perror("Could not send command");
fclose(file);
return;
}
while ((line = fgetln(file, &length))) {
if (strstr(line, response) != NULL) {
// Got expected response
break;
}
memset(line, 0, sizeof(char)*4096);
}
}
void com_ximeta_driver_NDASPhysicalUnitDevice::setPendingCommand(com_ximeta_driver_NDASCommand* command)
{
DbgIOLog(DEBUG_MASK_NDAS_TRACE, ("setPendingCommand: Entered. Command 0x%x\n", command));
if (command &&
command->scsiCommand()->completeWhenFailed) {
completeCommand(command);
return;
}
if (command) {
command->retain();
}
if (fTargetInfo.fTargetPendingCommand) {
fTargetInfo.fTargetPendingCommand->release();
}
fTargetInfo.fTargetPendingCommand = command;
}
/*
* The event helper thread. Dequeues commands and processes them.
*/
static void JNICALL
commandLoop(jvmtiEnv* jvmti_env, JNIEnv* jni_env, void* arg)
{
LOG_MISC(("Begin command loop thread"));
while (JNI_TRUE) {
HelperCommand *command = dequeueCommand();
if (command != NULL) {
/*
* Setup for a potential doBlockCommand() call before calling
* handleCommand() to prevent any races.
*/
jboolean doBlock = needBlockCommandLoop(command);
log_debugee_location("commandLoop(): command being handled", NULL, NULL, 0);
handleCommand(jni_env, command);
completeCommand(command);
/* if we just finished a suspend-all cmd, then we block here */
if (doBlock) {
doBlockCommandLoop();
}
}
}
/* This loop never ends, even as connections come and go with server=y */
}
/*
Gather the child's exit status.
WARNING: this may be called with a false-positive, ie. SIGCHLD will get invoked for all process deaths and not just
when this cmd has completed.
*/
static void reapCmd(MprCmd *cmd, bool finalizing)
{
if (cmd->pid == 0) {
return;
}
#if ME_UNIX_LIKE
{
int status, rc;
status = 0;
if ((rc = waitpid(cmd->pid, &status, WNOHANG | __WALL)) < 0) {
mprLog("error mpr cmd", 0, "Waitpid failed for pid %d, errno %d", cmd->pid, errno);
} else if (rc == cmd->pid) {
if (!WIFSTOPPED(status)) {
if (WIFEXITED(status)) {
cmd->status = WEXITSTATUS(status);
mprDebug("mpr cmd", 6, "Process exited pid %d, status %d", cmd->pid, cmd->status);
} else if (WIFSIGNALED(status)) {
cmd->status = WTERMSIG(status);
}
cmd->pid = 0;
if (cmd->signal) {
mprRemoveSignalHandler(cmd->signal);
cmd->signal = 0;
}
}
} else {
mprDebug("mpr cmd", 6, "Still running pid %d, thread %s", cmd->pid, mprGetCurrentThreadName());
}
}
#endif
#if VXWORKS
/*
The command exit status (cmd->status) is set in cmdTaskEntry
*/
if (!cmd->stopped) {
if (semTake(cmd->exitCond, MPR_TIMEOUT_STOP_TASK) != OK) {
mprLog("error mpr cmd", 0, "Child %s did not exit, errno %d", cmd->program, errno);
return;
}
}
semDelete(cmd->exitCond);
cmd->exitCond = 0;
cmd->pid = 0;
#endif
#if ME_WIN_LIKE
{
int status, rc;
status = 0;
if (GetExitCodeProcess(cmd->process, (ulong*) &status) == 0) {
mprLog("error mpr cmd", 0, "GetExitProcess error");
return;
}
if (status != STILL_ACTIVE) {
cmd->status = status;
rc = CloseHandle(cmd->process);
assert(rc != 0);
rc = CloseHandle(cmd->thread);
assert(rc != 0);
cmd->process = 0;
cmd->thread = 0;
cmd->pid = 0;
}
}
#endif
if (cmd->pid == 0) {
if (cmd->eofCount >= cmd->requiredEof) {
completeCommand(cmd);
}
mprDebug("mpr cmd", 6, "Process reaped: status %d, pid %d, eof %d / %d", cmd->status, cmd->pid,
cmd->eofCount, cmd->requiredEof);
if (cmd->callback) {
(cmd->callback)(cmd, -1, cmd->callbackData);
}
}
}
/* FIXME: Define the type 'struct command_stream' here. This should
complete the incomplete type declaration in command.h. */
command_stream_t make_command_stream(int(*get_next_byte) (void *),
void *get_next_byte_argument)
{
/* FIXME: Replace this with your implementation. You may need to
add auxiliary functions and otherwise modify the source code.
You can also use external functions defined in the GNU C Library. */
if (DEBUG) printf("291 Begin make_command_stream\n");
initStream();
size_t sizeofBuffer = 1024;
char* buffer = (char*)checked_malloc(sizeofBuffer);
char curr;
size_t filled = 0;
while ((curr = get_next_byte(get_next_byte_argument)) != EOF) {
buffer[filled] = curr;
filled++;
if (filled == sizeofBuffer) {
sizeofBuffer *= 2;
buffer = (char*)checked_grow_alloc(buffer, &sizeofBuffer);
}
}
//***For the parser:
//Word
int bufferWordSize = 10;
int currWord = 0;
//char ** wordElement;
char** wordElement = checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
int usedWord = 0;
//Input
int bufferInputSize = 10;
char* inputElement = (char*)checked_malloc(bufferInputSize);
int usedInput = 0;
//Output
int bufferOutputSize = 10;
char* outputElement = (char*)checked_malloc(bufferOutputSize);
int usedOutput = 0;
//***Initialize operator and command stacks
initStacks();
if (DEBUG) printf("333 Buffer created, initStacks()\n");
int i = 0;
while (i < (int)filled)
{
if (DEBUG) printf("on buffer %d\n", i);
//***When you want to add a character*************************//
int op = -1;
int openCount = 0;
int closedCount = 0;
if (buffer[i] == '`')
error(1, 0, "Line %d: %c", __LINE__, buffer[i]);
if (buffer[i] == '(')
{
openCount = 1;
closedCount = 0;
int x = i;
while (x < (int) filled)
{
x++;
if (buffer[x] == '(')
openCount++;
if (buffer[x] == ')')
closedCount++;
if (closedCount == openCount)
break;
}
if (closedCount != openCount)
error(1, 0, "Line %d: Expected ')' for end of subshell", __LINE__);
}
if(buffer[i] == ')')
{
if(openCount == 0)
error(1, 0, "Line %d: Expected '(' before ')'", __LINE__);
}
if(buffer[i] = '(')
{
op = numberOfOper(&buffer[i]);
processOperator(op);
}
//Case of ' '
while (buffer[i] == ' ' && usedWord == 0)
i++;
if (buffer[i] == ' ' && usedWord != 0)
{
if (usedWord >= bufferWordSize)
{
bufferWordSize += 10;
wordElement[currWord] = (char*)checked_realloc(wordElement[currWord], bufferWordSize);
}
//i++;
wordElement[currWord][usedWord] = '\0';
while (buffer[i + 1] == ' ')
i++;
usedWord = 0;
bufferWordSize = 10;
currWord++;
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
//wordElement[currWord][usedWord] = buffer[i];
//usedWord++;
}
//Case of carrots
//WHAT IF a<b>c>d<a....?! You're making a simple command out of a<b>c which then
// must also be the word of >d<a
//Case of '<' first
else
if (buffer[i] == '<')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
if (wordElement[0][0] == '\0')
error(1, 0, "Line %d: No command given to '<'", __LINE__);
i++;
while (buffer[i] != '<' && buffer[i] != '>' && buffer[i] != '&' && buffer[i] != '|' && buffer[i] != '(' && buffer[i] != ')' && buffer[i] != ';' && buffer[i] != '\n')
{
if (i == filled)
{
if (DEBUG) printf("378 Complete command, free buffer bc EOF\n");
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
//free(buffer);
return headStream;
}
if (buffer[i] == ' ')
i++;
else
{
if (usedInput >= bufferInputSize)
{
bufferInputSize += 10;
inputElement = (char*)checked_realloc(inputElement, bufferInputSize);
}
inputElement[usedInput] = buffer[i];
usedInput++;
i++;
}
}
if (usedInput >= bufferInputSize)
{
bufferInputSize += 10;
inputElement = (char*)checked_realloc(inputElement, bufferInputSize);
}
if (usedInput == 0)
error(1, 0, "Line %d: No input after '<'", __LINE__);
inputElement[usedInput] = '\0';
usedInput++;
if (buffer[i] == '>')
{
i++;
while (buffer[i] != '<' && buffer[i] != '>' && buffer[i] != '&' && buffer[i] != '|' && buffer[i] != '(' && buffer[i] != ')' && buffer[i] != ';' && buffer[i] != '\n')
{
if (i == filled)
{
if (DEBUG) printf("413 Complete command, free buffer at EOF\n");
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
//free(buffer);
return headStream;
}
if (buffer[i] == ' ')
i++;
else
{
if (usedOutput >= bufferOutputSize)
{
bufferOutputSize += 10;
outputElement = (char*)checked_realloc(outputElement, bufferOutputSize);
}
outputElement[usedOutput] = buffer[i];
usedOutput++;
i++;
}
}
if (usedOutput >= bufferOutputSize)
{
bufferOutputSize += 10;
outputElement = (char*)checked_realloc(outputElement, bufferOutputSize);
}
if (usedOutput == 0)
error(1, 0, "Line %d: No input after '<'", __LINE__);
outputElement[usedOutput] = '\0';
usedOutput++;
//i--; //Check logic
}
i--;
}
/////CHECK FOR EXTRA i++!!!!!
//Case of '>' first
else
if (buffer[i] == '>')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
if (wordElement[0][0] == '\0')
error(1, 0, "Line %d: No command given to '<'", __LINE__);
i++;
while (buffer[i] != '<' && buffer[i] != '>' && buffer[i] != '&' && buffer[i] != '|' && buffer[i] != '(' && buffer[i] != ')' && buffer[i] != ';' && buffer[i] != '\n')
{
if (i == filled)
{
if (DEBUG) printf("471 Complete Command, free buffer at EOF");
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
//free(buffer);
return headStream;
}
if (buffer[i] == ' ')
i++;
else
{
if (usedOutput >= bufferOutputSize)
{
bufferOutputSize += 10;
outputElement = (char*)checked_realloc(outputElement, bufferOutputSize);
}
outputElement[usedOutput] = buffer[i];
usedOutput++;
i++;
}
}
if (usedOutput >= bufferOutputSize)
{
bufferOutputSize += 10;
outputElement = (char*)checked_realloc(outputElement, bufferOutputSize);
}
if (usedOutput == 0)
error(1, 0, "Line %d: No input after '<'", __LINE__);
outputElement[usedOutput] = '\0';
usedOutput++;
if (buffer[i] == '<')
{
i++;
while (buffer[i] != '<' && buffer[i] != '>' && buffer[i] != '&' && buffer[i] != '|' && buffer[i] != '(' && buffer[i] != ')' && buffer[i] != ';' && buffer[i] != '\n')
{
if (i == filled)
{
if (DEBUG) printf("505 Complete Command, free buffer at EOF");
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
//free(buffer);
return headStream;
}
if (buffer[i] == ' ')
i++;
else
{
if (usedInput >= bufferInputSize)
{
bufferInputSize += 10;
inputElement = (char*)checked_realloc(inputElement, bufferInputSize);
}
inputElement[usedInput] = buffer[i];
usedInput++;
i++;
}
}
if (usedInput >= bufferInputSize)
{
bufferInputSize += 10;
inputElement = (char*)checked_realloc(inputElement, bufferInputSize);
}
if (usedInput == 0)
error(1, 0, "Line %d: No input after '<'", __LINE__);
inputElement[usedInput] = '\0';
usedInput++;
}
wordElement[currWord + 1] = '\0';
/*if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if(DEBUG) printf("makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);*/
i--;
}
//Operators
//After every operator is encountered, use makeSimpleCommand to push the command on the stack
//Case of '|'
else
if (buffer[i] == '|')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
if (buffer[i+1] == '|' && operatorStack == NULL)
error(1, 0, "Line %d: Missing pipe for '||'", __LINE__);
if (wordElement[0][0] == '\0')
error(1, 0, "Line %d: Nothing for '|'", __LINE__);
//if (commandStack == NULL)
// error(1, 0, "Line %d: Nothing to run '|' on");
if (buffer[i + 1] == '|' && buffer[i+2] == '|')
error(1, 0, "Line %d: Invalid Command, too many '|'", i);
op = numberOfOper(&buffer[i]);
//error(1, 0, "Line %d: Nothing to pipe", __LINE__);
if (buffer[i-1] != ' ')
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf(" 566 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
if (DEBUG) printf("577 Process operator %d\n", op);
processOperator(op);
if (op == 3)
i++;
if (buffer[i + 1] == ' ')
i++;
//i++;
}
//Case of '&'
else
if (buffer[i] == '&')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
//if (buffer[i] == '&' && operatorStack == NULL)
// error(1, 0, "Line %d: Missing pipe for '&&'", __LINE__);
if (wordElement[0][0] == '\0')
error(1, 0, "Line %d: Nothing for '|'", __LINE__);
if (buffer[i + 1] == '&' && buffer[i+2] == '&')
error(1, 0, "Line %d: Invalid Command, too many '&'", i);
op = numberOfOper(&buffer[i]);
if (buffer[i-1] != ' ')
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf("592 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
usedWord = 0;
currWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
processOperator(op);
i++;
if (buffer[i + 1] == ' ')
i++;
}
//Case of ';'
else
if (buffer[i] == ';')
{
int k = i;
while (buffer[k-1] == ' ')
{
k--;
if(buffer[k-1] == '\n')
error(1, 0, "Line %d: Operator and word on diff lines", __LINE__);
}
if(wordElement[0][0] == '\0')
error(1, 0, "Line %d: Nothing before sequence", i);
op = numberOfOper(&buffer[i]);
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf("617 makeSimpleCommand %s\n", wordElement[0]);
if ((currWord = 0) || (currWord == 1))
error(1, 0, "Line %d: Nothing to run ';' on", i);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
usedWord = 0;
currWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
processOperator(op);
//i++;
}
//Case of '\n'
else
if (buffer[i] == '\n' && i != 0)
{
/*int scChecker = i;
while (buffer[i + 1] == ' ')
{
scChecker++;
if (buffer[scChecker + 1] == ';')
error(1, 0, "Line %d: Newline followed by ';'");
}*/
if (buffer[i+1] == ';')
error(1, 0, "Line %d: Newline followed by ';'", i);
if ((i + 1) == (int)filled)
{
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf("654 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
completeCommand();
free(buffer);
return headStream;
}
char lastC;
int back = 1;
while (buffer[i - back] == ' ' && i - back >= 0)
{
//lastC = buffer[i - back];
back++;
}
lastC = buffer[i - back];
if (buffer[i + 1] == '\n')
{
while (buffer[i + 1] == '\n')
i++;
if (lastC != '|' && lastC != '&')
{
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf("654 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
completeCommand();
}
}
else
{
if (lastC == '|' || lastC == '&' || lastC == '<' || lastC || '>')
{
while (buffer[i + 1] == '\n')
i++;//////SPIT ERROR?
}
else
{
char swap = ';';
op = numberOfOper(&swap);
wordElement[currWord + 1] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
if (DEBUG) printf(" 679 makeSimpleCommand %s\n", wordElement[0]);
makeSimpleCommand(wordElement, inputElement, outputElement);
bufferWordSize = 10;
currWord = 0;
usedWord = 0;
usedInput = 0;
usedOutput = 0;
wordElement = (char**)checked_malloc(sizeof(char*));
wordElement[currWord] = (char*)checked_malloc(bufferWordSize);
inputElement = (char*)checked_malloc(bufferInputSize);
outputElement = (char*)checked_malloc(bufferOutputSize);
processOperator(op);
}
}
}
//Case of # (comment)
else
if (buffer[i] == '#')
{
if (DEBUG) printf("698 Got a comment!\n");
while (buffer[i] != '\n')
i++;
}
//Else
else
{
if (buffer[i] == '\'')
{
if (buffer[i + 1] == 'E' && buffer[i + 2] == 'O' && buffer[i + 3] == 'F')
break;
}
//if (buffer[i] != ' ')
wordElement[currWord][usedWord] = buffer[i];
usedWord++;
if (i + 1 == filled)
{
currWord++;
wordElement[currWord] = '\0';
if (usedInput == 0)
inputElement = NULL;
if (usedOutput == 0)
outputElement = NULL;
makeSimpleCommand(wordElement, inputElement, outputElement);
completeCommand();
}
}
i++;
}
free(buffer);
return headStream;
}
