自学教程：C++ tcgetpgrp函数代码示例

int main(){int ret;ret=fork();char cmd[100];signal(SIGTTOU, SIG_IGN);if(ret==0){	//igonre SIGTTOU signal. it is generated when a background process calls tcsetpgrp()	signal(SIGTTOU, SIG_IGN);	printf("fg group is %d/n", tcgetpgrp(0));	//create a new proces sgroup.	setpgid(getpid(),getpid());	//set it as fg group in the terminal	tcsetpgrp(0,getpgid());	printf("fg group is %d/n", tcgetpgrp(0));		fflush(stdout);		execlp("wc","wc",NULL);}wait(NULL);tcsetpgrp(0,getpid());printf("fg group is %d/n", tcgetpgrp(0));	return 0;}

void init_tty (void){		int term = STDIN_FILENO;	shooSHPGID = getpgrp(); // Pega o meu group ID			if( isatty(term) ){		/*Enquanto nao tiver em foreground*/		while( tcgetpgrp(term) != shooSHPGID ){ //Enquanto eu nao estiver em foreground			kill(-tcgetpgrp(term), SIGTTIN ); //Tenta depor a shell			shooSHPGID = getpgrp();		}				/*Ignorando sinais*/ 		signal (SIGINT, SIG_IGN);		signal (SIGQUIT, SIG_IGN);				sa_chld.sa_sigaction = &hanchld;		sa_chld.sa_flags = SA_SIGINFO;		sigaddset (&(sa_chld.sa_mask), SIGINT);		sigaddset (&(sa_chld.sa_mask), SIGQUIT);		sigaddset (&(sa_chld.sa_mask), SIGTTIN);		sigaddset (&(sa_chld.sa_mask), SIGTTOU);		sigaddset (&(sa_chld.sa_mask), SIGCHLD);		sigaddset (&(sa_chld.sa_mask), SIGCONT);		sigaddset (&(sa_chld.sa_mask), SIGTSTP);		sa_ttin.sa_sigaction = &hanttin;		sa_ttin.sa_flags = SA_SIGINFO;		sa_ttou.sa_handler = &hanttou;		sa_ttou.sa_flags = 0;		/*Tratamento de sinais*/		sigaction (SIGCHLD, &sa_chld, NULL);		sigaction (SIGTTIN, &sa_ttin, NULL);		sigaction (SIGTTOU, &sa_ttou, NULL);		signal (SIGTSTP, SIG_IGN);						shooSHPGID = getpid(); // Pega o meu pid		if( setpgid(shooSHPGID, shooSHPGID) < 0){ // Seta o meu group ID como o meu PID			fprintf(stderr, "Erro: nao foi possivel setar o group ID/n");			exit(1);		}				tcsetpgrp( term, shooSHPGID ); //Seta o meu group ID como o dono do terminal		tcgetattr( term, &shooSHTermios ); //Pega meus atributos	}}

int main(int argc, char *argv[]){	pid_t pid;	int fd;	if ((pid = fork()) == -1) {		perror("fork");		return -1;	} else if (pid > 0) {		int status;		if (waitpid(pid, &status, 0) == -1) {			perror("waitpid");			return -1;		}		if (WIFEXITED(status)) {			if (WEXITSTATUS(status) != 0) {				fprintf("child exit %d/n", WEXITSTATUS(status));				return -1;			}		} else if (WIFSIGNALED(status)) {			fprintf("child termiated by signal %d/n", WTERMSIG(status));			return -1;		}		printf("parent: pid=%d, ppid=%d, pgrp=%d, sid=%d, tpgrp=%d/n",			getpid(), getppid(), getpgrp(), getsid(0), tcgetpgrp(STDIN_FILENO));		return 0;	}	printf("child: pid=%d, ppid=%d, pgrp=%d, sid=%d, tpgrp=%d/n",		getpid(), getppid(), getpgrp(), getsid(0), tcgetpgrp(STDIN_FILENO));	if ((fd = open("/dev/tty", O_RDONLY)) == -1) {		perror("open controlling terminal failed before creating session");	} else {		printf("open controlling terminal succeed before creating session/n");		close(fd);	}	setsid();	printf("child: pid=%d, ppid=%d, pgrp=%d, sid=%d, tpgrp=%d/n",		getpid(), getppid(), getpgrp(), getsid(0), tcgetpgrp(STDIN_FILENO));	if ((fd = open("/dev/tty", O_RDONLY)) == -1) {		perror("open controlling terminal failed after creating session");	} else {		printf("open controlling terminal succeed after creating session/n");		close(fd);	}	return 0;}

void init_shell(){     /* Check if we are running interactively */  shell_terminal = STDIN_FILENO;  /** Note that we cannot take control of the terminal if the shell      is not interactive */  shell_is_interactive = isatty(shell_terminal);  if(shell_is_interactive){    /* force into foreground */    while(tcgetpgrp (shell_terminal) != (shell_pgid = getpgrp()))      kill( - shell_pgid, SIGTTIN);    shell_pgid = getpid();    /* Put shell in its own process group */    if(setpgid(shell_pgid, shell_pgid) < 0){      perror("Couldn't put the shell in its own process group");      exit(1);    }    /* Take control of the terminal */    tcsetpgrp(shell_terminal, shell_pgid);    tcgetattr(shell_terminal, &shell_tmodes);  }  /** YOUR CODE HERE */}

void init_shell() {  	/* See if we are running interactively.  */	shell_terminal = STDIN_FILENO;	/* isatty test whether a file descriptor referes to a terminal */	shell_is_interactive = isatty(shell_terminal);	if(shell_is_interactive) {    		/* Loop until we are in the foreground.  */    		while(tcgetpgrp(shell_terminal) != (shell_pgid = getpgrp()))      			kill(- shell_pgid, SIGTTIN);    		/* Ignore interactive and job-control signals.  */                /* If tcsetpgrp() is called by a member of a background process                  * group in its session, and the calling process is not blocking or                 * ignoring  SIGTTOU,  a SIGTTOU signal is sent to all members of                  * this background process group.                 */		signal(SIGTTOU, SIG_IGN);		/* Put ourselves in our own process group.  */		shell_pgid = getpid();		if(setpgid(shell_pgid, shell_pgid) < 0) {			perror("Couldn't put the shell in its own process group");			exit(1);		}		/* Grab control of the terminal.  */		tcsetpgrp(shell_terminal, shell_pgid);		/* Save default terminal attributes for shell.  */		tcgetattr(shell_terminal, &shell_tmodes);	}}

void init_shell(void){  cash_terminal = STDIN_FILENO;  cash_interactive = isatty(cash_terminal);    if(cash_interactive){    while(tcgetpgrp (cash_terminal) != (cash_pgid = getpgrp ()))      kill (- cash_pgid, SIGTTIN);      signal (SIGINT, SIG_IGN);      signal (SIGQUIT, SIG_IGN);      signal (SIGTSTP, SIG_IGN);      signal (SIGTTIN, SIG_IGN);      signal (SIGTTOU, SIG_IGN);            cash_pid = getpid();      cash_pgid = getpid();      if(setpgid(cash_pgid, cash_pgid) < 0){	if(logging)	  write_to_log(SHELL_PANIC, "could not spawn interactive shell");	exit_clean(1, "could not spawn interactive shell/n");      }      else	tcsetpgrp(cash_terminal, cash_pgid);      tcgetattr(cash_terminal, &cash_tmodes);  }}

char *osdep_get_name(int fd, unused char *tty){	FILE	*f;	char	*path, *buf;	size_t	 len;	int	 ch;	pid_t	 pgrp;	if ((pgrp = tcgetpgrp(fd)) == -1)		return (NULL);	xasprintf(&path, "/proc/%lld/cmdline", (long long) pgrp);	if ((f = fopen(path, "r")) == NULL) {		xfree(path);		return (NULL);	}	xfree(path);	len = 0;	buf = NULL;	while ((ch = fgetc(f)) != EOF) {		if (ch == '/0')			break;		buf = xrealloc(buf, 1, len + 2);		buf[len++] = ch;	}	if (buf != NULL)		buf[len] = '/0';	fclose(f);	return (buf);}

/* If dsh is running interactively as the foreground job * then set the process group and signal handlers * */void init_dsh(){	// in batch mode, STDIN_FILENO is not associated to terminal input.	dsh_terminal_fd = STDIN_FILENO;	dsh_is_interactive = isatty(dsh_terminal_fd);	if(dsh_is_interactive) {		/* Loop until we are in the foreground.  */		DEBUG("dsh run as foreground");		while(tcgetpgrp(dsh_terminal_fd) != (dsh_pgid = getpgrp())){            // SIGTTIN: (SIGnal due to TeleType INput)			kill(-dsh_pgid, SIGTTIN); /* Request for terminal input */		}		/* Ignore interactive and job-control signals.		* If tcsetpgrp() is called by a member of a background process		* group in its session, and the calling process is not blocking or		* ignoring SIGTTOU,  a SIGTTOU signal is sent to all members of		* this background process group.		*/        // register signal handler. ignore all the        // SIGTTOU (SIGnal due to TeleType OUtput) is the corresponding signal when a backgrounded (nohuped, etc) job tries to output to the terminal.		signal(SIGTTOU, SIG_IGN);		dsh_pgid = getpid();		if(setpgid(dsh_pgid, dsh_pgid) < 0) {			perror("Couldn't put the dsh in its own process group");			exit(EXIT_FAILURE);		}		seize_tty(dsh_pgid);		printf("/n--- Hi, you are using dsh shell, have fun! ---/n/n");	}	else{		DEBUG("dsh run as background");	}}

void tty_init(void){#ifndef __DJGPP__	int fd;	struct termios ti;	if (tty_fd >= 0) return;	if ((fd = open("/dev/tty", O_RDONLY | O_NONBLOCK)) < 0) return;#ifndef __CYGWIN32__	if (tcgetpgrp(fd) != getpid()) {		close(fd); return;	}#endif	tcgetattr(fd, &ti);	saved_ti = ti;	ti.c_lflag &= ~(ICANON | ECHO);	ti.c_cc[VMIN] = 1;	ti.c_cc[VTIME] = 0;	tcsetattr(fd, TCSANOW, &ti);	tty_fd = fd;	atexit(tty_done);#endif}

void init_dsh() {	dsh_terminal_fd = STDIN_FILENO;	/* isatty(): test whether a file descriptor refers to a terminal 	 * isatty() returns 1 if fd is an open file descriptor referring to a 	 * terminal; otherwise 0 is returned, and errno is set to indicate the error. 	 * */	dsh_is_interactive = isatty(dsh_terminal_fd);  	/* See if we are running interactively.  */	if(dsh_is_interactive) {		/* Loop until we are in the foreground.  */		while(tcgetpgrp(dsh_terminal_fd) != (dsh_pgid = getpgrp()))			kill(- dsh_pgid, SIGTTIN); /* Request for terminal input */		/* Ignore interactive and job-control signals.		* If tcsetpgrp() is called by a member of a background process 		* group in its session, and the calling process is not blocking or		* ignoring SIGTTOU,  a SIGTTOU signal is sent to all members of 		* this background process group.		*/		signal(SIGTTOU, SIG_IGN);		/* Put the dsh in our own process group.  */		dsh_pgid = getpid();		if(setpgid(dsh_pgid, dsh_pgid) < 0) {			perror("Couldn't put the dsh in its own process group");			exit(EXIT_FAILURE);		}		seize_tty(dsh_pgid);	} }

/** * initializes variables and enables job control * NOTE: function substantially stolen by the very useful glibc manual: * http://www.gnu.org/software/libc/manual/html_node/Implementing-a-Shell.html */void init(){        RSH_PID = getpid();                                                             // retrieve the pid of the shell        RSH_TERMINAL = STDIN_FILENO;                                       // terminal = STDIN        RSH_IS_INTERACTIVE = isatty(RSH_TERMINAL);            // the shell is interactive if STDIN is the terminal        if (RSH_IS_INTERACTIVE) {                                                 // is the shell interactive?                while (tcgetpgrp(RSH_TERMINAL) != (RSH_PGID = getpgrp()))                        kill(RSH_PID, SIGTTIN);                                                    // make sure we are in the foreground                /**                 * ignore all the job control stop signals and install custom signal handlers                 */                signal(SIGQUIT, SIG_IGN);                signal(SIGTTOU, SIG_IGN);                signal(SIGTTIN, SIG_IGN);                signal(SIGTSTP, SIG_IGN);                signal(SIGINT, SIG_IGN);                signal(SIGCHLD, &signalHandler_child);                setpgid(RSH_PID, RSH_PID);                                         // we make the shell process as new process group leader                RSH_PGID = getpgrp();                if (RSH_PID != RSH_PGID) {                        printf("Error, the shell is not process group leader");                        exit(EXIT_FAILURE);                }                if (tcsetpgrp(RSH_TERMINAL, RSH_PGID) == -1)      // if Rsh cannot grab control of the terminal                        tcgetattr(RSH_TERMINAL, &RSH_TMODES);             // we save default terminal attributes for shell.                currentDirectory = (char*) calloc(1024, sizeof(char));        } else {                printf("Could not make R-shell interactive. Exiting../n");                exit(EXIT_FAILURE);        }}

char *osdep_get_cwd(int fd){	static char	 target[MAXPATHLEN + 1];	char		*path;	pid_t		 pgrp, sid;	ssize_t		 n;	if ((pgrp = tcgetpgrp(fd)) == -1)		return (NULL);	xasprintf(&path, "/proc/%lld/cwd", (long long) pgrp);	n = readlink(path, target, MAXPATHLEN);	free(path);	if (n == -1 && ioctl(fd, TIOCGSID, &sid) != -1) {		xasprintf(&path, "/proc/%lld/cwd", (long long) sid);		n = readlink(path, target, MAXPATHLEN);		free(path);	}	if (n > 0) {		target[n] = '/0';		return (target);	}	return (NULL);}

/* test if an open file refers to the process' controlling terminal. */BOOL isctty(INT fd)        {        if (tcgetpgrp(fd) != -1)                return (YES);        else                return (NO);        }

static voidcheck_fg( char *ptyname) {    int pg, fgpg, fgpg2, fd;    fd = open( "/dev/tty", 0);    if( fd < 0)  complain( "cant open /dev/tty");    fgpg = tcgetpgrp( fd);    if( fgpg < 0)  complain( "cant tcgetpg");    pg = getpgrp();    if(pg != fgpg)  complain( "pg not fg");    close( fd);    fd = open( ptyname, 0);    fgpg2 = tcgetpgrp( fd);    if( fgpg2 != fgpg)  complain( "ctty not pty");    close( fd);}

/* Make sure the shell is running interactively as the foreground job   before proceeding. */void init_shell () {	/* See if we are running interactively.  */	shell_terminal = STDIN_FILENO;	shell_is_interactive = isatty (shell_terminal);	if (shell_is_interactive) {		/* Loop until we are in the foreground.  */		while (tcgetpgrp (shell_terminal) != (shell_pgid = getpgrp ()))			kill (- shell_pgid, SIGTTIN);		/* Ignore interactive and job-control signals.  */		signal (SIGINT, SIG_IGN);		signal (SIGQUIT, SIG_IGN);		signal (SIGTSTP, SIG_IGN);		signal (SIGTTIN, SIG_IGN);		signal (SIGTTOU, SIG_IGN);		signal (SIGCHLD, SIG_IGN);		/* Put ourselves in our own process group.  */		shell_pgid = getpid ();		if (setpgid (shell_pgid, shell_pgid) < 0) {			perror ("Couldn't put the shell in its own process group");			exit (1);		}		/* Grab control of the terminal.  */		tcsetpgrp (shell_terminal, shell_pgid);		/* Save default terminal attributes for shell.  */		tcgetattr (shell_terminal, &shell_tmodes);	}}

void init(){	//history[11] = {0};        MSH_PID = getpid();        MSH_TERMINAL = STDIN_FILENO;        MSH_IS_INTERACTIVE = isatty(MSH_TERMINAL);        if (MSH_IS_INTERACTIVE) {                while (tcgetpgrp(MSH_TERMINAL) != (MSH_PGID = getpgrp()))                        kill(MSH_PID, SIGTTIN);                signal(SIGQUIT, SIG_IGN);                signal(SIGTTOU, SIG_IGN);                signal(SIGTTIN, SIG_IGN);                signal(SIGTSTP, SIG_IGN);                signal(SIGINT, SIG_IGN);                signal(SIGCHLD, &signalHandler_child);                setpgid(MSH_PID, MSH_PID);                MSH_PGID = getpgrp();                if (MSH_PID != MSH_PGID) {                        printf("Error, the shell is not process group leader");                        exit(EXIT_FAILURE);                }                if (tcsetpgrp(MSH_TERMINAL, MSH_PGID) == -1)                        tcgetattr(MSH_TERMINAL, &MSH_TMODES);                currentDirectory = (char*) calloc(1024, sizeof(char));        } else {                printf("Could not make MyShell interactive. Exiting.../n");                exit(EXIT_FAILURE);        }}

char *osdep_get_name(int fd, __unused char *tty){	int		 mib[6];	struct stat	 sb;	size_t		 len, i;	struct kinfo_proc2 *buf, *newbuf, *bestp;	char		*name;	if (stat(tty, &sb) == -1)		return (NULL);	if ((mib[3] = tcgetpgrp(fd)) == -1)		return (NULL);	buf = NULL;	len = sizeof bestp;	mib[0] = CTL_KERN;	mib[1] = KERN_PROC2;	mib[2] = KERN_PROC_PGRP;	mib[4] = sizeof *buf;retry:	mib[5] = 0;	if (sysctl(mib, __arraycount(mib), NULL, &len, NULL, 0) == -1)		return (NULL);	if ((newbuf = realloc(buf, len)) == NULL)		goto error;	buf = newbuf;	mib[5] = len / (sizeof *buf);	if (sysctl(mib, __arraycount(mib), buf, &len, NULL, 0) == -1) {		if (errno == ENOMEM)			goto retry;		goto error;	}	bestp = NULL;	for (i = 0; i < len / (sizeof *buf); i++) {		if (buf[i].p_tdev != sb.st_rdev)			continue;		if (bestp == NULL)			bestp = &buf[i];		else			bestp = cmp_procs(&buf[i], bestp);	}	name = NULL;	if (bestp != NULL)		name = strdup(bestp->p_comm);	free(buf);	return (name);error:	free(buf);	return (NULL);}

void init_shell() {    /* Check if we are running interactively */    shell_terminal = STDIN_FILENO;    s = malloc(INPUT_STRING_SIZE+1); /* user input string */    /** Note that we cannot take control of the terminal if the shell    is not interactive */    shell_is_interactive = isatty(shell_terminal);    if (shell_is_interactive) {        /* force into foreground */        while (tcgetpgrp (shell_terminal) != (shell_pgid = getpgrp()))            kill (- shell_pgid, SIGTTIN);            /* Ignore interactive and job-control signals.  */            signal (SIGINT, SIG_IGN);            signal (SIGQUIT, SIG_IGN);            signal (SIGTSTP, SIG_IGN);            signal (SIGTTIN, SIG_IGN);            signal (SIGTTOU, SIG_IGN);            signal (SIGCHLD, SIG_IGN);        shell_pgid = getpid();        /* Put shell in its own process group */        if(setpgid(shell_pgid, shell_pgid) < 0) {          perror("Couldn't put the shell in its own process group... Eish.");          exit(1);        }        /* Take control of the terminal */        tcsetpgrp(shell_terminal, shell_pgid);        tcgetattr(shell_terminal, &shell_tmodes);  }}

static int is_fg(void){	pid_t pgid = getpgrp();	pid_t tcpgid = tcgetpgrp(1);	return (pgid != -1) && (pgid == tcpgid);}

voidonint(void){	sigset_t sigs;	/*	 * The !in_dotrap here is safe.  The only way we can arrive here	 * with in_dotrap set is that a trap handler set SIGINT to SIG_DFL	 * and killed itself.	 */	if (suppressint && !in_dotrap) {		intpending++;		return;	}	intpending = 0;	sigemptyset(&sigs);	sigprocmask(SIG_SETMASK, &sigs, NULL);	/*	 * This doesn't seem to be needed, since main() emits a newline.	 */#if 0	if (tcgetpgrp(0) == getpid())		write(STDERR_FILENO, "/n", 1);#endif	if (rootshell && iflag)		exraise(EXINT);	else {		signal(SIGINT, SIG_DFL);		kill(getpid(), SIGINT);	}}

voidinit_shell( void ) {  // Check if we are running interactively  shell_terminal = STDIN_FILENO;  shell_is_interactive = isatty( shell_terminal );  if( shell_is_interactive ){    // force into foreground    while( tcgetpgrp( shell_terminal ) != ( shell_pgid = getpgrp() ) )      kill( - shell_pgid, SIGTTIN);    // put shell in its own process group    shell_pgid = getpid();    if( setpgid( shell_pgid, shell_pgid ) < 0 ){      perror( "Couldn't put the shell in its own process group" );      exit( EXIT_FAILURE );    }    // take control of the terminal    tcsetpgrp(shell_terminal, shell_pgid);    tcgetattr(shell_terminal, &shell_tmodes);  }  // ignore signals  SET_SIGNALS( SIG_IGN );  }

/*www.gnu.org/software/libc/manual/html_node/Initializing-the-Shell.html*/void init_shell() {    /*keep track of shell attributes*/    pid_t shell_pgid;    int shell_is_interactive;    /*make sure shell is foreground process*/    shell_terminal = STDIN_FILENO;    while (tcgetpgrp(shell_terminal) != (shell_pgid = getpgrp())) {        kill (- shell_pgid, SIGTTIN);    }    /*ignore interactive and job-control signals so the    shell doesn't kill its own process*/    signal(SIGINT, SIG_IGN);    signal(SIGQUIT, SIG_IGN);    signal(SIGTSTP, SIG_IGN);    signal(SIGTTIN, SIG_IGN);    signal(SIGTTOU, SIG_IGN);    signal(SIGCHLD, SIG_IGN);    /*put ourselves in our own process group*/    shell_pgid = getpid();    if (setpgid(shell_pgid, shell_pgid) < 0) {        perror("Couldn't put the shell in its own process group.");        exit(1);    }    /*grab control of the terminal*/    tcsetpgrp(shell_terminal, shell_pgid);    /*save default terminal attributes for shell*/    tcgetattr(shell_terminal, &shell_tmodes);}

static voidpr_ids(char *name){  printf("%s: pid = %d, ppid = %d, pgrp = %d, tpgrp = %d/n",         name, getpid(), getppid(), getpgrp(), tcgetpgrp(STDIN_FILENO));  fflush(stdout);}

/* ____ SOSTIUIRE QUESTO PROGRAMMA __ */int main(int argc, char* argv[]){    pid_t pid;    int fd;    get_info("CALLING PROCESS", 0);    fd = open("/dev/tty", O_RDWR);    printf("PGID leader: %ld/n", (long)tcgetpgrp(fd));    printf("PGID foreground: %ld/n", (long)tcgetsid(0));    switch (pid = fork()) {    case -1:        fprintf(stderr, "Err.(%s) fork() failed/n", strerror(errno));        exit(EXIT_FAILURE);    case 0:        /* Il processo figlio crea una nuova sessione, pertanto PGID e        SID sono settati al PID del figlio medesimo */        setsid();        get_info("CHILD PROCESS", pid);        exit(EXIT_SUCCESS);    default:        waitpid(pid, NULL, 0);    }    return (EXIT_SUCCESS);}

void bootstrap(){processid = getpid();shellbash = isatty(STDIN_FILENO);  if (shellbash) {				while (tcgetpgrp(STDIN_FILENO) != (parentPID = getpgrp()))		kill(processid, SIGTTIN);		act_child.sa_handler = signalHandler_child;		act_int.sa_handler = signalHandler_int;		sigaction(SIGCHLD, &act_child, 0);		sigaction(SIGINT, &act_int, 0);		setpgid(processid, processid); 		parentPID = getpgrp();if (processid != parentPID) {exit(EXIT_FAILURE);}tcsetpgrp(STDIN_FILENO, parentPID);tcgetattr(STDIN_FILENO, &bashmodes);currentDirectory = (char*) calloc(1024, sizeof(char));} else {exit(EXIT_FAILURE);}}

static char *osdep_get_cwd_fallback(int fd){	static char		 wd[PATH_MAX];	struct kinfo_file	*info = NULL;	pid_t			 pgrp;	int			 nrecords, i;	if ((pgrp = tcgetpgrp(fd)) == -1)		return (NULL);	if ((info = kinfo_getfile(pgrp, &nrecords)) == NULL)		return (NULL);	for (i = 0; i < nrecords; i++) {		if (info[i].kf_fd == KF_FD_TYPE_CWD) {			strlcpy(wd, info[i].kf_path, sizeof wd);			free(info);			return (wd);		}	}	free(info);	return (NULL);}

/*  * 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, SIGTSTP, SIGTTIN or SIGTTOU 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){        if(pid == fgpid(job_list)){            if(tcgetpgrp(STDIN_FILENO) != shell_pid) {                tcsetpgrp(STDIN_FILENO, shell_pid);            }        }        if(WIFEXITED(status)){            deletejob(job_list, pid);        } else if(WIFSIGNALED(status)){            printf("Job [%d] (%d) terminated by signal %d/n",                   pid2jid(pid), pid, WTERMSIG(status));            deletejob(job_list, pid);        } else if (WIFSTOPPED(status)) {            printf("Job [%d] (%d) stopped by signal %d/n",                    pid2jid(pid), pid, WSTOPSIG(status));            getjobpid(job_list, pid)->state = ST;        }    }    return;}

void show_progress(OFF_T ofs, OFF_T size){	struct timeval now;#if defined HAVE_GETPGRP && defined HAVE_TCGETPGRP	static pid_t pgrp = -1;	pid_t tc_pgrp;#endif	if (am_server)		return;#if defined HAVE_GETPGRP && defined HAVE_TCGETPGRP	if (pgrp == -1)		pgrp = getpgrp(GETPGRP_ARG);#endif	gettimeofday(&now, NULL);	if (INFO_GTE(PROGRESS, 2)) {		ofs = stats.total_transferred_size - size + ofs;		size = stats.total_size;	}	if (!ph_start.time.tv_sec) {		int i;		/* Try to guess the real starting time when the sender started		 * to send us data by using the time we last received some data		 * in the last file (if it was recent enough). */		if (msdiff(&ph_list[newest_hpos].time, &now) <= 1500) {			ph_start.time = ph_list[newest_hpos].time;			ph_start.ofs = 0;		} else {			ph_start.time.tv_sec = now.tv_sec;			ph_start.time.tv_usec = now.tv_usec;			ph_start.ofs = ofs;		}		for (i = 0; i < PROGRESS_HISTORY_SECS; i++)			ph_list[i] = ph_start;	}	else {		if (msdiff(&ph_list[newest_hpos].time, &now) < 1000)			return;		newest_hpos = oldest_hpos;		oldest_hpos = (oldest_hpos + 1) % PROGRESS_HISTORY_SECS;		ph_list[newest_hpos].time.tv_sec = now.tv_sec;		ph_list[newest_hpos].time.tv_usec = now.tv_usec;		ph_list[newest_hpos].ofs = ofs;	}#if defined HAVE_GETPGRP && defined HAVE_TCGETPGRP	tc_pgrp = tcgetpgrp(STDOUT_FILENO);	if (tc_pgrp != pgrp && tc_pgrp != -1)		return;#endif	rprint_progress(ofs, size, &now, False);}

static intstart_inferior (char *argv[], char *statusptr){#ifdef SIGTTOU  signal (SIGTTOU, SIG_DFL);  signal (SIGTTIN, SIG_DFL);#endif  signal_pid = create_inferior (argv[0], argv);  /* FIXME: we don't actually know at this point that the create     actually succeeded.  We won't know that until we wait.  */  printf_filtered ("Process %s created; pid = %ld/n", argv[0],                   signal_pid);#ifdef SIGTTOU  signal (SIGTTOU, SIG_IGN);  signal (SIGTTIN, SIG_IGN);  terminal_fd = fileno (stderr);  old_foreground_pgrp = tcgetpgrp (terminal_fd);  tcsetpgrp (terminal_fd, signal_pid);  atexit (restore_old_foreground_pgrp);#endif  /* Wait till we are at 1st instruction in program, return signal     number (assuming success).  */  return mywait (statusptr, 0);}