/* * tsh - A tiny shell program with job control * Peter Chinetti peter@chinetti.me */ #include #include #include #include #include #include #include #include #include #include #include /* 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 */ /* * 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 setexecenv(char * cmdline,int io_flag,int fd); 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); int findspot(void); 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); 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) */ 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) { int cpid2; int fds[2]; sigset_t mask; sigemptyset(&mask); sigaddset(&mask, SIGCHLD); //check for flags int io_flag=0; char *tail = cmdline; if(strchr(cmdline,'<')){ io_flag=1; strsep(&tail,"<"); } if(strchr(cmdline,'>')){ io_flag=2; strsep(&tail,">"); } if(strchr(cmdline,'|')){ io_flag=3; strsep(&tail,"|"); pipe(fds); } char* argv[MAXARGS];//initialize int bg =parseline(cmdline,argv); if(argv[0] == NULL){ return; } if(!builtin_cmd(argv)){ sigprocmask(SIG_BLOCK,&mask,NULL);//making sure that I dont have a child terminate on me before I can insert it into the list. int cpid; if((cpid=fork())==0){ if(io_flag) setexecenv(tail,io_flag,fds[1]); execvp(argv[0],argv); printf("%s: Command not found\n",argv[0]);//only get here if exec fails exit(0); } if(io_flag==3){//duplication if there is a piped command. close(fds[1]); parseline(tail,argv); if((cpid2=fork())==0){ io_flag=4; setexecenv(tail,io_flag,fds[0]); execvp(argv[0],argv); printf("%s: Command not found\n",argv[0]);//only get here if exec fails exit(0); } close(fds[0]); } addjob(jobs,cpid,bg?BG:FG,cmdline);//add the forked job // printf("adding job"); sigprocmask(SIG_UNBLOCK,&mask,NULL); //safe to unblock now if(!bg){//then we are the foreground waitfg(cpid); waitfg(cpid2); return; } printf("[%d] (%d) %s",nextjid-1,cpid,cmdline); //print out background stuff } } char * onlyfirstword(char * in){ int curr = 0; while(*in==' ') ++in; while((in[curr]!='\0')&&(in[curr]!=' ')){ curr++; } in[curr-1]='\0'; return in; } /* setexecenv sets up the enviroment for the forked process, i.e. output redirection, pgid.. etc. */ void setexecenv(char * cmdline, int io_flag, int fd){ setpgrp(); if(io_flag==1){ int redirect = open(onlyfirstword(cmdline),O_RDONLY); dup2(redirect, 0); return; } if(io_flag==2){ int redirect = open(onlyfirstword(cmdline),O_CREAT|O_TRUNC|O_WRONLY, 0664); dup2(redirect, 1); return; } if(io_flag==3){ dup2(fd,1); close(fd); return; } if(io_flag==4){ dup2(fd,0); return; } } /* * 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. */ int parseline(const char *cmdline, char **argv) { //printf("----> %s", cmdline); 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; int bg; strcpy(buf, cmdline); buf[strlen(buf)-1] = ' '; /* replace trailing '\n' with space */ while (*buf && (*buf == ' ')) /* ignore leading spaces */ buf++; /* 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 == ' ')) /* ignore spaces */ buf++; if (*buf == '\'') { buf++; delim = strchr(buf, '\''); } else { delim = strchr(buf, ' '); } } argv[argc] = NULL; if (argc == 0) /* ignore blank line */ return 1; /* 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) { if(!strcmp(argv[0],"jobs")){ listjobs(jobs); return 1; } if(!strcmp(argv[0],"bg")){//this and the next could be combined, but disk space is cheap and readability is important do_bgfg(argv); return 1; } if(!strcmp(argv[0],"fg")){ do_bgfg(argv); return 1; } if(!strcmp(argv[0],"quit")) exit(0); return 0; /* not a builtin command */ } /* * do_bgfg - Execute the builtin bg and fg commands */ void do_bgfg(char **argv) { struct job_t *curr; if(argv[1]==NULL){ printf("%s command requires PID or %%jobid argument\n",argv[0]);//just some error checking return; } if(argv[1][0]=='%'){ int jid = strtol(argv[1]+1,NULL,10); if(!jid){ printf("%s command requires PID or %%jobid argument\n",argv[0]);//if strtol gets garbage it returns 0, which is also not a possible job! return; } curr = getjobjid(jobs,jid); if(curr==NULL){//couldn't find that job printf("%s: No such job\n",argv[1]); return; } } else{ int pid = strtol(argv[1],NULL,10); if(!pid){ printf("%s: argument must be a PID or %%jobid\n",argv[0]); return; } curr = getjobpid(jobs,pid); if(curr==NULL){ printf("(%s): No such process\n",argv[1]); return; } } kill(-(curr->pid),SIGCONT);//the meat of fg/bg if(!strcmp(argv[0],"fg")){ curr->state=FG; waitfg(curr->pid); if(curr->state==ST)//dont delete the stopped jobs! return; deletejob(jobs,curr->pid); } else{ curr->state=BG; printf("[%d] (%d) %s",curr->jid,curr->pid,curr->cmdline); } return; } /* * waitfg - Block until process pid is no longer the foreground process */ void waitfg(pid_t pid) { /* this has alot of code duplication from the sigchild handler I did this beacuse i wanted to use wait to give me interrupt driven code, rather than infinite loops of checking a variable */ int status; waitpid(pid,&status,WUNTRACED); struct job_t *curr = getjobpid(jobs,pid); if(WIFEXITED(status)){ // printf("removed job --> waitfg"); deletejob(jobs,pid); return; } if(WIFSTOPPED(status)){//this doesnt work if placed inside the WIFSIGNALED block... wtf? printf("Job [%d] (%d) stopped by signal 20\n",curr->jid,curr->pid); curr->state=ST; return; } if(WIFSIGNALED(status)){ if(WTERMSIG(status)==SIGINT){ printf("Job [%d] (%d) terminated by signal 2\n",getjobpid(jobs,pid)->jid,getjobpid(jobs,pid)->pid); } deletejob(jobs,pid); return; } } /***************** * 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; while((pid=waitpid(-1,&status,WNOHANG|WUNTRACED))>0){ struct job_t *curr = getjobpid(jobs,pid);//get the job we are messing around with. if(WIFEXITED(status)){//normal termination //printf("removed job --> handler"); deletejob(jobs,pid); continue; } if(WIFSTOPPED(status)==SIGTSTP){//thing was stopped printf("Job [%d] (%d) stopped by signal 20\n",curr->jid,curr->pid); curr->state=ST; continue; } else//thing was terminated printf("Job [%d] (%d) terminated by signal 2\n",getjobpid(jobs,pid)->jid,getjobpid(jobs,pid)->pid); deletejob(jobs,pid); } return; } /* * 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); if(!pid) return; kill(-pid,SIGINT);//forward on that SIGINT return; } /* * 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); if(!pid) return; struct job_t *curr = getjobpid(jobs,pid); curr->state=ST;//not really required kill(-pid,SIGTSTP); return; } /********************* * 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 ***********************/ /* * 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); }