/*
* 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];
/* int ground = parseline(cmdline, (char **)&argv); */
char buf[MAXLINE]; // Holds modified command line
strcpy(buf, cmdline);
int ground = parseline(buf, argv);
if (argv[0] == NULL) return;
if (!builtin_cmd((char **)&argv)) {
sigset_t mask;
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL);
pid_t pid = __fork();
if (pid != 0) {
addjob(jobs, pid, ground ? BG : FG, cmdline);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
if (!ground) waitfg(pid);
else printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
} else {
__setpgid(0, 0);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
if (execve(argv[0], argv, environ) < 0) {
printf("%s: Command not found\n", argv[0]);
exit(0);
}
}
}
return;
}
/* do_fg - Execute the builtin fg command */
void
do_fg(char **argv)
{
struct job_t * job;
pid_t pid;
if (verbose)
printf("do_fg: entering\n");
job = treat_argv(argv);
job->jb_state = FG;
pid = jobs_fgpid();
assert(kill(-pid, SIGCONT) != -1);
if (verbose)
printf("do_fg: sigcont %d \n", pid);
waitfg(pid);
if (verbose)
printf("do_fg: exiting\n");
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
int jobid = -1;
pid_t pid = -1;
struct job_t *nowjob;
//error messages
if(argv[1] == NULL)
{
if(!strcmp(argv[0],"fg"))
puts("fg command requires PID or %jobid argument");
else if(!strcmp(argv[0],"bg"))
puts("bg command requires PID or %jobid argument");
return;
}
if((argv[1][0] != '%') && (!(('0'<=argv[1][0]) && (argv[1][0]<='9'))))
{
if(!strcmp(argv[0],"fg"))
puts("fg: argument must be a PID or %jobid");
else if(!strcmp(argv[0],"bg"))
puts("bg: argument must be a PID or %jobid");
return;
}
//decide whether jid or pid
if(argv[1][0] == '%')
{
jobid = atoi(&argv[1][1]);
nowjob = getjobjid(jobs,jobid);
}
else
{
pid = (pid_t)atoi(argv[1]);
nowjob = getjobpid(jobs,pid);
}
if(nowjob == NULL)
{
if(argv[1][0] == '%')
printf("%%%d: No such job\n",jobid);
else
printf("(%d): No such process\n",(int)pid);
return;
}
//////////////
if(!strcmp(argv[0],"bg"))
{
nowjob->state = BG;
printf("[%d] (%d) %s",nowjob->jid,nowjob->pid,nowjob->cmdline);
if(kill(-(nowjob->pid), SIGCONT)<0) unix_error("kill error");
}
else if(!strcmp(argv[0],"fg"))
{
nowjob->state = FG;
// printf("[%d] (%d) %s\n",nowjob->jid,nowjob->pid,nowjob->cmdline);
if(kill(-(nowjob->pid), SIGCONT)<0) unix_error("kill error");
waitfg(nowjob->pid);
}
return;
}
/*
* 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];
int isBG = parseline(cmdline, argv);
if (argv[0] == NULL) return;
if (builtin_cmd(argv)) return;
sigset_t allset;
sigfillset(&allset);
sigprocmask(SIG_BLOCK, &allset, NULL);
pid_t childpid = fork();
if (childpid == -1) unix_error("fork failed");
if (childpid == 0) {
sigprocmask(SIG_UNBLOCK, &allset, NULL);
if (setpgid(0, 0) == -1) unix_error("setpgrp failed");
if (execv(argv[0], argv) == -1) unix_error("execv failed");
}
if (isBG) {
addjob(jobs, childpid, BG, cmdline);
printjob(jobs, childpid);
sigprocmask(SIG_UNBLOCK, &allset, NULL);
} else {
addjob(jobs, childpid, FG, cmdline);
sigprocmask(SIG_UNBLOCK, &allset, NULL);
waitfg(childpid);
}
return;
}
/*
* * 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 h
* * ave 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];
int bg = parseline(cmdline, argv);
pid_t pid;
struct job_t *jb;
sigset_t mask;
if (argv[0] == NULL) return; //Ignoring the empty lines
if (!builtin_cmd(argv)) {
sigprocmask(SIG_BLOCK,&mask, NULL);
if((pid = fork()) == 0) {
sigprocmask(SIG_UNBLOCK,&mask,NULL);
setpgid(0,0);
if(execv(argv[0],argv)<0){
printf("%s : Command not found!! \n" , argv[0]);
exit(0);
}
}
if(!bg) {
addjob(jobs,pid,FG,cmdline);
sigprocmask(SIG_UNBLOCK,&mask,NULL);
waitfg(pid);
}
else{
addjob(jobs,pid,BG,cmdline);
sigprocmask(SIG_UNBLOCK,&mask,NULL);
jb = getjobpid(jobs,pid);
printf("[%d] (%d) %s", jb->jid, jb->pid,jb->cmdline);
}
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
struct job_t * job;
job = NULL;
if (argv[1] == NULL) {
// Missing arguments
printf("%s command requires PID or %%jobid argument\n", argv[0]);
fflush(stdout);
return;
}
if (isdigit(*argv[1])) {
// Check if the second argument is a digit
job = getjobpid(jobs, atoi(argv[1]));
if (!job) {
printf("(%s): No such process\n", argv[1]);
fflush(stdout);
return;
}
} else if (strlen(argv[1]) > 1 && argv[1][0] == '%') {
// Check if the second argument is %number (e.g. %5)
if (isdigit(argv[1][1])) {
// Make sure that the second character is a digit
job = getjobjid(jobs, atoi(argv[1]+1));
if (!job) {
printf("%s: No such job\n", argv[1]);
fflush(stdout);
return;
}
}
}
if (job == NULL) {
// If the job is null, report invalid argument and stop
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
fflush(stdout);
return;
}
if (!strcmp(argv[0], "fg")) {
if (Kill(-job->pid, SIGCONT) == 0) {
job->state = FG;
// since sigcont will just run the program in the background,
// we need to explicitly tell the shell
// to wait for it to complete
waitfg(job->pid);
}
} else if (!strcmp(argv[0], "bg")) {
// Restart job but do not wait for the job (job is in background)
printf("[%i] (%i) %s", job->jid, job->pid, job->cmdline);
fflush(stdout);
if (Kill(-job->pid, SIGCONT) == 0) {
job->state = BG;
}
}
fflush(stdout);
return;
}
/*
* 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 execve() */
int bg;
pid_t pid;
bg = parseline(cmdline, argv);
if(argv[0] == NULL) return; /* ignore empty lines */
if(!builtin_cmd(argv))
{
if((pid = fork()) < 0) unix_error("eval(): fork() error");
if(pid == 0) /* child runs user job */
{
if(setpgid(0,0) < 0) unix_error("eval(): setpgid() error");
if(execve(argv[0], argv, environ) < 0)
{
printf("%s: Command not found.\n", argv[0]);
exit(0);
}
}
addjob(jobs,pid,(bg == 1 ? BG : FG),cmdline);
sigprocmask(SIG_UNBLOCK,&mask,NULL);
if(!bg) waitfg(pid);
else printf("[%d] (%d) %s",pid2jid(pid),pid,cmdline);
}
return;
}
/*
* 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];
int bg=parseline(cmdline,argv);
int p=builtin_cmd(&argv[0]);
int childpid;
bg++; //because the background process is defined as 2 and foreground as 1
sigset_t set;
sigemptyset(&set);
sigaddset(&set,SIGCHLD);
sigaddset(&set,SIGINT);
sigaddset(&set,SIGTSTP);
if(!p)
{
if((childpid=fork())==0)
{
setpgid(0,0); //Changing group id
execve(argv[0], argv, NULL);
printf("Command not found\n");//If incase there is no command
exit(0);
}
else
{
sigprocmask(SIG_BLOCK,&set,NULL); //masking if incase child executes first
addjob(jobs,childpid,bg,cmdline);
sigprocmask(SIG_UNBLOCK,&set,NULL);//remove mask
if(bg==1)
waitfg(childpid);
else
printf("[%d] (%d) %s",pid2jid(childpid),childpid,cmdline);
}
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
struct job_t *job = NULL;
if (argv[1] == NULL) {
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
if (argv[1][0] == '%') job = getjobjid(jobs, atoi(argv[1] + 1));
else job = getjobpid(jobs, atoi(argv[1]));
if (job == NULL) {
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return ;
}
if (job->state == ST) {
if (kill(-job->pid, SIGCONT) == -1) unix_error("kill failed");
}
if (strcmp(argv[0], "fg") == 0) {
if (job->state != FG) {
job->state = FG;
}
waitfg(job->pid);
}
return;
}
/*
* 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)
{
// Kyung and Jung drove here
/* Outline taken from Bryant & O'Hall page 735 */
/* variables*/
char *argv[MAXARGS];
char buf[MAXLINE];
int bg;
pid_t pid;
struct job_t *addedjob;
sigset_t mask; /* for signals */
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
strcpy(buf,cmdline); /* parse command line */
bg = parseline(buf,argv);
/**************************
* evaluates command line
**************************/
if(argv[0] == NULL)
return;
if(!builtin_cmd(argv))
{ /* built-in command */
sigprocmask(SIG_BLOCK, &mask, NULL);
pid = fork();
if(pid < 0) { /* fork error handling */
unix_error("Fork error");
}
else if(pid==0) { /* child */
setpgid(0, 0);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
if(execve(argv[0], argv,environ) < 0) {
printf("%s: Command not found\n", argv[0]);
exit(1);
}
}
else { /* parent - not a build-in command */
if(bg) { /* run in background */
sigprocmask(SIG_UNBLOCK, &mask, NULL);
addjob(jobs, pid, BG, cmdline);
addedjob = getjobpid(jobs,pid);
printf("[%d] (%d) %s", addedjob->jid, addedjob->pid, addedjob->cmdline);
}
else { /* run in foreground */
sigprocmask(SIG_UNBLOCK, &mask, NULL);
addjob(jobs, pid, FG, cmdline);
waitfg(pid);
}
}
}
return;
/* done with code excerpt/outline */
// end of Kyung and Jung driving
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
if (argv[1] == NULL) {
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
if (!isdigit(argv[1][0]) && argv[1][0] != '%') {
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
if (argv[1][0] == '%' ? 1 : 0) {
if (getjobjid(jobs, atoi(&argv[1][1])) == NULL) {
printf("%s: No such job\n", argv[1]);
return;
}
} else {
if (getjobjid(jobs, atoi(&argv[1][1])) == NULL) {
printf("(%d): No such process\n", atoi(argv[1]));
return;
}
}
// This is my favourite code
__kill(-getjobjid(jobs, atoi(&argv[1][1]))->pid, SIGCONT);
getjobjid(jobs, atoi(&argv[1][1]))->state = strcmp(argv[0], "fg")==0?FG:BG;
if (strcmp(argv[0], "fg")==0) waitfg(getjobjid(jobs, atoi(&argv[1][1]))->pid); else printf("[%d] (%d) %s", getjobjid(jobs, atoi(&argv[1][1]))->jid, getjobjid(jobs, atoi(&argv[1][1]))->pid, getjobjid(jobs, atoi(&argv[1][1]))->cmdline);
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
struct job_t *j=NULL;
/* Did the user provide bg or fg with an arguement? */
if(argv[1] == NULL)
{
printf("%s command requires PID or %%jobid argument\n",argv[0]);
return;
}
/* Is the argument a PID? */
if(isdigit(argv[1][0]))
{
pid_t pid = atoi(argv[1]);
if(!(j = getjobpid(jobs,pid)))
{
printf("(%d): No such process\n", pid);
return;
}
}
else if(argv[1][0] == '%') /* Is the argument a JID? */
{
int jid = atoi(&argv[1][1]); /* argv[1][1] points past the '%' */
if(!(j = getjobjid(jobs,jid)))
{
printf("%s: No such job\n",argv[1]);
return;
}
}
else
{
printf("%s: argument must be a PID or %%jobid\n",argv[0]);
return;
}
if(!strcmp(argv[0],"bg"))
{
if(kill(-(j->pid),SIGCONT) < 0) unix_error("do_bgfg(): kill error");
j->state =BG;
printf("[%d] (%d) %s",j->jid,j->pid,j->cmdline);
}
else if(!strcmp(argv[0],"fg"))
{
if(kill(-(j->pid),SIGCONT) < 0) unix_error("do_bgfg(): kill error");
j->state = FG;
waitfg(j->pid);
}
else
{
printf("do_bgfg(): internal error\n");
exit(0);
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
if(!argv) return;
int argc=0;
int temp = 0;
struct job_t* job = NULL;
for(; argv[argc] != 0; argc++);
if(argc != 2)
{
printf("fg command requires PID or %%jobid argument\n");
return;
}
char* pid_or_jid = argv[1];
if(pid_or_jid[0] != '%' && (pid_or_jid[0] > '9' || pid_or_jid[0] < '0'))
{
printf("fg: argument must be a PID or %%jobid\n");
return;
}
if(pid_or_jid[0] == '%')
{
temp = atoi(pid_or_jid+1);
job = getjobjid(jobs,temp);
if(!job)
{
printf("%s: No such job\n", pid_or_jid);
return;
}
}
else
{
temp = atoi(pid_or_jid);
job = getjobpid(jobs,temp);
if(!job)
{
printf("(%d): No such process\n", temp);
return;
}
}
//foreground job
if(!strcmp("fg", argv[0]))
{
kill(-job->pid,SIGCONT);
job->state = FG;
waitfg(job->pid);
}
//background job
else if(!strcmp("bg", argv[0]))
{
printf("[%d] (%d) %s", job->jid, job->pid,job->cmdline);
kill(-job->pid, SIGCONT);
job->state = BG;
}
return;
}
/*
* 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.
*
* Requires:
* "cmdline" is a NUL ('\0') terminated string with a trailing
* '\n' character. "cmdline" must contain less than MAXARGS
* arguments.
*
* Effects:
* A built-in command is executed immediately. Otherwise, it attempts
* to fork a child process and execute the job. If necessary, the
* executable program is searched through the directories of the
* search path. If not found, an error is thrown. If the job is
* running as a foreground job, it waits until completion.
*/
static void
eval(const char *cmdline)
{
char *argv[MAXARGS];
int bg = parseline(cmdline, argv);
pid_t pid;
sigset_t mask;
// Checks command line is not empty.
if (!argv[0]) {
return;
}
// Checks that the command is not a built-in command.
if(!builtin_cmd(argv)){
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL);
// A child is forked.
pid = fork();
if (pid == 0) {
// Put child in new group whose ID is identical to child’s PID.
setpgid(0, 0);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
if (execve(argv[0], argv, environ) == -1) {
int index = 0;
// Run through directories in search path to execute program.
while (argv[0][0] != '.' && index < directoryCount) {
if (execve(strcat(directories[index],argv[0]), argv, environ) != -1) {
break;
}
index++;
}
// Command not found.
char *print;
asprintf(&print, "%s: Command not found\n", argv[0]);
sio_error(print);
}
}
if (bg == 0) {
addjob(jobs,pid,FG,cmdline);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
// Wait for foreground jobs to complete.
waitfg(pid);
}
else {
addjob(jobs,pid,BG,cmdline);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
}
}
return;
}
/*
* 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];
char buf[MAXLINE];
int bg;
sigset_t mask;
pid_t pid;
strcpy(buf, cmdline);
bg = parseline(buf, argv);
if(argv[0] == NULL)
return;
if(!builtin_cmd(argv)){
//block signal
if(sigemptyset(&mask) < 0)
unix_error("sigemptyset error");
if(sigaddset(&mask, SIGCHLD) < 0)
unix_error("sigaddset error");
if(sigprocmask(SIG_BLOCK, &mask, NULL) < 0)
unix_error("sigprocmask error");
if((pid = fork()) == 0){
//set pid group to be the same as the current pid
if(setpgid(0,0) < 0)
unix_error("eval: set pid group error");
//unblock siganl
if(sigprocmask(SIG_UNBLOCK, &mask, NULL) < 0)
unix_error("sigprocmask error");
//execute program
if(execve(argv[0], argv, environ)<0){
printf("%s: Command not found.\n", argv[0]);
exit(1);
}
}
if(!bg){
addjob(jobs, pid, FG, cmdline);
//unblock siganl
if(sigprocmask(SIG_UNBLOCK, &mask, NULL) < 0)
unix_error("sigprocmask error");
waitfg(pid);
}else{
addjob(jobs, pid, BG, cmdline);
//unblock siganl
if(sigprocmask(SIG_UNBLOCK, &mask, NULL) < 0)
unix_error("sigprocmask error");
printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
}
}
return;
}
/*
* 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* argvTask[MAXARGS]; // holds arguments for other calls
pid_t npid; // new pid temp var
sigset_t mask;
parseline(cmdline, argvTask);
if(builtin_cmd(argvTask)){} // check for a built in and runs immediately
else // reaches for non-built in
{
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL); // enable mask for parent
if(parseline(cmdline, argvTask)) //checking if BG
{
if(( npid = fork()) == 0) // child run in bg
{
sigprocmask(SIG_UNBLOCK, &mask, NULL); // unblock mask for child
setpgid(0,0);
if(execve(argvTask[0], argvTask, environ) < 0)
{
//unix_error( argvTask[0]);
printf("%s: Command not found \n",argvTask[0]);
exit(0);
}
}
else // parent
{
addjob(jobs, npid,BG, cmdline); // add bg job to list and parent does not wait
printf( "[%d] (%d) %s", maxjid(jobs) , npid , cmdline);
sigprocmask(SIG_UNBLOCK, &mask, NULL); // unblock the parent
}
}
else // runs if FG
{
if(( npid = fork()) == 0) // child run in fg
{
sigprocmask(SIG_UNBLOCK, &mask, NULL); // unblock child
setpgid(0,0);
if(execve(argvTask[0], argvTask, environ) < 0) // use exec call and check for error
{
printf("%s: Command not found \n",argvTask[0]);
exit(0);
}
}
else // parent
{
addjob(jobs, npid,FG,cmdline); // adding the fg job to jobs list
sigprocmask(SIG_UNBLOCK, &mask, NULL); // unblock the parent
waitfg(npid); //waiting for fg process to finish
}
}
}
return;
}
/*
* 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];
int bg = parseline(cmdline, argv);
int rbic = builtin_cmd(argv);
if (!rbic)
{
pid_t child = fork();
//printf("forked\n");
if (child)
{
//PARENT
if (bg)
{
int ret = addjob(jobs, child, BG, cmdline); //returns an int
if (ret)
{
int jid = pid2jid(child);
printf("[%d] (%d) %s", jobs[jid-1].jid, jobs[jid-1].pid, jobs[jid-1].cmdline);
}
else
{
printf("addjobfailed\n");
}
}
else
{
int ret = addjob(jobs, child, FG, cmdline); //returns an int
if (!ret)
{
printf("addjobfailed\n");
}
waitfg(child);
}
}
else if( child < 0 )
{
//ERROR
exit(1);
}
else
{
//CHILDS
setpgid( 0, 0 );
int rc = execv( argv[0], argv );
if (rc == -1)
{
printf( "execv error %d\n", errno);
exit(1);
}
}
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
struct job_t *job;
char *tmp;
int jid;
pid_t pid;
tmp = argv[1];
// if id does not exist
if(tmp == NULL) {
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
// if it is a jid
if(tmp[0] == '%') {
jid = atoi(&tmp[1]);
//get job
job = getjobjid(jobs, jid);
if(job == NULL){
printf("%s: No such job\n", tmp);
return;
}else{
//get the pid if a valid job for later to kill
pid = job->pid;
}
}
// if it is a pid
else if(isdigit(tmp[0])) {
//get pid
pid = atoi(tmp);
//get job
job = getjobpid(jobs, pid);
if(job == NULL){
printf("(%d): No such process\n", pid);
return;
}
}
else {
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
//kill for each time
kill(-pid, SIGCONT);
if(!strcmp("fg", argv[0])) {
//wait for fg
job->state = FG;
waitfg(job->pid);
}
else{
//print for bg
printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
job->state = BG;
}
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
struct job_t* job = NULL;
sigset_t mask;
int jid = 0;
int fg = !strcmp(argv[0],"fg");
if(argv[1] == NULL){
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
//used to save a bit of repetition when returning after an error
int done = 0;
//SIGCHLD handler could delete the job before it is or read edited
//giving us a seg fault so we must protect it while reading and editing state
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL);
if(isdigit(argv[1][0])){
pid_t pid = atoi(argv[1]);
jid = pid2jid(pid);
if(jid == 0){
printf("(%d): No such process\n", pid);
done = 1;
}
}else if(argv[1][0]=='%'){
argv[1]++;
jid = atoi(argv[1]);
if(getjobjid(jobs, jid) == NULL){
printf("%%%s: No such job\n", argv[1]);
done = 1;
}
}else{
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
done = 1;
}
if(done){
sigprocmask(SIG_UNBLOCK, &mask, NULL);
return;
}
job = getjobjid(jobs, jid);
if(kill(-job->pid,SIGCONT) < 0){
printf("Could not continue child process\n");
sigprocmask(SIG_UNBLOCK, &mask, NULL);
return;
}
//sets state to 1 if fg 2 if bg
job->state = !fg + 1;
if(fg){
sigprocmask(SIG_UNBLOCK, &mask, NULL);
waitfg(job->pid);
}else{
printf("[%d] (%d) %s",job->jid,job->pid, job->cmdline);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
struct job_t *job;
int jid;
pid_t pid;
if (argv[1] == NULL)
{
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
if (argv[1][0] == '%')
{
jid = atoi(argv[1]+1);
if (!(job = getjobjid(jobs, jid)))
{
printf("%s: No such job\n", argv[1]);
return;
}
}
else if (isdigit(argv[1][0]))
{
pid = atoi(argv[1]);
if (!(job = getjobpid(jobs, pid)))
{
printf("(%d): No such process\n", pid);
return;
}
}
else
{
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
if (kill(-(job->pid), SIGCONT) < 0)
{
if (errno != ESRCH)
unix_error("do_bgfg error");
}
if (!strcmp("fg", argv[0]))
{
job->state = FG;
waitfg(job->pid);
}
else if (!strcmp("bg", argv[0]))
{
printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
job->state = BG;
}
else
printf("bg/fg error: %s\n", argv[0]);
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
// Check if there's an argument
if (argv[1] == NULL) {
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
struct job_t* process = NULL;
// Check if it's a pid or a jid
if (argv[1][0] == '%') {
// Check if the jid is valid
if (strlen(argv[1]) == 1 || valid(&argv[1][1]) == 0) {
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
// Get the process
process = getjobjid(jobs, atoi(&argv[1][1]));
// Error handling
if (process == NULL) {
printf("%s: No such job\n", argv[1]);
return;
}
}
else {
// Check if the pid is valid
if (valid(argv[1]) == 0) {
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
// Get the process
process = getjobpid(jobs, (pid_t)atoi(argv[1]));
if (process == NULL) {
printf("(%s): No such process\n", argv[1]);
return;
}
}
// If the process is stopped send SIGCONT
if (process->state == ST) {
Kill(-(process->pid), SIGCONT);
}
// Check if program is bg or fg
if (strcmp(argv[0], "bg") == 0) {
process->state = BG;
// Print job info
printf("[%d] (%d) %s", process->jid, process->pid, process->cmdline);
}
else {
process->state = FG;
waitfg(process->pid);
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
struct job_t * selectedJob;
if(argv[1] == NULL){
printf("Please include PID/JID in 2nd argument\n");
return;
}
if(argv[2] != NULL){
printf("Format should be: fg/bg PID/JID\n");
return;
}
if(argv[1][0] == '%' ){ // look for %n
int jid = argv[1][1] - '0';
if( getjobjid(jobs, jid) == NULL){ //bad jid
printf("Invalid JID\n");
return;
}
selectedJob = getjobjid(jobs, jid);
}
else if( atoi(argv[1] )){ // check if its a pid #
int pid = atoi(argv[1]);
if( getjobpid(jobs, pid) == NULL){ // bad pid
printf("Invalid PID\n");
return;
}
selectedJob = getjobpid(jobs, pid);
}
else{
printf("Unkown job ID/pid entered! \n" );
return;
}
int pid = selectedJob->pid;
if(strcmp(argv[0],"fg") == 0 ){
selectedJob->state = FG;
kill(-pid, SIGCONT);
waitfg(pid);
}
else if(strcmp(argv[0],"bg") == 0 ){
selectedJob->state = BG;
kill(-pid, SIGCONT);
}
}
/*
* 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)
{
// Get memory for our parsed input
char temp[MAXLINE];
char** argv = (char**)temp;
// Return if only newline
if (strcmp(cmdline, "\n") == 0) {
return;
}
// Parse the input
int background = parseline(cmdline, argv);
// Check if built in command
if (builtin_cmd(argv) == 0) {
// Not a built in command
char* programName = argv[0];
// Block sigchild signal
sigset_t mask;
Sigemptyset(&mask);
Sigaddset(&mask, SIGCHLD);
Sigprocmask(SIG_BLOCK, &mask, NULL);
// Create a child process
pid_t pid = Fork();
// Unblock sichild signal
Sigprocmask(SIG_UNBLOCK, &mask, NULL);
if (pid == 0) {
// Child
// Assign it a new process group id
setpgid(0,0);
// Run the external program
Execve(programName, argv, environ);
}
else {
// Parent
if (background == 0) {
// Add it to the list
addjob(jobs, pid, FG, cmdline);
// Make the shell wait for the process in the fg
waitfg(pid);
}
else {
// Add it to the list
addjob(jobs, pid, BG, cmdline);
// Get the job id
int jid = pid2jid(pid);
// Print info on background job
printf("[%d] (%d) %s", jid, pid, cmdline);
}
}
}
return;
}
/*
* 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];
//int to record for bg
int bg;
pid_t pid;
sigset_t mask;
// parse the line
bg = parseline(cmdline, argv);
//check if valid builtin_cmd
if(!builtin_cmd(argv)) {
// blocking first
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL);
// forking
if((pid = fork()) < 0){
unix_error("forking error");
}
// child
else if(pid == 0) {
sigprocmask(SIG_UNBLOCK, &mask, NULL);
setpgid(0, 0);
//check if command is there
if(execvp(argv[0], argv) < 0) {
printf("%s: Command not found\n", argv[0]);
exit(1);
}
}
// parent add job first
else {
if(!bg){
addjob(jobs, pid, FG, cmdline);
}
else {
addjob(jobs, pid, BG, cmdline);
}
sigprocmask(SIG_UNBLOCK, &mask, NULL);
//if bg/fg
if (!bg){
//wait for fg
waitfg(pid);
}
else {
//print for bg
printf("[%d] (%d) %s", pid2jid(pid), 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)
{
char *argv[MAXARGS]; //args for execvp
pid_t pid;
sigset_t sSet;
int stat;
if (*cmdline == 10)
return;
else{
stat= parseline(cmdline, argv);
if (argv[0] == NULL)
return; /* ignore empty lines */
if(!builtin_cmd(argv)){ //If it is not a user command
sigemptyset(&sSet);
sigaddset(&sSet,SIGCHLD);
sigprocmask(SIG_BLOCK, &sSet,NULL);
if((pid = fork()) == 0) { /*Child runs user job*/
setpgrp();
sigprocmask(SIG_UNBLOCK, &sSet,NULL); /*Unblocked after setpgrp() because childpid should be set as group pid first without any interruption */
int stat1=execvp(argv[0], argv); //prints a message if execvp fails.
if(stat1 < 0) { //If the command doesnot exists
stat1=0;
printf("%s: Command not found.\n",argv[0]);//prints a message if execvp fails.
exit(0); /*In case execvp fails then exit will get called.*/
}
}
if(stat) {
addjob(jobs, pid, BG, cmdline); /* request for background job then job is added with BG state*/
sigprocmask(SIG_UNBLOCK,&sSet,NULL); /*unblocks signal after adding all jobs without any type of signal*/
printf("[%d] (%d) %s",pid2jid(pid),pid,cmdline);
}
else
{
addjob(jobs, pid, FG, cmdline) ;
sigprocmask(SIG_UNBLOCK,&sSet,NULL);/*unblocks signal after adding all jobs without any type of signal*/
waitfg(pid);/*parent waits*/
}
}
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
char* p;
int jobid;
if(argv[1]==NULL)
{
printf("%s command requires PID or %%jobid argument\n",argv[0]);
return;
}
if((p = strstr(argv[1],"%"))!=NULL)
{
p++;
jobid=atoi(p);
if(getjobjid(jobs,jobid)!=NULL)
jobid=getjobjid(jobs,jobid)->pid;
else
{
printf("%%[%d]: no such job\n",atoi(p));
return;
}
}
else if(isdigit(argv[1][0]))
{
jobid=atoi(argv[1]); //argv[1] is the pid.
if(getjobpid(jobs,jobid)==NULL)
{
printf("(%d) no such process\n",jobid);
return;
}
}
else
{
printf("%s: argument must be a PID or %%jobid\n",argv[0]);
return;
}
kill(-jobid,SIGCONT);
if(strcmp(argv[0],"fg")==0)
{
getjobpid(jobs,jobid)->state=FG;
waitfg(jobid);
}
else
{
getjobpid(jobs,jobid)->state =BG;
printf("[%d] (%d) %s",getjobpid(jobs,jobid)->jid,getjobpid(jobs,jobid)->pid,getjobpid(jobs,jobid)->cmdline);
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
char *id = argv[1];
if(id == NULL){//invalid input
if(!strcmp(argv[0], "bg") )
printf("bg command requires PID or %%jobid argument\n");
else
printf("fg command requires PID or %%jobid argument\n");
return;
}
struct job_t *job;
int jid;
pid_t pid;
//find job_t from the id
if(id[0] == '%'){ //jid
jid = atoi(&id[1]);
job = getjobjid(jobs, jid);
if(job == NULL){
printf("%%%d: No such job\n", jid);
return;
}
}
else{ //pid
pid = atoi(id);
job = getjobpid(jobs,pid);
if(job == NULL){
printf("(%d): No such process\n", pid);
return;
}
}
//restart job by sending SIGCONT signal
if(kill(- job->pid, SIGCONT) < 0){
printf("Error with SIGCONT\n");
return;
}
if(!strcmp(argv[0], "bg") ){
printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
job->state = BG;
}
else if(!strcmp(argv[0], "fg") ){
job->state = FG;
waitfg(job->pid);
}
else{
printf("There is an error with bg or fg\n");
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
struct job_t * p;
char *ptr;
int ret;
if(argv[1]==NULL) //No argument to fg or bg passed
printf("%s command requires PID or %cjobid argument\n",argv[0],'%');
else{
if(*argv[1]=='%'){ //if job id passed
/* strtol returns integer in the argument passed and pointer to the string if present in it
* For eg. if argument is 1243gjgk, strtol returns 1243 and ptr points to "gjgk".
*/
ret=strtol(++argv[1],&ptr,10);
if(*ptr!='\0'){ //an integer was passed
printf("%s: argument must be a PID or %cjobid\n",argv[0],'%');
return;
}
else{
p=getjobjid(jobs,ret);
if(p==NULL){
printf("%c%d No such job\n",'%',ret);
return;
}
}
}
else{ //Now for pid
ret=strtol(argv[1],&ptr,10);
if(*ptr!='\0'){
printf("%s: argument must be a PID or %cjobid\n",argv[0],'%');
return;
}
else{
p = getjobpid(jobs, ret);
if(p==NULL){
printf("(%d): No such process\n",ret);
return;
}
}
}
kill(-(p->pid),SIGCONT); //Send SIGCONT signal to the process group
if(strcmp(*argv,"fg")==0){
p->state=FG; //change the state to FG
waitfg(p->pid); //wait for the foreground job
}
else{
p->state=BG; //change the state to BG
printf("[%d] (%d) %s",p->jid,p->pid,p->cmdline);
}
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
int jid = 0;
pid_t pid;
/*handle 4 possible errors*/
if (argv[1] == NULL) {
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
if (argv[1][0] != '%' && !((argv[1][0])<='9' && argv[1][0]>='0')){
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
if (argv[1][0] == '%'){
jid = atoi(argv[1]+1);
struct job_t *now_job = getjobjid(jobs,jid);
if (now_job == NULL){
printf("%s: No such job\n", argv[1]);
return;
}
pid = jobs[jid-1].pid;
}
else{
char *str = (char *)malloc(strlen(argv[1])* sizeof (char));
int i = 0;
while (argv[1][i] != '\0' && (argv[1][i]<='9' && argv[1][i]>='0')){
str[i] = argv[1][i];
i++;
}
str[i] = '\0';
pid = atoi(str);
jid = pid2jid(pid);
struct job_t *now_job = getjobjid(jobs,jid);
if (now_job == NULL){
printf("(%s): No such process\n", argv[1]);
return;
}
}
/*handle bg & fg*/
if (strcmp(argv[0],"bg") == 0){
kill(-pid,SIGCONT);
jobs[jid-1].state = BG;
printf("[%d] (%d) %s", jid, pid, jobs[jid-1].cmdline);
}
if (strcmp(argv[0],"fg") == 0){
kill(-pid,SIGCONT);
jobs[jid-1].state = FG;
waitfg(pid);
}
return;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
struct job_t* jd = NULL; //Store the job details
if( argv[1] == NULL ){ //If no second argument
printf("%s command requires PID or %%jobid argument\n", argv[0]); //throw error
return;
}
if(argv[1][0] == '%'){ //If % then job id
if(!isdigit(argv[1][1])){ //If not a digit
printf("%s: argument must be a pid or %%jobid\n", argv[0]); //throw error
return;
}
int jid = atoi( &argv[1][1] ); //Get the jid
if( !( jd = getjobjid( jobs, jid ) ) ){ //If no such job with that jid
printf( "%s: no such job\n", argv[1] ); //throw error
return;
}
}
else{ //If no % then pid
if(!isdigit(argv[1][0])){ //If not a digit
printf("%s: argument must be a pid or %%jobid\n", argv[0]); //throw error
return;
}
pid_t pid = atoi( argv[1] ); //get the pid
if( !( jd = getjobpid( jobs, pid ) ) ){ //if no such job with that pid
printf( "(%s): no such process\n", argv[1]); //throw error
return;
}
}
Kill(-jd->pid, SIGCONT); //Send SIGCONT signal
if( !strcmp( argv[0],"bg" ) ){ //If background
jd->state = BG; //Change job state to BG
printf("[%d] (%d) %s",jd->jid,jd->pid,jd->cmdline); //print status
}
else { //If foreground
jd->state = FG; //Change job state to FG
waitfg( jd->pid ); //Wait for the job to finish
}
return;
}
