操作系统第三次实验报告——有名管道(FIFO)

0 个人信息

• 张樱姿
• 201821121038
• 计算1812

1 实验目的

• 掌握进程间通信管道的编程。

2 实验内容

• 在服务器上用VIM编写一个程序：创建一个命名管道，创建两个进程分别对管道进行读(read_fifo.c)和写(write_fifo.c)。给出源代码
• 给出运行结果，并分析

3 实验报告

　　3.1 编写写管道程序（write_fifo.c）

#include<unistd.h>    //write,read,close,access
#include<string.h>    //memset
#include<errno.h>     //errno
#include<fcntl.h>     //open,O_WRONLY,O_RDONLY
#include<stdio.h>     //printf,sscanf
#include<stdlib.h>    //exit
#include<limits.h>    //PIPE_BUF

#define MYFIFO "/tmp/myfifo" //有名管道文件名
#define BUFES PIPE_BUF

int main(int argc,char * argv[])
{
    int fd,n;
    char buff[BUFES];
    
    if(argc <= 1)
    {
        exit(1);
    }
    sscanf(argv[1],"%s",buff);
    //以只写阻塞方式打开FIFO管道
    fd = open(MYFIFO,O_WRONLY);
    if(fd==-1)
    {
        printf("Open fifo error
");
        exit(1);
    }
    //向管道中写入字符串
    if((n = write(fd,buff,BUFES))>0)
    {
        printf("Finish writing '%s' to FIFO
",buff);
    }
    close(fd);
    exit(0);
}

　　3.2 编写读管道程序（read_fifo.c）

#include<unistd.h>    //write,read,close,access
#include<string.h>    //memset
#include<errno.h>     //errno
#include<fcntl.h>     //open,O_WRONLY,O_RDONLY
#include<stdio.h>     //printf,sscanf
#include<stdlib.h>    //exit
#include<limits.h>    //PIPE_BUF

#define MYFIFO "/tmp/myfifo" 
#define BUFES PIPE_BUF

int main()
{
    int fd,n;
    char buff[BUFES];
    //判断有名管道是否已存在
    if(access(MYFIFO,F_OK)==-1)
    {    //若不存在，则创建可读可写的有名管道
        if((mkfifo(MYFIFO,0666)<0)&&(errno != EEXIST))
        {
            printf("Could't create fifo
");
            exit(1);
        }
    }
    //以只读阻塞方式打开有名管道
    fd = open(MYFIFO,O_RDONLY);
    if(fd==-1)
    {
        printf("Open fifo error
");
        exit(1);
    }
    //不停读取管道中的数据，如果没用数据可读，则一直处于阻塞状态
    while(1)
    {
        memset(buff,0,sizeof(buff));
        if((n = read(fd,buff,BUFES))>0)
        {
            printf("Read '%s' from FIFO
",buff);
        }
    }
    close(fd);
    exit(0);
}

　　3.3 运行结果及分析

　　　　为了能够较好地观察运行结果，将两程序分别编译后，把这两个程序分别在两个终端里运行，在这里首先启动读管道程序。读管道进程在建立管道后就开始循环地从管道里读出内容，如果没有数据可读，则一直阻塞到写管道进程向管道写入数据。在启动了写管道程序后，读进程能够从管道里读出用户的输入内容，程序运行结果如下：

 　　　　分析：

　　　　①对于读进程：

　　　　· 若该管道是阻塞打开，且当前FIFO内无数据，则对读进程而言一直阻塞到有数据写入。

　　　　· 若该管道是非阻塞打开，则不论FIFO内是否有数据，都进程都会立即执行读操作。也就是说若FIFO内无数据，那么读程序将立马返回0。

　　　　此处使用的是阻塞方式。

　　　　②对于写进程：

　　　　· 若该管道是阻塞打开，则写进程将一直阻塞到有数据写入。

　　　　· 若该管道是非阻塞打开而不能写入全部数据，则对读进程而言只能进行部分写入或者调用失败。

 　　　　　③管道模式：

　　　　· O_RDONLY:读管道。

　　　　· O_WRONLY:写管道。

　　　　· O_RDWR:读写管道。

　　　　· O_NONBLOCK:非阻塞。

　　　　· O_CREAT:如果该文件不存在，就创建一个新的文件，并使用第3个参数为其设置权限。

　　　　· O_EXCL:测试文件是否存在。如果使用O_CREAT|O_CREAT时文件存在，那么将返回出错：errno == EEXIST。

　　3.4 创建两个有名管道实现聊天程序

　　服务器端程序：

/*Server.c*/
#include<unistd.h>    
#include<string.h>    
#include<errno.h>   
#include<fcntl.h>    
#include<stdio.h>    
#include<stdlib.h>    
#include<limits.h>    

#define WRITE_FIFO "/tmp/readfifo" 
#define READ_FIFO "/tmp/writefifo" 
#define BUFES PIPE_BUF

int main(int argc,char * argv[])
{
    int wfd,rfd,n;
    char buff[BUFES],readbuff[BUFES];
    //创建管道WRITE_FIFO
    mkfifo(WRITE_FIFO, S_IFIFO|0666);
    //以只读阻塞方式打开FIFO管道
    rfd = open(READ_FIFO,O_RDONLY);
    //以只写阻塞方式打开FIFO管道
    wfd = open(WRITE_FIFO,O_WRONLY);
    //不停读取管道中的数据，如果没用数据可读，则一直处于阻塞状态
    while(1){
        memset(readbuff,0,sizeof(readbuff));
        if((n = read(rfd,readbuff,BUFES))>0)
        {
            readbuff[BUFES] = '';
            printf("Client: %s
",readbuff);
        }
        memset(buff,0,sizeof(buff));
        printf("Server: ");
        fgets(buff, BUFES, stdin);
        buff[strlen(buff)-1] = '';

        write(wfd,buff,strlen(buff));
    }
    close(wfd);
    close(rfd);
    exit(0);
}

　　客户端程序：

/*Client.c*/
#include<unistd.h>    
#include<string.h>    
#include<errno.h>   
#include<fcntl.h>    
#include<stdio.h>    
#include<stdlib.h>    
#include<limits.h>    

#define WRITE_FIFO "/tmp/writefifo" 
#define READ_FIFO "/tmp/readfifo" 
#define BUFES PIPE_BUF

int main(int argc,char * argv[])
{
    int wfd,rfd,n;
    char buff[BUFES],readbuff[BUFES];
    //创建管道READ_FIFO
    mkfifo(WRITE_FIFO, S_IFIFO|0666);    
    //以只写阻塞方式打开FIFO管道
    wfd = open(WRITE_FIFO,O_WRONLY);
    //以只读阻塞方式打开FIFO管道
    rfd = open(READ_FIFO,O_RDONLY);
    //不停读取管道中的数据，如果没用数据可读，则一直处于阻塞状态
    while(1)
    {    
        memset(buff,0,sizeof(buff));
        printf("Client: ");
        fgets(buff, BUFES, stdin);
        buff[strlen(buff)-1] = '';

        write(wfd,buff,strlen(buff));
        memset(readbuff,0,sizeof(readbuff));
        if((n = read(rfd,readbuff,BUFES))>0)
        {
            printf("Server: %s
",readbuff);
        }
    }
    close(wfd);
    close(rfd);
    exit(0);
}

　　3.5 运行效果及分析

 　　分析：在这里首先启动客户端程序，再启动服务器端程序。客户端在建立管道后，首先写入数据到管道中，接着数据传递到服务器端，然后服务器端将数据写入管道中，再传递到客户端，如此往复循环。如果没有数据可读，则一直阻塞到写管道进程向管道写入数据。

4 References

• https://blog.csdn.net/ccskyer/article/details/24989961
• https://blog.csdn.net/MONKEY_D_MENG/article/details/5570468
• https://blog.csdn.net/CSDN_LQR/article/details/52170717