叉+管问题

Question

我有一个简单的程序即时通讯使用叉子和管道进行学习的问题。 我想要一个发送一些数据给父母的孩子，并且这个（父母）再次发送给孩子。

结果是，父母的行为就像管道是非阻塞的，并且如果管道阻塞，则子行为。但我没有使用任何代码来告诉管道根本没有阻塞。

让我告诉它：

#include <sys/types.h> 
#include <sys/stat.h> 
#include <sys/wait.h> 
#include <unistd.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <fcntl.h> 
#include <conio.h> 

void WriteStr(char* inStr) 
{ 
    write(1,inStr,strlen(inStr)); 
} 

int main(void){ 

    char *cad1 = "Introdueix un valor: "; 
int bytesr = 0; 
char valor[256]; 

//Un pipe serveix solament per una comunicació unidereccional, 
//si es necessari que pare i fill es comuniquin en amdos sentits, 
//s'hauran d'utilitzar dos pipes. 

int pip_fill[2]; //pip_fp[0]: file descriptor de lectura 
       //pip_fp[1]: file descriptor d'escriptura 

int pip_pare[2]; //pip_pf[0]: file descriptor de lectura 
       //pip_pf[1]: file descriptor d'escriptura 
int pid, nbytes = 0; 
char cad[256]; 
int num = 0; 

if (pipe (pip_fill)<0){ 
    write (1,"Pipe error!!!!\n",15); 
    exit (1); 
} 

if (pipe (pip_pare)<0){ 
    write (1,"Pipe error!!!!\n",15); 
    exit (1); 
} 

fflushnou(); 

pid = fork(); 
switch (pid){ 
    case -1:  
      //Error 
      write (2,"Tractar_Valor: Error!!!!\n",25); 
      exit (-1); 
    case 0: 
      //Fill 
      //printf("Fill: fp[0]:%d fp[1]:%d pf[0]:%d pf[1]:%d \n",pip_fp[0],pip_fp[1],pip_pf[0],pip_pf[1]); 
      close(pip_fill[0]); 
       close(pip_pare[1]); 

      while(1){ 
       bytesr = read(0, valor, 256); 

       valor[bytesr] = '\0'; 

       write(pip_fill[1],valor,strlen(valor)); //el fill escriu a la pipe la var valor 

       WriteStr("Fill avans\n"); 
       nbytes = read(pip_pare[0],cad,strlen(cad)); //el fill llegeix de la pipe la var un cop ha estat tractada per el pare 
       WriteStr("Fill despres\n"); 

       if (nbytes != 0){ //vol dir que hem llegit algo per la pipe pip_pf 
        write(1,cad,strlen(cad)); //pintem cad per pantalla 
       } 

       sleep(1); 
      } 
    default: 
      //Pare 
      close(pip_fill[1]); 
      close(pip_pare[0]); 
      close(0); 

      while(1){ 

       nbytes = read(pip_fill[0],valor,strlen(valor));//el pare llegeix de la pipe la var valor 
       //WriteStr("Pare despres\n"); 
       if (nbytes != 0){ //vol dir que hem llegit algo per la pipe pip_fp 
        //tractem la variable valor 
        num = atoi(valor); 
        num = num*2; 

        sprintf(cad,"Valor actual de la variable: %d \n\n",num); 

        write(1,cad,strlen(cad)); 

        write(pip_pare[1],cad,strlen(cad)); //el pare escriu a la pipe la var tractada 
       } 

       sleep(1); 
      } 
} 
return 0; 
} 

的实际行为是孩子接受输入，然后stucks阅读 'pip_pare [0]'。同时，父进程正在循环读取，并且始终从'pip_fill [0]'读取值为0.

所以，我对此有点困惑，为什么父母正在读取和循环，读'功能？

任何建议来解决它？

感谢您的帮助:)

LLORENS

Answer 1

nbytes = read(pip_pare[0],cad,strlen(cad)); 

我想你可能是指sizeof(cad)这里。

write(1,cad,strlen(cad)); 

and nbytes here。

nbytes = read(pip_fill[0],valor,strlen(valor)); 

而这个沿着类似的路线，但这个版本中有一个隐藏的陷阱，我将作为一个练习离开！

Answer 2

发送可变长度数据时，最好先发送长度（固定长度的整数），以便接收者知道要请求多少数据。