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

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <limits.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#define MAXLINE 100

pid_t str_handler(char*);
void handler_client_corrupt(int);
static char* itoa(int);//因为itoa是一个非标准C函数，因此需要自己定义
void del_fifo(void);//退出时将管道删除

int main()
{
        int fd;
        int count = 10;
        int BUF_SIZE;
        pid_t client_id;
//注册 程序退出时执行删除管道
      if(atexit(del_fifo))
      {
            perror("atexit\n");
            exit(1);
      }
#if 1
// 创建一个客户端到服务器共享有命管道,此管道必需不存在
        if(0 != mkfifo("../share_fifo", 0777 ))
        {
                perror("mkfifo\n");
                exit(1);
        }
        fputs("share_fifo has been created\n",stdout);
#endif
//打开管道并设置只读
        fd = open("../share_fifo", O_RDONLY, S_IRUSR|S_IRGRP|S_IROTH);
         if(fd<0)
        {
                perror("open\n");
                exit(1);
        }
//初始化缓存数组
        (MAXLINE > PIPE_BUF) ?  (BUF_SIZE = PIPE_BUF) :  (BUF_SIZE = MAXLINE);
        //原子操作写进fifo最大数据量，若超过会导致进行间的竟争 MAXLINE < PIPE_BUFPIPE_BUF = 4096
        //#define PIPE_BUF     4096
        //usr/lib/limits.h
        char buf[BUF_SIZE];
        memset(buf, sizeof(buf), 0);
//读取数据并进行处理
        while(20)
        {
//读客户端发来的信息内容，并冲洗标准输入出进行显示
                int num;
                num = read(fd, buf, BUF_SIZE);
                if(-1 == num)
                {
                        perror("read\n");
                        exit(1);
                }
                fputs(buf,stdout);
                //由于标准输出需要遇到换行符“\n”才会进行显示，而收到内容中没有换行符，使此函数进行冲洗显示
                putchar('\n');

//回复客户端，并对回复的内容进行处理
                client_id = str_handler(buf);

                //处理回复内容字符串
                char str[100] = "receided successfully:";
                strcat(str,itoa(client_id));
                int len = strlen(str);
                char str_reply[len+1];
                strcpy(str_reply, str);

                //处理客户端路径
                char tmp[100]= "../";
                strcat(tmp,itoa(client_id));
                len = strlen(tmp);
                char path[len+1];
                strcpy(path,tmp);

                //打开对应客户端的管道进行写操作
                int cfd = open(path,O_WRONLY, S_IWUSR|S_IWGRP);
                if(cfd<0)
                {
                        perror("open_1\n");
                        exit(1);
                }
                //回复对应的客户端
                if(write(cfd, str_reply, (strlen(str_reply)+1) ) == -1)
                {
                        perror("write\n");
                        exit(1);
                }
                //写完后关闭对应的管道
                if(close(cfd))
                {
                        perror("close\n");
                        exit(1);
                }
                sleep(1);
        }
      if(close(fd))
      {
            perror("close\n");
            exit(1);
      }

        return 0;
}


pid_t str_handler(char*buf)
{
        pid_t tmp;
        int len = strlen(buf);

        tmp = atoi(buf);
        printf("len :%d tmp:%d,buf:%s\n",len,tmp,buf);
        if( (tmp == 0) || (tmp < 0) )
        {
                return -1;
        }
        return tmp;
}

static char* itoa(int i)
{
      char * local =  (char*) malloc(10);
      memset(local,10,0);
      sprintf(local,"%d",i);
      return local;
}



void del_fifo(void)
{
      if(remove("../share_fifo"))
      {
            perror("remove\n");
            exit(1);
      }
}

client.c

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

#define MAXLINE 100
char buf[MAXLINE];

char tmp[100]= "../";
char* path;

static char* itoa(int i)
{
      char * local =  (char*) malloc(10);
      memset(local,10,0);
      sprintf(local,"%d",i);
      return local;
}

void del_fifo(void)
{
      if(remove(path))
      {
            perror("remove\n");
            exit(1);
      }
}


int main(int argc, char** argv)
{
      int fd0 , fd1;

      int len;

      strcat(tmp,itoa(getpid()));
      len = strlen(tmp);
      char tmp_path[len+1];
      strcpy(tmp_path,tmp);
      path = tmp_path;

      if(0 != mkfifo(path, 0777 ))
      {
            perror("mkfifo\n");
            exit(1);
      }

 #if 0
      fd0 = open("../client0", O_RDONLY, S_IRUSR|S_IRGRP);
      if(fd0<0)
      {
            perror("open_0\n");
            exit(1);
      }
#endif
    //处理回复内容字符串

    char str[10];
    memset(str,10,0);
    strcpy(str,itoa(getpid()));
    len = strlen(str);
    char str_send[len+1];
    strcpy(str_send, str);
    printf("%s\n",str_send);

       fd1 = open("../share_fifo", O_WRONLY, S_IWUSR|S_IWGRP);
      if(fd1<0)
      {
            perror("open_1\n");
            exit(1);
      }

      fd0 = open(path, O_RDONLY|O_NONBLOCK, S_IRUSR|S_IRGRP);
      if(fd0<0)
      {
            perror("open_0\n");
            exit(1);
      }

    int count = 10;
      while(count--)
      {

            if(write(fd1, str_send, (strlen(str_send)+1) ) == -1)
            //if(write(fd1, "test\n", 5 ) == -1)
            {
                  perror("write\n");
                  exit(1);
            }
            fputs("write complete\n",stdout);
          #if 0
            if(close(fd1))
            {
                  perror("close\n");
                  exit(1);
            }
          #endif
            while(read(fd0, buf, MAXLINE)<=0);
            printf("%s\n",buf);
            sleep(1);

      }
      return 0;
}