阿坝州网站建设公司

unix无关系进程间通信-有名管道

  1. 有名管道是专用于无关系进程间的通信
  2. open("../share_fifo", O_RDONLY, 777); 这个以只读打开有名管道，会产生阻塞,直到有其它进程以写打开才会继续执行下去
  3. open("../share_fifo", O_RDONLY|O_NONBLOCK, 777); 这个以只读且注明以非阻塞打开，open不会产生阻塞，导致read()函数对有无数据读完即离开
  4. open(fifo,O_WRONLY, 777) 阻塞到其它进行以读打开这个管道
  5. open(fifo,O_WRONLY|O_NONBLOCK, 777) 没有阻塞，如果没有其它进行以读打开管道会立即返回报错-1 ENXIO
  6. 写一个无读打开的管道会产生一个信号 SIGPIPE，可以捕捉以信号来进行后续处理
  7. 此例程，功能为一个服务进程 与 多个客户进程之间的通信
  8. 程序还需要进行一步完美

server.c

成都创新互联成立于2013年，先为香洲等服务建站，香洲等地企业，进行企业商务咨询服务。为香洲企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

  1. #include  
  2. #include  
  3. #include  
  4. #include  
  5. #include  
  6. #include  
  7. #include  
  8. #include  
  9. #include  
  10. #include  
  11.  
  12. #define MAXLINE 100 
  13.  
  14. pid_t str_handler(char*); 
  15. void handler_client_corrupt(int); 
  16. static char* itoa(int);//因为itoa是一个非标准C函数，因此需要自己定义 
  17. void del_fifo(void);//退出时将管道删除 
  18.  
  19. int main() 
  20. { 
  21.         int fd; 
  22.         int count = 10; 
  23.         int BUF_SIZE; 
  24.         pid_t client_id; 
  25. //注册 程序退出时执行删除管道 
  26.       if(atexit(del_fifo)) 
  27.       { 
  28.             perror("atexit\n"); 
  29.             exit(1);          
  30.       } 
  31. #if 1 
  32. // 创建一个客户端到服务器共享有命管道,此管道必需不存在  
  33.         if(0 != mkfifo("../share_fifo", 0777 )) 
  34.         { 
  35.                 perror("mkfifo\n"); 
  36.                 exit(1); 
  37.         } 
  38.         fputs("share_fifo has been created\n",stdout); 
  39. #endif 
  40. //打开管道并设置只读 
  41.         fd = open("../share_fifo", O_RDONLY, S_IRUSR|S_IRGRP|S_IROTH); 
  42.          if(fd<0) 
  43.         { 
  44.                 perror("open\n"); 
  45.                 exit(1);                
  46.         }  
  47. //初始化缓存数组 
  48.         (MAXLINE > PIPE_BUF) ?  (BUF_SIZE = PIPE_BUF) :  (BUF_SIZE = MAXLINE); 
  49.         //原子操作写进fifo最大数据量，若超过会导致进行间的竟争 MAXLINE < PIPE_BUFPIPE_BUF = 4096 
  50.         //#define PIPE_BUF     4096 
  51.         //usr/lib/limits.h 
  52.         char buf[BUF_SIZE]; 
  53.         memset(buf, sizeof(buf), 0); 
  54. //读取数据并进行处理 
  55.         while(20) 
  56.         {      
  57. //读客户端发来的信息内容，并冲洗标准输入出进行显示 
  58.                 int num;   
  59.                 num = read(fd, buf, BUF_SIZE); 
  60.                 if(-1 == num) 
  61.                 { 
  62.                         perror("read\n"); 
  63.                         exit(1);                       
  64.                 } 
  65.                 fputs(buf,stdout); 
  66.                 //由于标准输出需要遇到换行符“\n”才会进行显示，而收到内容中没有换行符，使此函数进行冲洗显示 
  67.                 putchar('\n'); 
  68.                  
  69. //回复客户端，并对回复的内容进行处理                
  70.                 client_id = str_handler(buf); 
  71.                  
  72.                 //处理回复内容字符串 
  73.                 char str[100] = "receided successfully:"; 
  74.                 strcat(str,itoa(client_id)); 
  75.                 int len = strlen(str); 
  76.                 char str_reply[len+1]; 
  77.                 strcpy(str_reply, str); 
  78.                  
  79.                 //处理客户端路径 
  80.                 char tmp[100]= "../"; 
  81.                 strcat(tmp,itoa(client_id)); 
  82.                 len = strlen(tmp); 
  83.                 char path[len+1]; 
  84.                 strcpy(path,tmp); 
  85.             
  86.                 //打开对应客户端的管道进行写操作 
  87.                 int cfd = open(path,O_WRONLY, S_IWUSR|S_IWGRP); 
  88.                 if(cfd<0) 
  89.                 { 
  90.                         perror("open_1\n"); 
  91.                         exit(1);                
  92.                 } 
  93.                 //回复对应的客户端             
  94.                 if(write(cfd, str_reply, (strlen(str_reply)+1) ) == -1) 
  95.                 { 
  96.                         perror("write\n"); 
  97.                         exit(1);                
  98.                 } 
  99.                 //写完后关闭对应的管道 
  100.                 if(close(cfd)) 
  101.                 { 
  102.                         perror("close\n"); 
  103.                         exit(1);                   
  104.                 } 
  105.                 sleep(1); 
  106.         } 
  107.       if(close(fd)) 
  108.       { 
  109.             perror("close\n"); 
  110.             exit(1);                   
  111.       }        
  112.         
  113.         return 0; 
  114. } 
  115.  
  116.  
  117. pid_t str_handler(char*buf) 
  118. { 
  119.         pid_t tmp;  
  120.         int len = strlen(buf); 
  121.          
  122.         tmp = atoi(buf); 
  123.         printf("len :%d tmp:%d,buf:%s\n",len,tmp,buf); 
  124.         if( (tmp == 0) || (tmp < 0) ) 
  125.         { 
  126.                 return -1; 
  127.         } 
  128.         return tmp; 
  129. } 
  130.  
  131. static char* itoa(int i) 
  132. { 
  133.       char * local =  (char*) malloc(10); 
  134.       memset(local,10,0); 
  135.       sprintf(local,"%d",i); 
  136.       return local; 
  137. } 
  138.  
  139.  
  140.  
  141. void del_fifo(void) 
  142. { 
  143.       if(remove("../share_fifo")) 
  144.       { 
  145.             perror("remove\n"); 
  146.             exit(1);     
  147.       } 
  148. } 


client.c

  1. #include  
  2. #include  
  3. #include  
  4. #include  
  5. #include  
  6. #include  
  7. #include  
  8.  
  9. #define MAXLINE 100 
  10. char buf[MAXLINE]; 
  11.  
  12. char tmp[100]= "../"; 
  13. char* path; 
  14.  
  15. static char* itoa(int i) 
  16. { 
  17.       char * local =  (char*) malloc(10); 
  18.       memset(local,10,0); 
  19.       sprintf(local,"%d",i); 
  20.       return local; 
  21. } 
  22.  
  23. void del_fifo(void) 
  24. { 
  25.       if(remove(path)) 
  26.       { 
  27.             perror("remove\n"); 
  28.             exit(1);     
  29.       } 
  30. } 
  31.  
  32.  
  33. int main(int argc, char** argv) 
  34. { 
  35.       int fd0 , fd1; 
  36.        
  37.       int len; 
  38.             
  39.       strcat(tmp,itoa(getpid())); 
  40.       len = strlen(tmp); 
  41.       char tmp_path[len+1]; 
  42.       strcpy(tmp_path,tmp); 
  43.       path = tmp_path; 
  44.             
  45.       if(0 != mkfifo(path, 0777 )) 
  46.       { 
  47.             perror("mkfifo\n"); 
  48.             exit(1); 
  49.       }   
  50.        
  51.  #if 0         
  52.       fd0 = open("../client0", O_RDONLY, S_IRUSR|S_IRGRP); 
  53.       if(fd0<0) 
  54.       { 
  55.             perror("open_0\n"); 
  56.             exit(1);                
  57.       }       
  58. #endif        
  59.     //处理回复内容字符串 
  60.     
  61.     char str[10]; 
  62.     memset(str,10,0); 
  63.     strcpy(str,itoa(getpid())); 
  64.     len = strlen(str); 
  65.     char str_send[len+1]; 
  66.     strcpy(str_send, str); 
  67.     printf("%s\n",str_send); 
  68.      
  69.        fd1 = open("../share_fifo", O_WRONLY, S_IWUSR|S_IWGRP); 
  70.       if(fd1<0) 
  71.       { 
  72.             perror("open_1\n"); 
  73.             exit(1);                
  74.       } 
  75.  
  76.       fd0 = open(path, O_RDONLY|O_NONBLOCK, S_IRUSR|S_IRGRP); 
  77.       if(fd0<0) 
  78.       { 
  79.             perror("open_0\n"); 
  80.             exit(1);                
  81.       } 
  82.              
  83.     int count = 10; 
  84.       while(count--) 
  85.       { 
  86.  
  87.             if(write(fd1, str_send, (strlen(str_send)+1) ) == -1) 
  88.             //if(write(fd1, "test\n", 5 ) == -1) 
  89.             { 
  90.                   perror("write\n"); 
  91.                   exit(1);                
  92.             } 
  93.             fputs("write complete\n",stdout);   
  94.           #if 0   
  95.             if(close(fd1)) 
  96.             { 
  97.                   perror("close\n"); 
  98.                   exit(1);                   
  99.             }   
  100.           #endif   
  101.             while(read(fd0, buf, MAXLINE)<=0); 
  102.             printf("%s\n",buf);  
  103.             sleep(1);   
  104.              
  105.       } 
  106.       return 0; 
  107. } 

 

附件：http://down.51cto.com/data/2362203

分享文章：unix无关系进程间通信-有名管道
本文URL：http://azwzsj.com/article/pisodh.html

其他资讯