API tools faq
paste
Advertisement
romko11l

Untitled

romko11l
Nov 19th, 2019
169
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 18.12 KB | None | 0 0
raw download clone embed print report
  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.     signal(SIGINT,SIG_DFL);
  453.     if ((base[0]!=NULL)&&(strcmp(base[0],"cd")==0))
  454.     {
  455.         if ((base[1]!=NULL)&&(base[2]!=NULL)) //ошибки не случится, т.к. при false в первом условии проверки второго не осуществиться
  456.         {
  457.             printf("cd: Некорректное число аргументов\n");
  458.         }
  459.         else
  460.         {
  461.             cd(base[1]);
  462.         }
  463.         return 0;
  464.     }
  465.     k=fork();
  466.     if (k==-1)
  467.     {
  468.         printf("Породить процесс не удалось\n");
  469.         return -1;
  470.     }
  471.     if (k==0)
  472.     {
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!