SHARE
TWEET

Untitled

romko11l Nov 19th, 2019 77 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/wait.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <sys/stat.h>
  8. #include <fcntl.h>
  9. #include <signal.h>
  10.  
  11.  
  12.  
  13. const int n = 5; // на сколько элементов выделится память (символов) при заполнении строки (read_line) (не делать меньше 3)
  14. const int m = 5; // на сколько элементов (символов) выделится память в функции strtok
  15. const int t = 5; // на сколько строк выделится память в функции parcer
  16.  
  17. void freedom (char **base)
  18. {
  19.     int pos=0;
  20.     while (base[pos])
  21.     {
  22.         free(base[pos]);
  23.         pos++;
  24.     }
  25.     free(base);
  26. }
  27.  
  28. void Sighndlr ()
  29. {
  30.     printf("Не удалось запустить программу\n");
  31. }
  32.  
  33. char *read_line(int fd, int *check) // в check-е вернется 1, если в строке обнаружен EOF; num_quotes - число кавычек
  34. {
  35.     int pos=0, size;
  36.     char *str, *temp, c, k;
  37.     size=n;
  38.     str=malloc(sizeof(char)*size);
  39.     *check=0;
  40.    
  41.     if (!str)
  42.     {
  43.         printf("memory allocation error\n");
  44.         exit(1);
  45.     }
  46.    
  47.     while (1)
  48.     {
  49.         k=read(fd,&c,sizeof(char));
  50.         if ((k==0)||(c=='\n'))
  51.         {
  52.             str[pos]='\0';
  53.             if (k==0)
  54.             {
  55.                 *check=1;
  56.             }
  57.             return str;
  58.         }
  59.         else
  60.         {
  61.             str[pos]=c;
  62.             pos++;
  63.         }
  64.    
  65.         if (pos==size)
  66.         {
  67.             size=size+n;
  68.             temp=str;
  69.             str=realloc(str,size*sizeof(char));
  70.             if (!str)
  71.             {
  72.                 free(temp);
  73.                 printf("memory allocation error\n");
  74.                 exit(1);
  75.             }
  76.         }
  77.     }
  78.    
  79. }
  80.  
  81. char *mystrtok (char *line, int *check, int *num) //вернет 1 в случае нахождения конца строки
  82. {
  83.     int size, pos=0, hpos=0, pos1, hpos1;
  84.     char *str, *temp;
  85.     size=m;
  86.     str=malloc(sizeof(char)*size);
  87.     if (!str)
  88.     {
  89.         printf("memory allocation error\n");
  90.         *check=2;
  91.         free(str);
  92.         return NULL;
  93.     }
  94.    
  95.     while (1)
  96.     {
  97.         // Обработка кавычек
  98.         if (line[pos]=='"')
  99.         {
  100.             pos1=pos+1;
  101.             hpos1=hpos;
  102.             while (1)
  103.             {
  104.                 if (line[pos1]=='"')
  105.                 {
  106.                     hpos=hpos1;
  107.                     pos=pos1+1;
  108.                     break;
  109.                 }
  110.                 if ((line[pos1]==EOF)||(line[pos1]=='\0'))
  111.                 {
  112.                     break; // не найдено парной кавычки -> кавычка должна считаться как обычный символ
  113.                 }
  114.                 str[hpos1]=line[pos1];
  115.                 hpos1++;
  116.                 pos1++;
  117.                 if (hpos1==size)
  118.                 {
  119.                     temp=str;
  120.                     size=size+m;
  121.                     str=realloc(str,size*sizeof(char));
  122.                     if (!str)
  123.                     {
  124.                         free(temp);
  125.                         printf("memory allocation error\n");
  126.                         *check=2;
  127.                         return NULL;
  128.                     }
  129.                 }
  130.             }
  131.         }
  132.         // Обработка иных случаев
  133.         if (line[pos]==' ')
  134.         {
  135.             if (hpos==0)
  136.             {
  137.                 pos++;
  138.             }
  139.             else
  140.             {
  141.                 str[hpos]='\0';
  142.                 *check=0;
  143.                 *num=pos; // чтобы в следующий раз отправить в эту функцию другую строку
  144.                 return str;
  145.                
  146.             }
  147.         }
  148.         else
  149.         {
  150.             if (line[pos]=='\0')
  151.             {
  152.                 if (hpos==0)
  153.                 {
  154.                     *check=1;
  155.                     free(str);
  156.                     return NULL;
  157.                 }
  158.                 else
  159.                 {
  160.                     str[hpos]='\0';
  161.                     *check=1;
  162.                     return str;
  163.                 }
  164.             }
  165.             else // обнаружен элемент, который можно записать в строку
  166.             {
  167.                 // Обрабатываем спецсимволы
  168.                 if ((line[pos]=='|')||(line[pos]=='&')||(line[pos]=='>')||(line[pos]=='<')||(line[pos]==';')||(line[pos]==')')||(line[pos]=='('))
  169.                 {
  170.                     if (hpos>0) //до этого уже сформирована строка
  171.                     {
  172.                         str[hpos]='\0';
  173.                         *check=0;
  174.                         *num=pos;
  175.                         return str;
  176.                     }
  177.                     else // строка еще не сформирована (hpos==0)
  178.                     {
  179.                         // |
  180.                         if (line[pos]=='|')
  181.                         {
  182.                             if (line[pos+1]=='|')
  183.                             {
  184.                                 str[0]='|';
  185.                                 str[1]='|';
  186.                                 str[2]='\0';
  187.                                 *check=0;
  188.                                 *num=pos+2;
  189.                                 return str;
  190.                             }
  191.                             else
  192.                             {
  193.                                 str[0]='|';
  194.                                 str[1]='\0';
  195.                                 *check=0;
  196.                                 *num=pos+1;
  197.                                 return str;
  198.                             }
  199.                         }
  200.                         // &
  201.                         if (line[pos]=='&')
  202.                         {
  203.                             if (line[pos+1]=='&')
  204.                             {
  205.                                 str[0]='&';
  206.                                 str[1]='&';
  207.                                 str[2]='\0';
  208.                                 *check=0;
  209.                                 *num=pos+2;
  210.                                 return str;
  211.                             }
  212.                             else
  213.                             {
  214.                                 str[0]='&';
  215.                                 str[1]='\0';
  216.                                 *check=0;
  217.                                 *num=pos+1;
  218.                                 return str;
  219.                             }
  220.                         }
  221.                         // >
  222.                         if (line[pos]=='>')
  223.                         {
  224.                             if (line[pos+1]=='>')
  225.                             {
  226.                                 str[0]='>';
  227.                                 str[1]='>';
  228.                                 str[2]='\0';
  229.                                 *check=0;
  230.                                 *num=pos+2;
  231.                                 return str;
  232.                             }
  233.                             else
  234.                             {
  235.                                 str[0]='>';
  236.                                 str[1]='\0';
  237.                                 *check=0;
  238.                                 *num=pos+1;
  239.                                 return str;
  240.                             }
  241.                         }
  242.                         // <
  243.                         if (line[pos]=='<')
  244.                         {
  245.                             str[0]='<';
  246.                             str[1]='\0';
  247.                             *check=0;
  248.                             *num=pos+1;
  249.                             return str;
  250.                         }
  251.                         // ;
  252.                         if (line[pos]==';')
  253.                         {
  254.                             str[0]=';';
  255.                             str[1]='\0';
  256.                             *check=0;
  257.                             *num=pos+1;
  258.                             return str;
  259.                         }
  260.                         // )
  261.                         if (line[pos]==')')
  262.                         {
  263.                             str[0]=')';
  264.                             str[1]='\0';
  265.                             *check=0;
  266.                             *num=pos+1;
  267.                             return str;
  268.                         }
  269.                         // (
  270.                         if (line[pos]=='(')
  271.                         {
  272.                             str[0]='(';
  273.                             str[1]='\0';
  274.                             *check=0;
  275.                             *num=pos+1;
  276.                             return str;
  277.                         }
  278.                     }
  279.                 }
  280.                 //Если встречен обычный символ
  281.                 str[hpos]=line[pos];
  282.                 hpos++;
  283.                 pos++;
  284.                 if (hpos==size)
  285.                 {
  286.                     temp=str;
  287.                     size=size+m;
  288.                     str=realloc(str,size*sizeof(char));
  289.                     if (!str)
  290.                     {
  291.                         free(temp);
  292.                         printf("memory allocation error\n");
  293.                         *check=2;
  294.                         return NULL;
  295.                     }
  296.                 }
  297.             }
  298.         }
  299.        
  300.     }
  301. }
  302.  
  303. char **parcer (char *line) // последний элемент массива всегда будет иметь значение NULL
  304. {
  305.     int check, pos=0, size=0, strpos=0, hstrpos=0;
  306.     char **base, **temp;
  307.    
  308.     size=t;
  309.     base=malloc(sizeof(char *)*size);
  310.     if (!base)
  311.     {
  312.         printf("memory allocation error\n");
  313.         free(line);
  314.         exit(1);
  315.     }
  316.    
  317.     while(1)
  318.     {
  319.         base[pos]=mystrtok(line+strpos, &check, &hstrpos);
  320.         if (check==2)
  321.         {
  322.             base[pos]=NULL;
  323.             freedom(base);
  324.             exit(1);
  325.         }
  326.         if (check==1)
  327.         {
  328.             if (!base[pos]) // вернулась NULL - парсинг строки завершен
  329.             {
  330.                 return base; //может быть даже такое, что первый элемент этого массива - NULL
  331.             }
  332.             else // вернулась не пустая строка, но обнаружен конец основной строки
  333.             {
  334.                 pos++;
  335.                 if (pos==size)
  336.                 {
  337.                     size=size+1;
  338.                     temp=base;
  339.                     base=realloc(base,size*sizeof(char *));
  340.                     if (!base)
  341.                     {
  342.                         free(temp[pos-1]); // т.к. на новый pos места уже нет
  343.                         temp[pos-1]=NULL;
  344.                         freedom(base);
  345.                         exit(1);
  346.                     }
  347.                 }
  348.                 base[pos]=NULL;
  349.                 return base;
  350.             }
  351.         }
  352.         if (check==0)
  353.         {
  354.             strpos+=hstrpos;
  355.             pos++;
  356.             if (pos==size)
  357.             {
  358.                 size=size+t;
  359.                 temp=base;
  360.                 base=realloc(base,size*sizeof(char *));
  361.                 if (!base)
  362.                 {
  363.                     free(temp[pos-1]); // т.к. на новый pos места уже нет
  364.                     temp[pos-1]=NULL;
  365.                     freedom(base);
  366.                     exit(1);
  367.                 }
  368.             }
  369.         }
  370.     }
  371. }
  372.  
  373. int cd (char *str) // проверка на корректность количества аргументов команды cd производится раньше
  374. {
  375.     int k;
  376.     if (str==NULL) //значит пользователю надо перейти в домашний каталог
  377.     {
  378.         k=chdir(getenv("HOME"));
  379.         if (k==-1)
  380.         {
  381.             printf ("В указанный каталог перейти не удалось\n");
  382.         }
  383.         return k;
  384.     }
  385.     else
  386.     {
  387.         k=chdir(str);
  388.         if (k==-1)
  389.         {
  390.             printf ("В указанный каталог перейти не удалось\n");
  391.         }
  392.         return k;
  393.     }
  394. }
  395.  
  396. int function_call (char **base, int fd[2], int flag) // вернет -1 в случае неудачного fork, -2  в случае неудачного exec
  397. {   // flag=1 говорит о том, что подан последний процесс из конвейера
  398.     // base представляет из себя массив строк, заканчивающийся NULL - ссылкой
  399.     int a;
  400.     if (base[0]==NULL)
  401.     {
  402.         dup2(fd[0],0);
  403.         close(fd[0]);
  404.         close(fd[1]);
  405.         return -2;
  406.     }
  407.     a=fork();
  408.     if (a==-1)
  409.     {
  410.         printf("Не удалось породить процесс\n");
  411.         return (-1);
  412.     }
  413.     if (a>0)
  414.     {
  415.         dup2(fd[0],0);
  416.         close(fd[0]);
  417.         close(fd[1]);
  418.     }
  419.     else
  420.     {
  421.         if (flag!=1)
  422.         {
  423.             dup2(fd[1],1);
  424.         }
  425.         close(fd[1]);
  426.         close(fd[0]);
  427.         a=execvp(base[0],base);
  428.         if (a==-1)
  429.         {
  430.             //printf("Не удалось запустить программу - %s\n",base[0]);
  431.             kill(getppid(),SIGUSR1);
  432.             return -2;
  433.         }
  434.     }
  435.     return 0;
  436. }
  437.  
  438. void all_str_output (char **base)
  439. {
  440.     int pos=0;
  441.     while ((base[pos]))
  442.     {
  443.         printf("%s\n",base[pos]);
  444.         pos++;
  445.     }
  446. }
  447.  
  448. int pipeline (char** base)
  449. {
  450.     int len=0, i=0, j=0, fd[2], k;
  451.     char **lastinstr, *str;
  452.     if ((base[0]!=NULL)&&(strcmp(base[0],"cd")==0))
  453.     {
  454.         if ((base[1]!=NULL)&&(base[2]!=NULL)) //ошибки не случится, т.к. при false в первом условии проверки второго не осуществиться
  455.         {
  456.             printf("cd: Некорректное число аргументов\n");
  457.         }
  458.         else
  459.         {
  460.             cd(base[1]);
  461.         }
  462.         return 0;
  463.     }
  464.     k=fork();
  465.     if (k==-1)
  466.     {
  467.         printf("Породить процесс не удалось\n");
  468.         return -1;
  469.     }
  470.     if (k==0)
  471.     {
  472.         signal(SIGINT,SIG_DFL);
  473.         lastinstr=base;
  474.         while (base[i])
  475.         {
  476.             if (strcmp(base[i],"|")==0)
  477.             {
  478.                 len++;
  479.             }
  480.             i++;
  481.         }
  482.         j=0;
  483.         i=0;
  484.         while (i<len)
  485.         {
  486.             while (strcmp(base[j],"|")!=0)
  487.             {
  488.                 j++;
  489.             }
  490.             i++;
  491.             j++;
  492.             k=pipe(fd);
  493.             if (k==-1)
  494.             {
  495.                 printf("Не удалось установить связь между процессами конвейера\n");
  496.                 return -2;
  497.                 // тут еще надо подумать
  498.             }
  499.             str=base[j-1];
  500.             base[j-1]=NULL;
  501.             k=function_call(lastinstr, fd, 0);
  502.             base[j-1]=str;
  503.             lastinstr=base+j;
  504.             if (k==-2) // возврат в теле сыновнего процесса
  505.             {
  506.                 return -2;
  507.             }
  508.             if (k==-1)
  509.             {
  510.                 while(wait(NULL)!=-1);
  511.                 return -2;
  512.             }
  513.             // k = 0 - всё хорошо
  514.         }
  515.         // на момент выхода из цикла не вызвана последняя программа из конвейера
  516.         k=pipe(fd);
  517.         if (k==-1)
  518.         {
  519.             printf("Не удалось установить связь между процессами конвейера\n");
  520.             return -2;
  521.             // тут еще надо подумать
  522.         }
  523.         k=function_call(lastinstr, fd, 1);
  524.         while(wait(NULL)!=-1);
  525.         return -2;
  526.     }
  527.     wait(NULL);
  528.     return 0;
  529. }
  530.  
  531. // требуем, чтобы перенаправления были последними
  532. int redirection (char **base)
  533. {
  534.     int len=0,fdrd,fdwr,hfd1,hfd2,checkrd=0,checkwr=0,res=0;
  535.     char *str;
  536.     while (base[len]) // кол-во переданных слов
  537.     {
  538.         len++;
  539.     }
  540.     hfd1=dup(1);
  541.     hfd2=dup(0);
  542.     if ((len>=4)&&(strcmp(base[len-2],">>")==0)&&(strcmp(base[len-4],">")==0)&&(strcmp(base[len-3],base[len-1])==0))
  543.     {
  544.         fdwr=open(base[len-1], O_CREAT | O_TRUNC | O_WRONLY | O_EXCL, 0666);
  545.         if (fdwr==-1)
  546.         {
  547.             fdwr=open(base[len-1], O_TRUNC | O_WRONLY); // возможно, файл уже существует
  548.             if (fdwr==-1)
  549.             {
  550.                 printf("Перенаправление вывода организовать не удалось\n");
  551.                 goto jmp;
  552.             }
  553.         }
  554.         checkwr=1;
  555.         dup2(fdwr,1);
  556.         str=base[len-4];
  557.         base[len-4]=NULL;
  558.         res=pipeline(base);
  559.         base[len-4]=str;
  560.         goto jmp;
  561.     }
  562.     if ((len>=4)&&(strcmp(base[len-2],">>")==0)&&(strcmp(base[len-4],"<")==0)&&(strcmp(base[len-3],base[len-1])==0))
  563.     {
  564.         printf("Недопустимая конструкция (входной и выходной файлы совпадают)\n");
  565.         goto jmp;
  566.     }
  567.     if ((len>=4)&&(strcmp(base[len-2],">")==0)&&(strcmp(base[len-4],"<")==0)&&(strcmp(base[len-3],base[len-1])==0))
  568.     {
  569.         printf("Недопустимая конструкция (входной и выходной файлы совпадают)\n");
  570.         goto jmp;
  571.     }
  572.     if ((len>=4)&&(strcmp(base[len-2],"<")==0)&&(strcmp(base[len-4],">")==0)&&(strcmp(base[len-3],base[len-1])==0))
  573.     {
  574.         printf("Недопустимая конструкция (входной и выходной файлы совпадают)\n");
  575.         goto jmp;
  576.     }
  577.     if ((len>=4)&&(strcmp(base[len-2],"<")==0)&&(strcmp(base[len-4],">>")==0)&&(strcmp(base[len-3],base[len-1])==0))
  578.     {
  579.         printf("Недопустимая конструкция (входной и выходной файлы совпадают)\n");
  580.         goto jmp;
  581.     }
  582.     if (len>=2) // потому что ситуация подачи на ввод, например >> text - корректна
  583.     {
  584.         if (strcmp(base[len-2],">")==0)
  585.         {
  586.             fdwr=open(base[len-1], O_CREAT | O_TRUNC | O_WRONLY | O_EXCL, 0666);
  587.             if (fdwr==-1)
  588.             {
  589.                 fdwr=open(base[len-1], O_TRUNC | O_WRONLY); // возможно, файл уже существует
  590.                 if (fdwr==-1)
  591.                 {
  592.                     printf("Перенаправление вывода организовать не удалось\n");
  593.                     goto jmp;
  594.                 }
  595.             }
  596.             checkwr=1;
  597.             dup2(fdwr,1);
  598.         }
  599.         if (strcmp(base[len-2],">>")==0)
  600.         {
  601.             fdwr=open(base[len-1], O_CREAT | O_APPEND | O_WRONLY | O_EXCL, 0666);
  602.             if (fdwr==-1)
  603.             {
  604.                 fdwr=open(base[len-1], O_APPEND| O_WRONLY);
  605.                 if (fdwr==-1)
  606.                 {
  607.                     printf("Перенаправление вывода организовать не удалось\n");
  608.                     goto jmp;
  609.                 }
  610.             }
  611.             checkwr=1;
  612.             dup2(fdwr,1);
  613.         }
  614.         if (strcmp(base[len-2],"<")==0)
  615.         {
  616.             fdrd=open(base[len-1], O_RDONLY);
  617.             if (fdrd==-1)
  618.             {
  619.                 printf("Перенаправление ввода организовать не удалось\n");
  620.                 goto jmp;
  621.             }
  622.             checkrd=1;
  623.             dup2(fdrd,0);
  624.         }
  625.         if (len>=4)
  626.         {
  627.             if ((checkrd==1)||(checkwr==1))
  628.             {
  629.                 if ((checkrd==1)&&(strcmp(base[len-4],">")==0))
  630.                 {
  631.                     fdwr=open(base[len-3], O_CREAT | O_TRUNC | O_WRONLY | O_EXCL, 0666);
  632.                     if (fdwr==-1)
  633.                     {
  634.                         fdwr=open(base[len-3], O_TRUNC | O_WRONLY);
  635.                         if (fdwr==-1)
  636.                         {
  637.                             printf("Перенаправление вывода организовать не удалось\n");
  638.                             goto jmp;
  639.                         }
  640.                     }
  641.                     checkwr=1;
  642.                     dup2(fdwr,1);
  643.                 }
  644.                 if ((checkrd==1)&&(strcmp(base[len-4],">>")==0))
  645.                 {
  646.                     fdwr=open(base[len-3], O_CREAT | O_APPEND | O_WRONLY | O_EXCL, 0666);
  647.                     if (fdwr==-1)
  648.                     {
  649.                         fdwr=open(base[len-3], O_APPEND| O_WRONLY);
  650.                         if (fdwr==-1)
  651.                         {
  652.                             printf("Перенаправление вывода организовать не удалось\n");
  653.                             goto jmp;
  654.                         }
  655.                     }
  656.                     checkwr=1;
  657.                     dup2(fdwr,1);
  658.                 }
  659.                 if ((checkwr==1)&&(strcmp(base[len-4],"<")==0))
  660.                 {
  661.                     fdrd=open(base[len-3], O_RDONLY);
  662.                     if (fdrd==-1)
  663.                     {
  664.                         printf("Перенаправление ввода организовать не удалось\n");
  665.                         goto jmp;
  666.                     }
  667.                     checkrd=1;
  668.                     dup2(fdrd,0);
  669.                 }
  670.                 if ((checkwr==1)&&(checkrd==1))
  671.                 {
  672.                     str=base[len-4];
  673.                     base[len-4]=NULL;
  674.                     res=pipeline(base);
  675.                     base[len-4]=str;
  676.                 }
  677.                 else
  678.                 {
  679.                     str=base[len-2];
  680.                     base[len-2]=NULL;
  681.                     res=pipeline(base);
  682.                     base[len-2]=str;
  683.                 }
  684.             }
  685.             else
  686.             {
  687.                 res=pipeline(base);
  688.             }
  689.         }
  690.         else // меньше 4 слов в команде
  691.         {
  692.             if ((checkrd==1)||(checkwr==1)) // только одно из перенаправлений имело место
  693.             {
  694.                 str=base[len-2];
  695.                 base[len-2]=NULL;
  696.                 res=pipeline(base);
  697.                 base[len-2]=str;
  698.             }
  699.             else // перенаправлений не было
  700.             {
  701.                 res=pipeline(base);
  702.             }
  703.         }
  704.     }
  705.     else // меньше 2 слов в команде
  706.     {
  707.         res=pipeline(base);
  708.     }
  709.     jmp:
  710.     if (checkwr==1)
  711.     {
  712.         dup2(hfd1,1);;
  713.         close(fdwr);
  714.     }
  715.     if (checkrd==1)
  716.     {
  717.         dup2(hfd2,0);
  718.         close(fdrd);
  719.     }
  720.     close(hfd1);
  721.     close(hfd2);
  722.     return res;
  723. }
  724.  
  725. /*
  726. // пока что отказываемся от использования этой функции
  727. int parsing_sequence_of_commands (char **base) // в этой функции потом надо будет реализовывать фоновый режим
  728. {
  729.     int i=0,lastarg=-1;
  730.     char str[2], *hstr;
  731.     str[0]=';';
  732.     str[1]='\0';
  733.     while (base[i]!=NULL)
  734.     {
  735.         if (strcmp(base[i],str)==0)
  736.         {
  737.             hstr=base[i];
  738.             base[i]=NULL;
  739.             if (function_call(base+lastarg+1)==-2)
  740.             {
  741.                 base[i]=hstr;
  742.                 return -1; // возврат при неккоректном exec-е
  743.             } // здесь нужен будет вызов функции, которая продолжит дальнейший разбор
  744.             base[i]=hstr;
  745.             lastarg=i;
  746.         }
  747.         i++;
  748.     }
  749.     if ((lastarg+1)!=i)
  750.     {
  751.         if (function_call(base+lastarg+1)==-2)
  752.         {
  753.             return -1;
  754.         }
  755.     }
  756.     // иначе - пустая команда
  757.     return 0;
  758. } */
  759.  
  760. int main (int argc, char **argv)
  761. {
  762.     signal(SIGINT, SIG_IGN);
  763.     signal(SIGUSR1, Sighndlr);
  764.     int a, check=0, fd;
  765.     char *s, **base;
  766.     if (argc==1)
  767.     {
  768.         fd=dup(0);
  769.     }
  770.     else
  771.     {
  772.         if (argc==2)
  773.         {
  774.             fd=open(argv[1], O_RDONLY);
  775.             check=1;
  776.             if (fd==-1)
  777.             {
  778.                 printf("Нет доступа к файлу\n");
  779.                 return 0;
  780.             }
  781.         }
  782.         else
  783.         {
  784.             printf("Некорректное число аргументов командной строки\n");
  785.             return 0;
  786.         }
  787.     }
  788.     do {
  789.     s=read_line(fd,&a);
  790.     //printf("%d\n",a);
  791.     //printf("\n");
  792.     //printf("%s\n",s);
  793.     base=parcer(s);
  794.     //printf("В массив строк занесены следующие строки\n");
  795.     //all_str_output(base);
  796.     if (redirection(base)==-2)
  797.     { // возврат в сыновний процесс при некорректном exec-е
  798.         freedom(base);
  799.         free(s);
  800.         return 0;
  801.     }
  802.     freedom(base);
  803.     free(s);
  804.     } while (a==0);
  805.     if (check==1)
  806.     {
  807.         close(fd);
  808.     }
  809.     return 0;
  810. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top