ырудд_зшзу3

#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/time.h>
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <stdlib.h>
#include <sys/resource.h>
#include "util.h"

typedef struct pr_list{
    char **pr_arr;
    pid_t pid;
    struct pr_list *next;
}pr_list;

typedef struct pipe_list{
    char *line;
    struct pipe_list *next;
    pr_list *prs;
}pipe_list;

void printf_prs(char *array[]){
    int i;
    for (i = 0; array[i] != NULL /*&& array[i] != NULL*/; i++){
        printf("%s ", array[i]);
    }
}

void add_pr(char *pr, char **array[]){
    int i, j, len;
    /*  count "non-NULL" cells  */
    for (j = 0; (*array)[j] != NULL; j++);
    j += 2;//j "non-NULL" + 1 "NULL" + 1 extra for a new argument
    (*array) = realloc((*array), j*sizeof(char*));
    /*  MOVE PR INTO CELL   */
    for (i = 0; ((*array)[i]) != NULL && (i < j) ; i++);
    len = strlen(pr);
    ((*array)[i]) = calloc(len + 1, sizeof(char));
    for (j = 0; j < len; j++){
        ((*array)[i][j]) = pr[j];
    }
    ((*array)[i][j]) = '\0';
    /*  NEXT CELL = NULL    */
    ((*array)[i+1]) = NULL;
}

    /*  MAIN    */

int main(int argc, char *argv[]){
    int i, j, k, len, word_begin, word_end;
    int status;
    pid_t pid;
    int not_empty, back_mode, pr_flag, error_flag;
    int exited_flag = 1, next_pr = 0;
    pipe_list *c_pipe, *pipes, *p_pipe;
    pr_list *c_pr, *p_pr, *pr_pointer;
    char *new_line, *cur_word;

    printf("Please input pipe\n");
    pipes = malloc(sizeof(pipe_list));
    pipes->next = NULL;
    pipes->line = NULL;
    pipes->prs = NULL;

    while ((new_line = getline_unlim()) != NULL){
        if (!strcmp(new_line,"")) continue;
        /*  WAIT BACK PROCESSES */
        while ((pid = wait4(-1, &status, WNOHANG, NULL)) > 0){
            p_pipe = pipes->next;
            while (p_pipe){
                p_pr = p_pipe->prs;
                while (p_pr){
                    if (pid == p_pr->pid){
                        p_pr->pid = -1;
                        printf("program \"%s\" has been completed with exit status: %d\n", p_pr->pr_arr[0], WEXITSTATUS(status));
                        pr_pointer = p_pr;
                        exited_flag = 1;
                        while (pr_pointer){
                            if (pr_pointer->pid != -1){
                                exited_flag = 0;
                                break;
                            }
                            pr_pointer = pr_pointer->next;
                        }
                        if (exited_flag){
                            printf("pipe \"%s\" has been completed with exit status: %d\n", p_pipe->line, WEXITSTATUS(status));
                        }
                    }
                    p_pr = p_pr->next;
                }
                p_pipe = p_pipe->next;
            }
        }

        /*  DELETE PRS WITH PID == -1   */
        p_pipe = pipes->next;
        while (p_pipe){
            p_pr = p_pipe->prs;
            while (p_pr){
                if (p_pr->pid == -1){
                    if (p_pr == p_pipe->prs){
                        for (i = 0; p_pr->pr_arr[i] != NULL; i++){
                            if (p_pr->pr_arr[i])
                                free((p_pr->pr_arr[i]));
                        }
                        if (p_pr->pr_arr)
                            free(p_pr->pr_arr);
                        p_pipe->prs = p_pr->next;
                        if (p_pr)
                            free(p_pr);
                        p_pr = p_pipe->prs;
                    }else{
                        c_pr = p_pipe->prs;
                        while (c_pr->next != p_pr && c_pr->next != NULL){
                            c_pr = c_pr->next;
                        }
                        c_pr->next = p_pr->next;
                        for (i = 0; p_pr->pr_arr[i] != NULL; i++){
                            if (p_pr->pr_arr[i])
                                free((p_pr->pr_arr[i]));
                        }
                        if (p_pr->pr_arr)
                            free(p_pr->pr_arr);
                        p_pipe->prs = p_pr->next;
                        if (p_pr)
                            free(p_pr);
                        p_pr = c_pr;
                    }
                }else{
                    p_pr = p_pr->next;
                }
            }
            p_pipe = p_pipe->next;
        }


        if( !strcmp(new_line, "exit") || !strcmp(new_line, "EXIT") ){
            printf("exit\n");
            break;
        }

        /* processing line, creating pipe */

        c_pipe = pipes;
        while (c_pipe){
            c_pipe = c_pipe->next;
        }
        /*  allocate memory for current pipe    */
        c_pipe = calloc(1, sizeof(pipe_list));
        c_pipe->next = NULL;
        c_pipe->prs = NULL;

        len = strlen(new_line);
        /*  copy new_line to current_pipe->line */
        c_pipe->line = calloc(len + 1, sizeof(char));
        for (i = 0; i < len + 1; i++){
            c_pipe->line[i] = new_line[i];
        }

        /*  allocate memory for first pr in current pipe    */
        c_pipe->prs = calloc(1, sizeof(pr_list));
        c_pipe->prs->pr_arr = calloc(1, sizeof(char*));
        c_pipe->prs->pr_arr[0] = NULL;
        c_pipe->prs->next = NULL;
        c_pr = c_pipe->prs;

        p_pipe = pipes;
        while (p_pipe->next){
            p_pipe = p_pipe->next;
        }
        p_pipe->next = c_pipe;

        word_begin = 0; word_end = 0; next_pr = 0; error_flag = 0;
        not_empty = 0, back_mode = 0, pr_flag = 1;
        for (i = 0; i < len; i++){
            if (pr_flag){
                c_pipe->prs = c_pr;
                pr_flag = 0;
                not_empty = 0;
            }
            if (next_pr){
                c_pr->next = calloc(1, sizeof(pr_list));
                c_pr = c_pr->next;
                c_pr->pr_arr = calloc(1, sizeof(char*));
                c_pr->next = NULL;
                next_pr = 0;
                not_empty = 0;
            }

            if ( isspace(new_line[i]) || new_line[i] == '|' || new_line[i] == '&' ){
                if (new_line[i] == '|'){
                    if (!not_empty) error_flag = 1;
                    next_pr = 1;
                    not_empty = 0;
                }
                if (new_line[i] == '&'){
                    back_mode = 1;
                }
                new_line[i] = '\0';
                word_end = i;

                k = word_end - word_begin;
                if (k != 0){
                    cur_word = calloc(k, sizeof(char));
                    for (j = 0; j < k; j++){
                        cur_word[j] = new_line[word_begin + j];
                    }
                    word_begin = i + 1;
                }
                if (word_begin != word_end){
                    if (strcmp(cur_word,"")){
                        if (!not_empty) not_empty = 1;
                        add_pr(cur_word, &(c_pr->pr_arr));
                        if (cur_word)
                            free(cur_word);
                    }
                }
            }
        }
        k = i - word_begin;
        if (k != 0){
            cur_word = calloc(k, sizeof(char));
            for (j = 0; j < k; j++){
                cur_word[j] = new_line[word_begin + j];
            }
        }
        if (word_begin != i){
            if (strcmp(cur_word,"")){
                if (!not_empty) not_empty = 1;
                add_pr(cur_word, &(c_pr->pr_arr));
                if (cur_word)
                    free(cur_word);
            }
        }

        /*  executing pipe  */
            if (error_flag){
                printf("pipe was written incorrectly\n");

                if (c_pipe){
                    if (c_pipe->line)
                        free(c_pipe->line);
                    p_pr = c_pipe->prs;
                    while (p_pr){
                        for (i = 0; p_pr->pr_arr[i] != NULL; i++){
                            if(p_pr->pr_arr[i])
                                free((p_pr->pr_arr[i]));
                        }
                        if (p_pr->pr_arr)
                            free(p_pr->pr_arr);
                        c_pipe->prs = p_pr->next;
                        if (p_pr)
                            free(p_pr);
                        p_pr = c_pipe->prs;
                    }
                    c_pipe = NULL;
                }

            }else if (!back_mode){
        /*  STANDART MODE   */
                int cnt = 0;
                p_pr = c_pipe->prs;
                while (p_pr){
                    cnt++;
                    if (p_pr->next == NULL) break;
                    else (p_pr = p_pr->next);
                }
                p_pr = c_pipe->prs;
                int fd[cnt-1][2];
                for (i = 0; i < cnt - 1; i++){
                    pipe(fd[i]);
                }
                for (i = 0; p_pr && i < cnt; i++){
                    if (p_pr->pr_arr[0] != NULL){
                        if ((p_pr->pid = fork()) < 0){
                            perror("fork ");
                            exit(1);
                        }else if (p_pr->pid == 0){
                            if (i < cnt - 1){
                                dup2(fd[i][1], 1);
                            }
                            if (i > 0){
                                dup2(fd[i-1][0], 0);
                            }
                            for (j = 0; j < cnt - 1; j++){
                                close(fd[j][0]);
                                close(fd[j][1]);
                            }
                            execvp(p_pr->pr_arr[0], p_pr->pr_arr);
                            perror("exec ");
                            _exit(1);
                        }
                        p_pr = p_pr->next;
                        if (p_pr == NULL) break;
                    }else break;
                }
                for (i = 0; i < cnt-1; i++){
                    close(fd[i][0]);
                    close(fd[i][1]);
                }
//////////////////
                c_pr = c_pipe->prs;
                for (i = 0; i < cnt; i++){
                    pid = waitpid(c_pr->pid, &status, 0);
                    if (WIFEXITED(status)){
                        p_pr = c_pipe->prs;
                        while (p_pr){
                            if (p_pr->pid == pid){
                                printf("program \"%s\" has been completed with exit status: %d\n", p_pr->pr_arr[0], WEXITSTATUS(status));
                                if (c_pr->next == NULL){
                                    printf("pipe \"%s\" has been completed with exit status: %d\n", c_pipe->line, WEXITSTATUS(status));
                                }
                                break;
                            }else{
                                p_pr = p_pr->next;
                            }if (p_pr == NULL){
                                printf("there aren't process with pid == %d\n", (int)pid);
                                break;
                            }
                        }
                    }else{
                        p_pr = c_pipe->prs;
                        while (p_pr){
                            if (p_pr->pid == pid){
                                printf("program \"%s\" hasn't been completed\n", p_pr->pr_arr[0]);
                                if (c_pr->next == NULL){
                                    printf("pipe \"%s\" hasn't been completed\n", p_pipe->line);
                                }
                                break;
                            }else{
                                p_pr = p_pr->next;
                            }
                            if (p_pr == NULL){
                                printf("there aren't process with pid == %d\n", (int)pid);
                                break;
                            }
                        }
                    }
                    c_pr = c_pr->next;
                }
///////////////////
                /*  DELETE USED MEMORY  */

                if (c_pipe){
                    if (c_pipe->line)
                        free(c_pipe->line);
                    p_pr = c_pipe->prs;
                    while (p_pr){
                        for (i = 0; p_pr->pr_arr[i] != NULL; i++){
                            if (p_pr->pr_arr[i])
                                free((p_pr->pr_arr[i]));
                        }
                        if (p_pr->pr_arr)
                            free(p_pr->pr_arr);
                        c_pipe->prs = p_pr->next;
                        if (p_pr)
                            free(p_pr);
                        p_pr = c_pipe->prs;
                    }
                    c_pipe = NULL;
                }
///////////////////////////////
            }else{
            /*  BACKGROUND MODE */
                printf("backgroung mode\n");
                int cnt = 0;
                p_pr = c_pipe->prs;
                while (p_pr){
                    cnt++;
                    if (p_pr->next == NULL) break;
                    else (p_pr = p_pr->next);
                }
                p_pr = c_pipe->prs;
                int fd[cnt-1][2];
                for (i = 0; i < cnt - 1; i++){
                    pipe(fd[i]);
                }
                for (i = 0; p_pr && i < cnt; i++){
                    if (p_pr->pr_arr[0] != NULL){
                        if ((p_pr->pid = fork()) < 0){
                            perror("fork ");
                            exit(1);
                        }else if (p_pr->pid == 0){
                            if (i < cnt - 1){
                                dup2(fd[i][1], 1);
                            }
                            if (i > 0){
                                dup2(fd[i-1][0], 0);
                            }
                            for (j = 0; j < cnt - 1; j++){
                                close(fd[j][0]);
                                close(fd[j][1]);
                            }
                            execvp(p_pr->pr_arr[0], p_pr->pr_arr);
                            perror("exec ");
                            _exit(1);
                        }
                        p_pr = p_pr->next;
                        if (p_pr == NULL) break;
                    }else break;
                }
                for (i = 0; i < cnt-1; i++){
                    close(fd[i][0]);
                    close(fd[i][1]);
                }
            }
    printf("Please input pipe\n");
    }
    /*  WAIT BACK PROCESSES AND FREE ALL PIPES  */
    p_pipe = pipes->next;
    while (p_pipe){
        p_pr = p_pipe->prs;
        while (p_pr){
            pid = waitpid(p_pr->pid, &status, 0);
            if (WIFEXITED(status)){
                while (p_pr){
                    if (p_pr->pid == pid){
                        printf("program \"%s\" has been completed with exit status: %d\n", p_pr->pr_arr[0], WEXITSTATUS(status));
                        if (p_pr->next == NULL){
                            printf("pipe \"%s\" has been completed with exit status: %d\n", p_pipe->line, WEXITSTATUS(status));
                        }
                    }else{
                        p_pr = p_pr->next;
                    }if (p_pr == NULL){
                        printf("there aren't process with pid == %d\n", (int)pid);
                    }
                    if (p_pr){
                        p_pr = p_pr->next;
                    }
                }
            }else{
                p_pr = c_pipe->prs;
                while (p_pr){
                    if (p_pr->pid == pid){
                        printf("program \"%s\" hasn't been completed\n", p_pr->pr_arr[0]);
                        if (p_pr->next == NULL){
                            printf("pipe \"%s\" hasn't been completed\n", p_pipe->line);
                        }
                    }else{
                        p_pr = p_pr->next;
                    }
                    if (p_pr == NULL){
                        printf("there aren't process with pid == %d\n", (int)pid);
                    }
                    if (p_pr){
                        p_pr = p_pr->next;
                    }
                }
            }
            if (p_pr){
                p_pr = p_pr->next;
            }
        }
        if (p_pipe){
            p_pipe = p_pipe->next;
        }
    }
    /*  DELETE PIPES WITHOUT PRS    */
    p_pipe = pipes->next;
    while (p_pipe){
        if (p_pipe->prs == NULL){
            if (pipes->next == p_pipe){
                pipes->next = p_pipe->next;
                if (p_pipe)
                    free(p_pipe);
                p_pipe = pipes->next;
            }else{
                c_pipe = pipes->next;
                while (c_pipe->next != p_pipe && c_pipe != NULL){
                    c_pipe = c_pipe->next;
                }
                c_pipe->next = p_pipe->next;
                if (p_pipe)
                    free(p_pipe);
                p_pipe = c_pipe;
            }
        }else{
            p_pipe = p_pipe->next;
        }
        if (p_pipe){
            p_pipe = p_pipe->next;
        }
    }
    /*  DELETE ALL PIPES    */
    p_pipe = pipes;
    while (p_pipe->next){
        if (p_pipe->next->prs){
            p_pr = p_pipe->prs;
            while (p_pr){
                for (i = 0; p_pr->pr_arr[i] != NULL; i++){
                    if (p_pr->pr_arr[i])
                        free((p_pr->pr_arr[i]));
                }
                if (p_pr->pr_arr)
                    free(p_pr->pr_arr);
                p_pipe->next->prs = p_pr->next;
                if (p_pr)
                    free(p_pr);
                p_pr = p_pipe->next->prs;
            }
        }
        p_pipe = p_pipe->next;
    }
    if (pipes)
        free(pipes);
    return 0;
}