看了几遍都没整明白异常控制流核心原理,而对这个实验也是一知半解。不过,下面的shell实现代码应该还是不错的。贴出来看一看:/* * tsh - A tiny shell program with job control * * lycos 201020601005 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <ctype.h> #include <signal.h> #include <sys/types.h> #include <sys/wait.h> #include <errno.h> /* Misc manifest constants */ #define MAXLINE 1024 /* max line size */ #define MAXARGS 128 /* max args on a command line */ #define MAXJOBS 16 /* max jobs at any point in time */ #define MAXJID 1<<16 /* max job ID */ /* Job states */ #define UNDEF 0 /* undefined */ #define FG 1 /* running in foreground */ #define BG 2 /* running in background */ #define ST 3 /* stopped */ #define BUILTIN_COMMANDS 4 /* how many built-in commands there are */ /* * Jobs states: FG (foreground), BG (background), ST (stopped) * Job state transitions and enabling actions: * FG -> ST : ctrl-z * ST -> FG : fg command * ST -> BG : bg command * BG -> FG : fg command * At most 1 job can be in the FG state. */ /* Global variables */ extern char **environ; /* defined in libc */ char prompt[] = "tsh> "; /* command line prompt (DO NOT CHANGE) */ int verbose = 0; /* if true, print additional output */ int nextjid = 1; /* next job ID to allocate */ char sbuf[MAXLINE]; /* for composing sprintf messages */ struct job_t { /* The job struct */ pid_t pid; /* job PID */ int jid; /* job ID [1, 2, ...] */ int state; /* UNDEF, BG, FG, or ST */ char cmdline[MAXLINE]; /* command line */ }; struct job_t jobs[MAXJOBS]; /* The job list */ /* End global variables */ /* Function prototypes */ /* Here are the functions that you will implement */ void eval(char *cmdline); int builtin_cmd(char **argv); void do_bgfg(char **argv); void waitfg(pid_t pid); void sigchld_handler(int sig); void sigtstp_handler(int sig); void sigint_handler(int sig); /* Here are helper routines that we've provided for you */ int parseline(const char *cmdline, char **argv); void sigquit_handler(int sig); void clearjob(struct job_t *job); void initjobs(struct job_t *jobs); int maxjid(struct job_t *jobs); int addjob(struct job_t *jobs, pid_t pid, int state, char *cmdline); int deletejob(struct job_t *jobs, pid_t pid); pid_t fgpid(struct job_t *jobs); struct job_t *getjobpid(struct job_t *jobs, pid_t pid); struct job_t *getjobjid(struct job_t *jobs, int jid); int pid2jid(pid_t pid); void listjobs(struct job_t *jobs); sigset_t mask_signal(int how, int sig); int send_signal(pid_t pid, int sig); pid_t Fork(void); void usage(void); void unix_error(char *msg); void app_error(char *msg); typedef void handler_t(int); handler_t *Signal(int signum, handler_t *handler); /* * main - The shell's main routine */ int main(int argc, char **argv) { char c; char cmdline[MAXLINE]; int emit_prompt = 1; /* emit prompt (default) */ /* Redirect stderr to stdout (so that driver will get all output * on the pipe connected to stdout) * 重定向,1表示stdout,2表示是stderr 。第一个参数为重定向的目标。 */ dup2(1, 2); /* Parse the command line */ while ((c = getopt(argc, argv, "hvp")) != EOF) { switch (c) { case 'h': /* print help message */ usage(); break; case 'v': /* emit additional diagnostic info */ verbose = 1; break; case 'p': /* don't print a prompt */ emit_prompt = 0; /* handy for automatic testing */ break; default: usage(); } } /* Install the signal handlers */ /* These are the ones you will need to implement */ Signal(SIGINT, sigint_handler); /* ctrl-c */ Signal(SIGTSTP, sigtstp_handler); /* ctrl-z */ Signal(SIGCHLD, sigchld_handler); /* Terminated or stopped child */ /* This one provides a clean way to kill the shell */ Signal(SIGQUIT, sigquit_handler); /* Initialize the job list */ initjobs(jobs); /* Execute the shell's read/eval loop */ while (1) { /* Read command line */ if (emit_prompt) { printf("%s", prompt); fflush(stdout); } if ((fgets(cmdline, MAXLINE, stdin) == NULL) && ferror(stdin)) app_error("fgets error"); if (feof(stdin)) { /* End of file (ctrl-d) */ fflush(stdout); exit(0); } /* Evaluate the command line */ eval(cmdline); fflush(stdout); fflush(stdout); } exit(0); /* control never reaches here */ } /* * 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) { char *argv[MAXARGS]; /* argv for command */ int bg; /* should the job run in bg or fg? */ pid_t pid; /* process id */ bg = parseline(cmdline, argv); if(bg != -1 && !builtin_cmd(argv)) { /* block SIGCHLD signals to so it doesn't cry if child terminates before addjob gets called */ mask_signal(SIG_BLOCK, SIGCHLD); if((pid = Fork()) == 0) { /* child runs user job */ mask_signal(SIG_UNBLOCK, SIGCHLD); /* unblock SIGCHLD */ if(setpgid(0, 0) < 0) { /* put the child in a new process group */ unix_error("eval: setpgid failed"); } /* run the command */ if(execvp(argv[0], argv) < 0) { printf("%s: Command not found./n", argv[0]); exit(1); /* exit the child process */ } } else { /* parent */ /* add the job to the jobs list */ if(!bg) addjob(jobs, pid, FG, cmdline); else addjob(jobs, pid, BG, cmdline); mask_signal(SIG_UNBLOCK, SIGCHLD); /* unblock SIGCHLD */ /* handle the started job */ if (!bg) waitfg(pid); /* wait for fg job to terminate */ else { /* don't wait for bg jobs */ printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline); } } } } /* * parseline - Parse the command line and build the argv array. * * Characters enclosed in single quotes are treated as a single * argument. Return true if the user has requested a BG job, false if * the user has requested a FG job. Return -1 on a blank line. */ int parseline(const char *cmdline, char **argv) { static char array[MAXLINE]; /* holds local copy of command line */ char *buf = array; /* ptr that traverses command line */ char *delim; /* points to first space delimiter */ int argc; /* number of args */ int bg; /* background job? */ strcpy(buf, cmdline); buf[strlen(buf)-1] = ' '; /* replace trailing '/n' with space */ while (*buf && (*buf == ' ')) buf++; /* ignore leading spaces */ /* Build the argv list */ argc = 0; if (*buf == '/'') { buf++; delim = strchr(buf, '/''); } else { delim = strchr(buf, ' '); } while (delim) { argv[argc++] = buf; *delim = '/0'; buf = delim + 1; while (*buf && (*buf == ' ')) buf++; /* ignore spaces */ if (*buf == '/'') { buf++; delim = strchr(buf, '/''); } else { delim = strchr(buf, ' '); } } argv[argc] = NULL; if(argc == 0) return -1; /* ignore blank line */ /* should the job run in the background? */ if ((bg = (*argv[argc-1] == '&')) != 0) { argv[--argc] = NULL; } return bg; } /* * builtin_cmd - If the user has typed a built-in command then execute * it immediately. */ int builtin_cmd(char **argv) { char *command = argv[0]; /* see if this is a built in command */ if (!strcmp(argv[0], "quit")) { /* quit command */ exit(0); } else if (!strcmp("jobs", command)) { listjobs(jobs); return 1; } else if (!strcmp("bg", command) || !(strcmp("fg", command))) { do_bgfg(argv); return 1; } return 0; /* not a builtin command */ } /* * do_bgfg - Execute the builtin bg and fg commands */ void do_bgfg(char **argv) { /* get the pid (if given a jid) */ struct job_t *job; char *command = argv[0]; char *id = argv[1]; /* might be pid or jid */ int jid; /* handle non-existent id error */ if(id == NULL) { printf("%s command requires PID or %%jobid argument/n", command); return; } /* make sure jid is actually a jid (this assumes jid/pid can't be 0) */ if(id[0] == '%' && (atoi(id += sizeof(char)) != 0)) { /* if this looks like a jid (starts with %) and isn't doesn't look like an error */ jid = atoi(id); /* try and get the job, print msg on error */ if((job = getjobjid(jobs, jid)) == NULL) { printf("%%%s: No such job/n", id); return; } } else if(atoi(id) != 0 ) { /* assume this is a PID */ jid = pid2jid(atoi(id)); /* try and get the job, print msg on error */ if((job = getjobjid(jobs, jid)) == NULL) { printf("(%s): No such process/n", id); return; } } else { /* handle errors */ printf("%s: argument must be a PID or %%jobid/n", command); return; } /* continue the job */ send_signal(-(job->pid), SIGCONT); /* handle bg/fg */ if(!strcmp("bg", command)) { printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline); job->state = BG; } else if(!strcmp("fg", command)) { job->state = FG; waitfg(job->pid); /* wait for the fg job to finish */ } else printf("bg/fg error: %s/n", command); } /* * waitfg - Block until process pid is no longer the foreground process */ void waitfg(pid_t pid) { /* while pid is fg job */ while(pid == fgpid(jobs)) { /* sleeping for any amount of time caused strange effects when signals occured during the sleep time */ sleep(0); } } /***************** * Signal handlers *****************/ /* * sigchld_handler - The kernel sends a SIGCHLD to the shell whenever * a child job terminates (becomes a zombie), or stops because it * received a SIGSTOP or SIGTSTP signal. The handler reaps all * available zombie children, but doesn't wait for any other * currently running children to terminate. */ void sigchld_handler(int sig) { pid_t pid; int status, child_sig; /* reap any zombies and handle status reports -- the loop allows reaping of any processes that die during this function */ while((pid = waitpid(-1, &status, WUNTRACED|WNOHANG)) > 0) { if(WIFSTOPPED(status)) { /* handle stop signals (this assumes all stop signals are equivalent to SIGTSTP) */ sigtstp_handler(WSTOPSIG(status)); } else if(WIFSIGNALED(status)) { /* uncaught signal */ child_sig = WTERMSIG(status); if(child_sig == SIGINT) sigint_handler(child_sig); else unix_error("sigchld_handler: uncaught signal/n"); } else deletejob(jobs, pid); /* remove the job under normal conditions */ } if(pid == -1 && errno != ECHILD) unix_error("sigchld_handler: waitpid error"); } /* * sigint_handler - The kernel sends a SIGINT to the shell whenver the * user types ctrl-c at the keyboard. Catch it and send it along * to the foreground job. */ void sigint_handler(int sig) { pid_t pid = fgpid(jobs); /* get pid of the fg job */ int jid = pid2jid(pid); /* if there is a fg job, send it the signal */ if(pid != 0) { printf("Job [%d] (%d) terminated by signal %d/n", jid, pid, sig); deletejob(jobs, pid); /* remove the job */ send_signal(-pid, sig); /* forward the signal to the process group */ } } /* * sigtstp_handler - The kernel sends a SIGTSTP to the shell whenever * the user types ctrl-z at the keyboard. Catch it and suspend the * foreground job by sending it a SIGTSTP. */ void sigtstp_handler(int sig) { pid_t pid = fgpid(jobs); /* get pid of the fg job */ int jid = pid2jid(pid); /* if there is a fg job, send it the signal */ if(pid != 0) { printf("Job [%d] (%d) stopped by signal %d/n", jid, pid, sig); (*(getjobpid(jobs, pid))).state = ST; /* job's state is "stopped" */ send_signal(-pid, sig); /* forward the signal to the process group */ } } /********************* * End signal handlers *********************/ /*********************************************** * Helper routines that manipulate the job list **********************************************/ /* clearjob - Clear the entries in a job struct */ void clearjob(struct job_t *job) { job->pid = 0; job->jid = 0; job->state = UNDEF; job->cmdline[0] = '/0'; } /* initjobs - Initialize the job list */ void initjobs(struct job_t *jobs) { int i; for (i = 0; i < MAXJOBS; i++) clearjob(&jobs[i]); } /* maxjid - Returns largest allocated job ID */ int maxjid(struct job_t *jobs) { int i, max=0; for (i = 0; i < MAXJOBS; i++) if (jobs[i].jid > max) max = jobs[i].jid; return max; } /* addjob - Add a job to the job list */ int addjob(struct job_t *jobs, pid_t pid, int state, char *cmdline) { int i; if (pid < 1) return 0; for (i = 0; i < MAXJOBS; i++) { if (jobs[i].pid == 0) { jobs[i].pid = pid; jobs[i].state = state; jobs[i].jid = nextjid++; if (nextjid > MAXJOBS) nextjid = 1; strcpy(jobs[i].cmdline, cmdline); if(verbose) { printf("Added job [%d] %d %s/n", jobs[i].jid, jobs[i].pid, jobs[i].cmdline); } return 1; } } printf("Tried to create too many jobs/n"); return 0; } /* deletejob - Delete a job whose PID=pid from the job list */ int deletejob(struct job_t *jobs, pid_t pid) { int i; if (pid < 1) return 0; for (i = 0; i < MAXJOBS; i++) { if (jobs[i].pid == pid) { clearjob(&jobs[i]); nextjid = maxjid(jobs)+1; return 1; } } return 0; } /* fgpid - Return PID of current foreground job, 0 if no such job */ pid_t fgpid(struct job_t *jobs) { int i; for (i = 0; i < MAXJOBS; i++) if (jobs[i].state == FG) return jobs[i].pid; return 0; } /* getjobpid - Find a job (by PID) on the job list */ struct job_t *getjobpid(struct job_t *jobs, pid_t pid) { int i; if (pid < 1) return NULL; for (i = 0; i < MAXJOBS; i++) if (jobs[i].pid == pid) return &jobs[i]; return NULL; } /* getjobjid - Find a job (by JID) on the job list */ struct job_t *getjobjid(struct job_t *jobs, int jid) { int i; if (jid < 1) return NULL; for (i = 0; i < MAXJOBS; i++) if (jobs[i].jid == jid) return &jobs[i]; return NULL; } /* pid2jid - Map process ID to job ID */ int pid2jid(pid_t pid) { int i; if (pid < 1) return 0; for (i = 0; i < MAXJOBS; i++) if (jobs[i].pid == pid) return jobs[i].jid; return 0; } /* listjobs - Print the job list */ void listjobs(struct job_t *jobs) { int i; for (i = 0; i < MAXJOBS; i++) { if (jobs[i].pid != 0) { printf("[%d] (%d) ", jobs[i].jid, jobs[i].pid); switch (jobs[i].state) { case BG: printf("Running "); break; case FG: printf("Foreground "); break; case ST: printf("Stopped "); break; default: printf( "listjobs: Internal error: job[%d].state=%d ", i, jobs[i].state ); } printf("%s", jobs[i].cmdline); } } } /****************************** * end job list helper routines ******************************/ /*********************** * Other helper routines ***********************/ /* * mask the indicated signal according to "how" */ sigset_t mask_signal(int how, int sig) { sigset_t signals, result; if(sigemptyset(&signals) < 0) unix_error("mask_signal: sigemptyset failed"); if(sigaddset(&signals, sig) < 0) unix_error("mask_signal: sigaddset failed"); if(sigprocmask(how, &signals, &result) < 0) unix_error("mask_signal: sigprocmask failed"); return result; } /* * error-handling wrapper for kill() */ int send_signal(pid_t pid, int sig) { if(kill(pid, sig) < 0) { /* fail silently if pid doesn't exist -- this keeps handlers that are called too close together from complaining */ if(errno != ESRCH) unix_error("send_signal: kill failed"); } return 0; } /* * error-handling wrapper for fork() */ pid_t Fork(void) { pid_t pid; if((pid = fork()) < 0) unix_error("Fork error"); return pid; } /* * usage - print a help message */ void usage(void) { printf("Usage: shell [-hvp]/n"); printf(" -h print this message/n"); printf(" -v print additional diagnostic information/n"); printf(" -p do not emit a command prompt/n"); exit(1); } /* * unix_error - unix-style error routine */ void unix_error(char *msg) { fprintf(stdout, "%s: %s/n", msg, strerror(errno)); exit(1); } /* * app_error - application-style error routine */ void app_error(char *msg) { fprintf(stdout, "%s/n", msg); exit(1); } /* * Signal - wrapper for the sigaction function */ handler_t *Signal(int signum, handler_t *handler) { struct sigaction action, old_action; action.sa_handler = handler; sigemptyset(&action.sa_mask); /* block sigs of type being handled */ action.sa_flags = SA_RESTART; /* restart syscalls if possible */ if (sigaction(signum, &action, &old_action) < 0) unix_error("Signal error"); return (old_action.sa_handler); } /* * sigquit_handler - The driver program can gracefully terminate the * child shell by sending it a SIGQUIT signal. */ void sigquit_handler(int sig) { printf("Terminating after receipt of SIGQUIT signal/n"); exit(1); } 暂时,自己的shell就只能先这样了,以后接触更深的相关知识,再完善它。。。