title: Unnamed Pipes in UNIX child message doesn't get received by father while sending a string in C
body: <p>I have two processes that I have created with two unnamed pipes, but I can't figure out why I can't send messages from the sons to the father. It appears that the father doesn't receive the string. The son is sending the right string; it just doesn't reach destination, can't figure out why ...
  Can you explain to me?</p>
  
  <pre><code>#include &lt;unistd.h&gt;
  #include &lt;sys/wait.h&gt;
  #include &lt;sys/types.h&gt;
  #include &lt;stdio.h&gt;
  #include &lt;strings.h&gt;
  #include &lt;sys/stat.h&gt;
  #include &lt;fcntl.h&gt;
  #include &lt;errno.h&gt;
  #include &lt;time.h&gt;
  
      #define max_chars_string 1000
      #define n_childs 2
  
      pid_t childs[n_childs];
      int channel[n_childs][2];
  
      void read_lines(char * filename, char (*pointer)[max_chars_string],int init_read,int n_lines);
      void get_strings_hash(char (*pointer_strings)[max_chars_string],char (*pointer_hashes)[max_chars_string],int total_lines);
  
      void worker(int mypipe,char filename[],int n_lines){ // meter as funcoes de ler passwords no filho
          int resources[2];// numero de linhas que cada processo tem de ler
          int i = 0;
  
          //definicao arrays
          char strings_hashes[n_lines][max_chars_string];//aray de string com as strings lidas do ficheiro
              char * pointer_strings = &amp;strings_hashes[0][0];//ponteiro para o inicio do array das hashes
  
          read_lines(filename,strings_hashes,0,n_lines); // le as strings do ficheiro e passa para o array
  
          for(i = 0;i&lt;n_lines;i++){
              printf("%s \n",strings_hashes[i]);
          }
          printf("[%d] My parent is: %d\n", getpid(), getppid());
  
          //open pipe to write and close pipe to read
  
          close(channel[mypipe][0]);
          i = 0;
          int incr = 0;
          while (i&lt;n_lines) {
              printf("[Son] Password sent e  %s: \n",strings_hashes[incr]);
               write(channel[mypipe][1], strings_hashes[incr], strlen(strings_hashes[incr]));
               incr++;
               i++;
          }
          exit(0);
      }
  
      int main(int argc, char **argv)
      {
          char *filename;
          int status;//status do processos filho
          int resources[2];// numero de linhas que cada processo tem de ler
          int n_lines; //numero de linhas do ficheiro
          int i = 0;
  
            // Create a pipe
          filename = (char*)malloc(strlen(argv[1])*sizeof(char)+1);
  
          if(argc !=3){
              fprintf(stderr, "Usage : %s [text_file] [cores]",argv[0]);
              exit(0);
          }
  
          strcpy(filename,argv[1]);
  
          char get_file [strlen(filename)];
          strcpy(get_file,filename);
  
       // start the processes
         for(i = 0; i &lt;atoi(argv[2]);i++){
              pipe(channel[i]);
              childs[i] = fork();
  
              if(childs[i] == -1){
                 perror("Failed to fork");
                 return 1;
             }
             if (childs[i] == 0)
             {
                worker(i,get_file,n_lines);
             }
             close(channel[i][1]);
         }
  
                 i = 0;
                 int k = 0;
                 int fd;
                 fd_set read_set;
                 FD_ZERO(&amp;read_set);
                 char string_lida [30];
  
                 // working father
                 printf("[%d] I'm the father!\n", getpid());
                 printf("[Father]orking ...\n");
  
                  //unammed_pipes connection
                  while(k&lt;n_childs){
  
                      FD_SET(channel[0][0], &amp;read_set);
                      for(i=0;i&lt;n_childs;i++){
                              FD_SET(channel[i][0], &amp;read_set);
                              if(fd&lt;channel[i][0]){      fd=channel[i][0];
                              }
                          }
  
                      if(select(fd+1,&amp;read_set,NULL,NULL,NULL)&gt;0){
                          for(i=0;i&lt;n_childs;i++){
                              if(FD_ISSET(channel[i][0], &amp;read_set)){                    
                                  read(channel[i][0],string_lida,strlen(string_lida));
                                  printf("[Father]pipe %d - string lida:%s\n",i,string_lida);
  
                                  k++;                 
                              }
                          }
                      }
                      fd=1;
                  }
                //
                //waiting for childs ...
              for(i=0;i&lt;n_childs;i++){
                  wait(&amp;status);
                  printf("waiting for childs \n");
                }
  
        return 0;
      }  
  
  
      void get_strings_hash(char (*pointer_strings)[max_chars_string],char (*pointer_hashes)[max_chars_string],int total_lines)//vai ao array de strings e corta a parte de hash e mete num array
      {
          int i = 0;
          char *strings;
          char *hash;
  
          for(i = 0;i&lt;total_lines;i++){
                  strings = (char*)malloc(strlen(pointer_strings)*sizeof(char)+1);
                  strcpy(strings,*pointer_strings);
                  hash = (char*)malloc(strlen(pointer_strings)*sizeof(char)+1);
                  find_hash(strings,hash);
                  strcpy(*pointer_hashes,hash);
              pointer_hashes++;
              pointer_strings++;
          }
  
      }
  
  
      void read_lines(char * filename, char (*pointer)[max_chars_string],int init_read,int n_lines){ 
          FILE *fp;
          char str[max_chars_string];
          int i =0;
  
          if((fp = fopen(filename, "r"))==NULL) {
            printf("Cannot open file.\n");
            exit(1);
          }
  
          if(init_read&gt;0 &amp;&amp; init_read&lt;=n_lines){
           for(i = 0;i&lt;init_read;i++){
               fgets(str, sizeof str, fp);
             for(i = init_read;i&lt;n_lines;i++){
                 fgets(str, sizeof str, fp);
                 strcpy(*pointer, str); //copia para a posicao actula do ponteiro
                 pointer++;
             }
           }
          }
          if(init_read&lt;=n_lines &amp;&amp; init_read==0){
             for(i = init_read;i&lt;n_lines;i++){
                  fgets(str, sizeof str, fp);
                 strcpy(*pointer, str); //copia para a posicao actula do ponteiro
                 pointer++;
             }
           }
  
  
        fclose(fp);
      }
  </code></pre>