/* eval - Evaluate a command line */ void eval(char *cmdline) { char *argv[MAXARGS]; /* Argument list execve() */ char buf[MAXLINE]; /* Holds modified command line */ int bg; /* Should the job run in bg or fg? */ pid_t pid; /* Process id */ strcpy(buf, cmdline); bg = parseline(buf, argv); if (argv[0] == NULL) return; /* Ignore empty lines */ if (!builtin_command(argv)) { if ((pid = Fork()) == 0) { /* Child runs user job */ if (execve(argv[0], argv, environ) < 0) { printf("%s: Command not found.\n", argv[0]); exit(0); } } /* Parent waits for foreground job to terminate */ if (!bg) { int status; if (waitpid(pid, &status, 0) < 0) unix_error("waitfg: waitpid error"); } else printf("%d %s", pid, cmdline); } return; }
void proc(void) { int status,i; char *command = NULL; char **parameters; char prompt[MAX_PROMPT]; parameters = malloc(sizeof(char *)*(MAXARG+2)); buffer = malloc(sizeof(char) * MAXLINE); if(parameters == NULL || buffer == NULL) { printf("Rshell error:malloc failed.\n"); return; } //arg[0] is command //arg[MAXARG+1] is NULL while(TRUE) { type_prompt(prompt); if(-1 == read_command(&command,parameters,prompt)) continue; if(builtin_command(command,parameters)) continue; if(fork()!=0) { waitpid(-1,&status,0); } else { execvp(command,parameters); } } }
void eval(char *cmdline) { char *argv[MAXARGS]; // argv pour exec char buf[MAXLINE]; // contient ligne commande modifiee char buf2[MAXLINE]; // pour les substitutions de jobid // par pid pour la commande kill strcpy(buf, cmdline); bool bg = parseline(buf, argv); if (!builtin_command(argv) && replace_kill_jobs(buf2, argv)) { int pid; if ((pid = Fork()) == 0) { exec_command(argv); // Ne retourne jamais } jobid_t jobid = jobs_add(pid, cmdline); if (jobid == INVALID_JOBID) { printf("Error while trying to register job with pid %d ", pid); printf("Maximum number of jobs (%d) reached ?)\n", MAXJOBS); } if (bg) { job_print_with_pid(jobid); } else { job_fg_wait(jobid, false); } } jobs_print_update(); exit_forget_next_forced(); }
/* eval - Evaluate a command line */ void eval(char *cmdline) { char *argv[MAXARGS]; /* Argument list execve() */ char buf[MAXLINE]; /* Holds modified command line */ int bg; /* Should the job run in bg or fg? */ pid_t pid; /* Process id */ signal(SIGCHLD, reaperthegrim); strcpy(buf, cmdline); bg = parseline(buf, argv); //bg = p3parseline(buf, argv); /* call new parseline function for cs485 project 3 */ if (argv[0] == NULL) return; /* Ignore empty lines */ if (!builtin_command(argv)) { if ((pid = fork()) == 0) { /* Child runs user job */ if (execve(argv[0], argv, environ) < 0) { printf("%s: Command not found.\n", argv[0]); exit(0); } } /* Parent waits for foreground job to terminate */ if (!bg) { int status; if (waitpid(pid, &status, 0) < 0) unix_error("waitfg: waitpid error"); } else{ printf("%d %s", pid, cmdline); int i =0; int ctr = 1; while(ctr==1) { //puts the pid into the PIDS array so we can keep track of all pids if(PIDS[i]==0) { PIDS[i]=pid; ctr=0; } else { i++; } } } } in = 0; out = 0; inpos = 0; outpos = 0; return; }
/* * Executes command while processing call tree * parameters: char** args - command arguments * returns: exit status of command executed */ static int execCommand(char** args) { int rv = 0;//return exit status int execute(char**);//execute() function declaration int builtin_command(char**,int*);//built in handler function declaration if ( !builtin_command(args,&rv) )//handles built in command rv = execute(args);//regular command return rv;//returns exit status of command executed }
/* * eval - Evaluate the command line that the user has just typed in * * If the user has requested a built-in command (quit, jobs, bg or fg) * then execute it immediately. Otherwise, fork a child process and * run the job in the context of the child. If the job is running in * the foreground, wait for it to terminate and then return. Note: * each child process must have a unique process group ID so that our * background children don't receive SIGINT (SIGTSTP) from the kernel * when we type ctrl-c (ctrl-z) at the keyboard. */ void eval(char *cmdline) { int bg; /* should the job run in bg or fg? */ struct cmdline_tokens tok; sigset_t prev, mask_all; int state; pid_t pid; struct job_t *job_ins; /* Parse command line */ bg = parseline(cmdline, &tok); if (bg == -1) /* parsing error */ return; if (tok.argv[0] == NULL) /* ignore empty lines */ return; /* Fig. 8.40 */ if (!builtin_command(&tok)) { Sigemptyset(&mask_all); Sigaddset(&mask_all, SIGCHLD); Sigaddset(&mask_all, SIGINT); Sigaddset(&mask_all, SIGTSTP); Sigprocmask(SIG_BLOCK, &mask_all, &prev); /* Block at beginning */ if ((pid = Fork()) == 0) { /* Child process */ Sigprocmask(SIG_SETMASK, &prev, NULL); /* Unblock inside child */ Setpgid(0, 0); /* one proc and shell in pgrp */ open_dup2_in(tok.infile); open_dup2_out(tok.outfile); if (execve(tok.argv[0], tok.argv, environ) < 0) { printf("%s: Command not found.\n", tok.argv[0]); exit(0); } } /* Parent process */ state = bg ? BG : FG; addjob(job_list, pid, state, cmdline); job_ins = getjobpid(job_list, pid); Sigprocmask(SIG_SETMASK, &prev, NULL); /* Unblock 3 signals */ if (bg) { printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline); } else { wait_fg_job(job_ins -> state); } } return; }
void eval(char *cmdline) { char *argv[MAXARGS]; // argv pour execve() char buf[MAXLINE]; // contient ligne commande modifiee int bg; // arriere-plan ou premier plan ? pid_t pid; // process id int indexJobLibre; strcpy(buf, cmdline); bg = parseline(buf, argv); if (argv[0] == NULL) return; // ignorer lignes vides if (!builtin_command(argv)) { // commande integree ? // si oui, executee directement if ((pid = Fork()) == 0) { // si non, executee par un fils setpgid(0, 0); if (execvp(argv[0], argv) < 0) { printf("%s: Command not found.\n", argv[0]); exit(0); } } indexJobLibre = getIndexLibre(); tabJobs[indexJobLibre] = malloc(sizeof (job)); tabJobs[indexJobLibre]->pid = pid; strcpy(tabJobs[indexJobLibre]->commande, argv[0]); if (!bg) { // le pere attend fin du travail de premier plan tabJobs[indexJobLibre]->etat = FG; printf("dans !bg: commande = %s\n", tabJobs[indexJobLibre]->commande); printf("getIndexFG() = %d --\n", getIndexFG()); } else { // travail d'arriere-plan, on imprime le pid tabJobs[indexJobLibre]->etat = BG; printf("%d %s", pid, cmdline); } } while (getIndexFG() != -1) { printf("verif FG = %d\n", getIndexFG()); afficheJobs(); sleep(1); } return; }
int do_control_command(char** args) { int rv; if (strcmp(args[0], "if") == 0) { if (if_state != NEUTRAL) err_ret("if error", ""); last_result = process(args + 1); if_result = ((last_result == 0) ? SUCCESS : FAIL); if_state = WANT_THEN; rv = 0; printf("in do_control_command if, last_result = %d, if_result = %d, if_state = %d, arg + 1 = %s\n", last_result, if_result, if_state, *(args + 1)); } else if (strcmp(args[0], "then") == 0) { if (if_state != WANT_THEN) err_ret("then error", ""); if_state = THEN_BLOCK; rv = 0; } else if (strcmp(args[0], "else") == 0) { if (if_state != THEN_BLOCK) err_ret("else error", ""); if_state = ELSE_BLOCK; rv = 0; } else if (strcmp(args[0], "fi") == 0) { if ((if_state != THEN_BLOCK) && (if_state != ELSE_BLOCK)) err_ret("fi error", ""); exec_cmd_ptr = exec_cmds; while(exec_number != 0) { if (!builtin_command(*exec_cmd_ptr)) execute(*exec_cmd_ptr); freelist(*exec_cmd_ptr); ++exec_cmd_ptr; --exec_number; } if_state = NEUTRAL; } return rv; }
/** * @brief : process user commands * @param : args array of strings * exit_code pointer to exit code passed to builtins * @return rv result of command execution */ int process(char **args,int *exit_code, bool *syn_err) { int rv = 1; /* defaults to 1 for failed exit */ if ( args[0] == NULL ) rv = 0; else if ( is_control_command(args[0]) ) rv = do_control_command(args, syn_err); else if ( ok_to_execute(syn_err) ) if ( !builtin_command(args,&rv,exit_code)) rv = execute(args); return rv; }
int process(char** args) { int rv; if (args[0] == NULL) return 0; else if (is_control_command(args[0])) rv = do_control_command(args); else if ((rv = ok_to_execute(args)) == 1) if (!builtin_command(args)) rv = execute(args); return rv; }
//Evaluates the command line void eval(char *cmdline){ char *argv[MAXARGS]; //list of arguments char buf[MAXLINE]; //holds modified command line int bg; //bg == 1 if job should be run in the background, otherwise foreground pid_t pid; //Process id strcpy(buf,cmdline); add_command_to_history(buf); //Records command in history bg = parseline(buf, argv); if(argv[0]== NULL) return; //Ignore empty lines if(!builtin_command(argv)){ execute_cmd(argv, bg); } return; }
/* * eval - evaluate a command line */ void eval(char *cmdline) { char *argv[MAXARGS]; /* argv for execve() */ int bg; /* should the job run in bg or fg? */ pid_t pid; /* process id */ /* parse command line */ bg = parseline(cmdline, argv); if (argv[0] == NULL) return; /* ignore empty lines */ if (!strcmp(argv[0], "quit")) exit(0); /* terminate shell */ if (!builtin_command(argv)) { if ((pid = Fork()) == 0) { /* child */ /* Background jobs should ignore SIGINT (ctrl-c) */ /* and SIGTSTP (ctrl-z) */ if (bg) { Signal(SIGINT, SIG_IGN); Signal(SIGTSTP, SIG_IGN); } if (execve(argv[0], argv, environ) < 0) { printf("%s: Command not found.\n", argv[0]); fflush(stdout); exit(0); } } /* parent waits for foreground job to terminate or stop */ addjob(jobs, pid, (bg == 1 ? BG : FG), cmdline); if (!bg) waitfg(pid); else printf("%d %s", pid, cmdline); } return; }
/* Eval -- Evalute a command line */ void eval(char *cmdline){ char *argv[MAXARGS]; // Argument list execve() char *environ; // 环境变量列表environ暂设为空 char buf[MAXARGS]; // Holds modified command line int bg; // Should the job run in bg or fg? pid_t pid; strcpy(buf, cmdline); bg = parseline(buf, argv); // 解析以空格为delimiter的命令, buf ---> argv // bg = 1 ;后台执行 // bg = 0 ; 前台执行(shell挂起) if(argv[0] == NULL){ return; // Ignore empty lines } if(!builtin_command(argv)){ // 不是内置命令 if((pid = fork()) == 0){ // Child runs user job if(execve(argv[0], argv, environ) < 0){ printf("%s: Command not found.\n", argv[0]); exit(0); } } /* parent waits for foreground job to terminate */ if(!bg){ // bg = 0 ; 前台执行(shell挂起) int status; if(waitpid(pid, &status, 0) < 0){ unix_error("waitfg: waitpid error"); } }else{ // 后台执行,即父进程无需挂起,用SIGCHLD处理程序回收子进程 if(signal(SIGCHLD, handler) == SIG_ERR){ // 设置SIGCHLD处理程序 unix_error("signal error"); } printf("%d %s", pid, cmdline); } } return; }
void eval(char *cmdLine) { char *argv[MAXARGS], *argv2[MAXARGS], *pch; int bg, argc, fd[2]; int status; pid_t pid, pid2; char _cmdLine[MAXLINE]; char *cmd1; char *cmd2; strcpy(_cmdLine, cmdLine); if(strchr(_cmdLine, '|') != NULL) { cmd1 = strtok(_cmdLine, "|"); cmd2 = strtok(NULL, "|"); strcat(cmd1, "\0"); strcat(cmd2, "\0"); argc = 0; argv[argc] = strtok(cmd1, " \n"); while(argv[argc] != NULL) { argc++; argv[argc] = strtok(NULL, " \n"); } argc = 0; argv2[argc] = strtok(cmd2, " \n"); while(argv2[argc] != NULL) { argc++; argv2[argc] = strtok(NULL, " \n"); } // fd[0] : read, fd[1] write if(pipe(fd) == -1) { printf("fail to call pipe()\n"); exit(1); } if((pid = fork()) == 0) { close(1); dup(fd[1]); if(close(fd[0]) == -1 || close(fd[1]) == -1) { perror("close"); } if(execvp(argv[0], argv) < 0) { printf("%s : Command not found.\n", argv[0]); exit(0); } } if((pid2 = fork()) == 0) { close(0); dup(fd[0]); if(close(fd[0]) == -1 || close(fd[1]) == -1) perror("close"); if(execvp(argv2[0], argv2) < 0) { printf("%s : Command not found.\n", argv2[0]); exit(0); } } if(waitpid(pid, &status, 0) < 0) { fprintf(stderr, "waitfg : waidpid error"); } } else { bg = parseLine(_cmdLine, argv); if(argv[0]==NULL) return; if(!builtin_command(argv)) { if((pid = fork()) == 0) { if(execvp(argv[0], argv) < 0) { printf("%s : Command not found.\n", argv[0]); exit(0); } if(bg) printf("[%d] %s\n", pid, cmdLine); fflush(stdout); } if(!bg) { if(waitpid(pid, &status, 0) < 0) { fprintf(stderr, "waitfg : waidpid error"); } } else { printf("%d %s", pid, cmdLine); } } } }
/* * eval - Evaluate the command line that the user has just typed in * * If the user has requested a built-in command (quit, jobs, bg or fg) * then execute it immediately. Otherwise, fork a child process and * run the job in the context of the child. If the job is running in * the foreground, wait for it to terminate and then return. Note: * each child process must have a unique process group ID so that our * background children don't receive SIGINT (SIGTSTP) from the kernel * when we type ctrl-c (ctrl-z) at the keyboard. */ void eval(char *cmdline) { int bg; /* should the job run in bg or fg? */ struct cmdline_tokens tok; /* Parse command line */ bg = parseline(cmdline, &tok); if (bg == -1) return; /* parsing error */ if (tok.argv[0] == NULL) return; /* ignore empty lines */ /* Built-in Command */ if (tok.builtins!=BUILTIN_NONE){ builtin_command(&tok); return; } /* Common tasks for both foreground and background */ pid_t pid; sigset_t mask; Sigemptyset(&mask); Sigaddset(&mask, SIGCHLD); Sigaddset(&mask, SIGINT); Sigaddset(&mask, SIGTSTP); /* Block signal receving in parent */ Sigprocmask(SIG_BLOCK, &mask, NULL); if ((pid=Fork())==0){ /* Unblock signal receiving in child */ Sigprocmask(SIG_UNBLOCK, &mask, NULL); /* Changes the child's process group from the shell's */ Setpgid(0,0); /* Change the input and output file descriptors */ IOredirection(&tok); Execve(tok.argv[0], tok.argv, environ); /* Command not found */ printf("Executable file not found\n"); exit(0); } /* Foreground job*/ if (!bg){ if (!addjob(job_list, pid, FG, cmdline)) return; Sigprocmask(SIG_UNBLOCK, &mask, NULL); wait_for_fg(pid); return; } /* Background job */ if (bg){ if (!addjob(job_list, pid, BG, cmdline)) return; Sigprocmask(SIG_UNBLOCK, &mask, NULL); printf("[%d] (%d) %s\n", pid2jid(pid), pid, cmdline); } return; }