// // ACE_TMAIN // int ACE_TMAIN (int argc, char * argv []) { int retval; u_long default_mask = LM_EMERGENCY | LM_ALERT | LM_CRITICAL | LM_ERROR | LM_WARNING | LM_NOTICE; ACE_Log_Msg::instance ()->priority_mask (default_mask, ACE_Log_Msg::PROCESS); try { // Register the signal handler. register_sighandler (); // Run the main part of the application. retval = LOGGING_SERVER->run_main (argc, argv); } catch (...) { ACE_ERROR ((LM_ERROR, "%T - [%M] - caught unknown exception\n")); retval = 1; } // Destroy the server's resources. LOGGING_SERVER->destroy (); return retval; }
// // ACE_TMAIN // int ACE_TMAIN (int argc, char * argv []) { int retval = 0; // Get the current priority levels. u_long prio = LM_ALERT | LM_CRITICAL | LM_EMERGENCY | LM_ERROR | LM_WARNING; ACE_Log_Msg::instance ()->priority_mask (prio, ACE_Log_Msg::PROCESS); // Register the signal handler. register_sighandler (); try { retval = OASIS_SYSTEM_PROBE_DAEMON->run_main (argc, argv); } catch (const std::exception & ex) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%T (%t) - %M - %s\n"), ex.what ())); retval = 1; } return retval; }
// // main // int ACE_TMAIN (int argc, ACE_TCHAR * argv []) { CUTS_TEST_TRACE ("ACE_TMAIN (int, ACE_TCHAR * [])"); try { // Register the signal handler. register_sighandler (); // Run the main application. return TESTING_APP->run_main (argc, argv); } catch (...) { ACE_ERROR ((LM_ERROR, "%T (%t) - %M - caught unknown exception\n")); } return 1; }
/* main * * main handles the shell program flow and returns 0 on exit. */ int main () { pid_t child_pid; /* Keep track of child process while forking. */ long long timediff; /* Helps us time processes. */ int FOREGROUND; /* Foreground or background process branch? */ char command[MAX_COMMAND_SIZE]; /* User-specified command. */ char * command_args[MAX_COMMAND_SIZE]; /* Command arguments. */ char * pchr; /* char pointer used for string parsing. */ int param_index = 0; /* Holds which parameter we're at while parsing, and after parsing is done equals the number of parameters. */ int child_status; /* Keep track of child process status. */ struct timeval time1,time2; /* Structs used to track time. */ int return_value; /* Temp variable to save return values of system calls. */ char * return_value_ptr; /* Temp variable to save return value from fgets. */ /* * Ignore sig-interrupt (Ctrl-C) in the parent (this) process. */ signal(SIGINT,SIG_IGN); /* * Install handler for SIGCHLD if needed. */ #if SIGNALDETECTION register_sighandler(SIGCHLD, sigchld_handler); #endif /* main program loop */ for (;;) { /* get command string */ return_value_ptr = fgets(command,MAX_COMMAND_SIZE,stdin); /* if EINTR, no nothing */ if (return_value_ptr == NULL && errno == EINTR) continue; /* empty line (only newline), do nothing */ if (strlen(command) == 1) continue; /* if last char is '&', set FOREGROUND to 0, otherwise set it to 1 */ if (strlen(command) >= 2 && command[strlen(command)-2] == '&') { /* replace '&' with '\0' */ command[strlen(command)-2] = '\0'; FOREGROUND = 0; } else { FOREGROUND = 1; } /* replace newline character with null terminator */ command[strlen(command)-1] = '\0'; /* check for exit command */ if (!strcmp(command,"exit")) break; /* split command string at spaces */ pchr = strtok(command," "); /* first parameter is always the program itself */ param_index = 0; command_args[param_index] = pchr; ++param_index; /* go through and save parameters into string array */ while (pchr != NULL) { pchr = strtok(NULL," "); command_args[param_index] = pchr; ++param_index; } /* check for cd command */ if (!strncmp(command,"cd",2)) { /* cd always takes 3 parameters ("cd cd example/directory/") */ if (param_index != 3) { printf("==> ERROR: Invalid argument count to cd!\n"); continue; } /* check the return value from chdir */ return_value = chdir(command_args[1]); if (return_value == -1) { /* the directory is not valid */ if (ENOTDIR) { printf("==> ERROR: Invalid directory, sending you home...\n"); chdir(getenv("HOME")); /* another error, unknown... */ } else { printf("==> ERROR: Couldn't change directory to %s\n",command_args[1]); } } /* don't run rest of loop */ continue; } /* check no. of arguments */ if (param_index > MAX_NO_ARGS) fprintf(stderr,"Error: Too many arguments!"); /* executed for foreground process execution */ if (FOREGROUND) { child_pid = fork(); if (child_pid == 0) { /* unignore sig-interrupt in the child process (Ctrl-C) */ signal(SIGINT,SIG_DFL); /* execute command with specified arguments */ (void)execvp(command,command_args); printf("==> ERROR: Could not execute command: %s\n",command); exit(1); } else if (child_pid == -1) { /* couldn't fork, something is wrong */ fprintf(stderr,"==> ERROR: Couldn't fork!"); exit(1); } /* this is executed by the parent process, we want to wait for * the child process to finish execution, and wait for its finished * execution */ /* get first time measurement */ gettimeofday(&time1,NULL); printf("==> %d - spawned foreground process\n",(int)child_pid); /* wait for child to finish */ child_pid = waitpid(child_pid,&child_status,0); /* get second time measurement */ gettimeofday(&time2,NULL); /* calculate time difference in microseconds */ timediff = ((time2.tv_sec*1e6+time2.tv_usec)-(time1.tv_sec*1e6+time1.tv_usec)); print_exit_msg(child_pid); printf("==> execution time: %lf seconds\n",timediff/1e6); } else { /* background process execution */ child_pid = fork(); if (child_pid == 0) { /* unignore sig-interrupt in child (Ctrl-C) */ signal(SIGINT,SIG_DFL); /* execute command with specified arguments */ (void)execvp(command,command_args); printf("==> ERROR: Could not execute command: %s\n",command); exit(1); } else if (child_pid == -1) { /* unknown forking error, shouldn't happen */ fprintf(stderr,"==> ERROR: Couldn't fork!"); exit(1); } /* this is executed by the parent process */ printf("==> %d - spawned background process\n",(int)child_pid); } /* * Perform polling of child process state changes to detect if any such * has terminated. Only performed if signal detection is not activated. */ #if !SIGNALDETECTION for (;;) { /* Asynchronously check if any process has terminated. */ child_pid = waitpid(-1,&child_status,WNOHANG); /* if nothing has changed, or if error, break the loop */ if (child_pid == 0 || child_pid == -1) { break; } /* here, a process has terminated */ print_exit_msg(child_pid); } #endif } return 0; }
int main(int argc, const char *argv[]) { char linebuf[LIMIT+1]; char *read; char **tokens; int len, bg; #if SIGDET == 0 /*pid_t pid; int status;*/ #endif register_sighandler(SIGINT, parent_sigint); register_sighandler(SIGTSTP, parent_sigtstp); /* SIGDET = 1 means that the child is responsible for reporting to its parent when it's done so we register a sighandler for that */ #if SIGDET == 1 register_sighandler(SIGCHLD, parent_sigchld); #endif while (TRUE) { read = NULL; tokens = 0; bg = FALSE; #if SIGDET == 0 poll_childs(); #endif type_prompt(); read = fgets(linebuf, LIMIT, stdin); if (read != linebuf) { /* end of file - quit as with exit command */ if (feof(stdin)) { printf("^D\n"); strcpy(linebuf, "exit\n"); } else { /* some interrupt, proceed to next read */ continue; } } /* trim whitespace right (in order to read flag later) */ len = strlen(linebuf); while ((len > 0) && (linebuf[len-1] == '\n' || linebuf[len-1] == ' ')) { linebuf[len-1] = '\0'; len -= 1; } /* check for background flag */ if (len > 0 && linebuf[len-1] == '&') { bg = TRUE; linebuf[len-1] = '\0'; len -= 1; } tokens = tokenize(linebuf, '|'); exec_command(tokens, bg); } return 0; }
/* * Interpret the user input as either * a shell command or a program to be run */ void exec_command(char **tokens, int bg) { char *path, *first, **firstparsed, **checkenv, *pager; char *pathenv, *pathcp, **pathtokens; char *tmp_str; int i; pid_t parent; /* copy the first command string and handle * this case specially - it might be a shell command */ first = malloc(sizeof(char)*strlen(tokens[0])+1); strcpy(first, tokens[0]); firstparsed = tokenize(first, ' '); if (strcmp(firstparsed[0], "") == 0) { free(first); free(firstparsed); free(tokens); return; } if (strcmp(firstparsed[0], "exit") == 0) { free(first); free(firstparsed); free(tokens); /* try to terminate all childs before exiting */ /* send term to whole group, but ignore in parent */ register_sighandler(SIGTERM, SIG_IGN); parent = getpid(); sighold(SIGCHLD); /* give processes a chance to finish */ if (kill(-parent, SIGTERM) == -1) { printf("Error: %s\n", strerror(errno)); exit(1); } sleep(1); poll_childs(); sigrelse(SIGCHLD); printf("Bye!\n"); exit(0); } if (strcmp(firstparsed[0], "cd") == 0) { if (firstparsed[1] == '\0') { /* default dir to change to */ path = getenv("HOME"); } else { path = firstparsed[1]; } if (DEBUG) { printf("Change Directory to %s\n", path); } if (chdir(path) == -1) { fprintf(stderr, "Error: %s\n", strerror(errno)); } free(first); free(firstparsed); free(tokens); return; } if (strcmp(firstparsed[0], "checkEnv") == 0) { pager = getenv("PAGER"); if (pager == NULL) { pathenv = getenv("PATH"); pathcp = malloc(strlen(pathenv)+1); strcpy(pathcp, pathenv); pathtokens = tokenize(pathcp, ':'); for (i = 0; i < tokens_length(pathtokens); i++) { if((tmp_str = malloc(strlen(pathtokens[i])+strlen("/less")+1)) != NULL){ tmp_str[0] = '\0'; strcat(tmp_str,pathtokens[i]); strcat(tmp_str,"/less"); if (access(tmp_str, X_OK) != -1) { pager = "less"; free(tmp_str); break; } free(tmp_str); } } if (pager == NULL) pager = "more"; free(pathcp); free(pathtokens); } if (DEBUG) { printf("Pager: %s\n", pager); } /* As our fork_and_run function takes an array of commands, we prepare an array with these commands in the checkenv array */ /* tmp_str will become "grep <arguments>" if any arguments are passed to checkEnv */ tmp_str = malloc(sizeof(char*) * (LIMIT + 1)); if (tokens_length(firstparsed) > 1) { checkenv = malloc(sizeof(char*) * (4 + 1)); tmp_str[0] = '\0'; strcat(tmp_str, "grep "); for (i = 1; firstparsed[i] != NULL; i++) { strcat(tmp_str, firstparsed[i]); strcat(tmp_str, " "); } checkenv[0] = "printenv"; checkenv[1] = tmp_str; checkenv[2] = "sort"; checkenv[3] = pager; checkenv[4] = NULL; } else { checkenv = malloc(sizeof(char*) * (3 + 1)); checkenv[0] = "printenv"; checkenv[1] = "sort"; checkenv[2] = pager; checkenv[3] = NULL; } fork_and_run(checkenv, bg); free(tmp_str); free(checkenv); free(first); free(firstparsed); free(tokens); return; } /* what was wrote wasn't "cd", "exit" or "checkEnv". We still execute the command. */ free(first); free(firstparsed); fork_and_run(tokens, bg); free(tokens); }