Esempio n. 1
0
void shell_server()
{
	int pidp;
	int pid;
	int *fifo;
	
	init_transit(0);
	init_data(0);
	if (!(fifo = (int *)malloc(2*sizeof(int))))
		error("malloc error\n");
	pidp = getpid();
	if ((pid = fork()))
	{
		ft_pidsave(pid);
		return ;
	}
	pipe(fifo);
	recup_pipe(fifo);
	init_pipe_redir();
	if (!(pid = fork()))
	{
		ft_pidsave(pidp);
		wait_sig();
	}
	ft_pidsave(pid);
	signal(SIGINT, killslave);
	servershell(pid);
}
Esempio n. 2
0
void child(int child_id){
	signal(SIGINT, sig_int);
	wait_sig();
	lockf(STDOUT_FILENO, F_LOCK, 0);
	printf("child %d is terminating\n", child_id);
	lockf(STDOUT_FILENO, F_ULOCK, 0);
}
Esempio n. 3
0
int main(){
	pid_t p1, p2;
	int fd_stdout = STDOUT_FILENO;

	signal(SIGINT, sig_int);
	
	while ((p1=fork()) == -1);
	if (!p1){
		child(1);
		return 0;
	}
	while ((p2=fork()) == -1);
	if (!p2) {
		child(2);
		return 0;
	}

	puts("waiting SIGINT...");
	wait_sig();

	kill(p1, SIGINT);
	kill(p2, SIGINT);

	wait(0);
	wait(0);

	puts("parent is terminating");
	return 0;
}
Esempio n. 4
0
int pipe_loop() {
    unsigned long check;
    pid_t pid;

    /* Hope the sleep will help the top process
     * finish the forkes, at least most of them*/
    sleep (1);

    if (pipe (p1) || pipe (p2)) {
        perror ("pipe created failed");
        exit (ERR_PIP);
    }

    if ((pid = fork()) < 0) {
#ifdef DEBUG
        perror ("fork failed\n");
#endif
        exit (ERR_FRK);
    }

    if (pid > 0) {
        /* parent process */

#if 0
        /***************************************************
        * Set up the signal
        * only after receiving the SIGUSR1 signal
        * transfer is started
        **************************************************/
        wait_sig (SIGUSR1, resume);
        pause ();
#endif

        /* set up the timer */
        wake_me (duration, report);

        /* master, write p1 & read p2 */
        close(p1[0]); close(p2[1]);
        while (1) {
            if (write(p1[1], (char *)&iter, sizeof(iter)) != sizeof(iter)) {
#ifdef NDEBUG
                if ((errno != 0) && (errno != EINTR))
                    perror("master write failed");
#endif
                exit(ERR_WRI);
            }

            if (read(p2[0], (char *)&check, sizeof(check)) != sizeof(check)) {
#ifdef NDDEBUG
                if ((errno != 0) && (errno != EINTR))
                    perror("master read failed");
#endif
                exit(ERR_RED);
            }

            if (check != iter) {
#ifdef DEBUG
                printf("Master sync error: expect %lu, got %lu\n",
                       iter, check);
#endif
                exit(ERR_SYN);
            }
            iter++;
        }
    }
    /* child process */

#if 0
    /**************************************************
     * Child processes must ignore the signal SIGUSR1
     * otherwise will be corrupted. Also this would
     * prevent overhead casued by signal handling
     **************************************************/
    signal (SIGUSR1, SIG_IGN);
#endif


    unsigned long iter1;
    iter1 = 0;
    /* slave, read p1 & write p2 */
    close(p1[1]); close(p2[0]);
    while (1) {
        if (read(p1[0], (char *)&check, sizeof(check)) != sizeof(check)) {
#ifdef NDEBUG
            if ((errno != 0) && (errno != EINTR))
                perror("slave read failed");
#endif
            exit(ERR_RED);
        }

        if (check != iter1) {
#ifdef DEBUG
            printf("Slave sync error: expect %lu, got %lu\n",
                   iter1, check);
#endif
            exit(ERR_SYN);
        }
        if (write(p2[1], (char *)&iter1, sizeof(iter1)) != sizeof(iter1)) {
#ifdef NDEBUG
            if ((errno != 0) && (errno != EINTR))
                perror("slave write failed");
#endif
            exit(ERR_WRI);
        }
        iter1++;
    }
    return 0;
}