Chinaunix首页 | 论坛 | 博客

淘米挣＊博文精选yourtommy.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

yourtommy

  • 博客访问： 1797975
  • 博文数量： 438
  • 博客积分： 9799
  • 博客等级： 中将
  • 技术积分： 6092
  • 用 户 组： 普通用户
  • 注册时间： 2012-03-25 17:25
文章分类

全部博文（438）

文章存档

2019年（1）

2013年（8）

2012年（429）

我的朋友
最近访客
推荐博文
相关博文
第十七章＊高级IPC（五）－－一个打开服务器，版本1（An Open Server，Version 1）

分类： 系统运维

2012-04-03 13:50:19

使用文件描述符的传递，我们现在开发一个打开服务器：一个被一个进程执行来打开一个或多个文件的程序。但是服务器并非把文件内容发送回给调用进程， 而是把一个打开文件的描述符发送回去。这让服务器可以和任何类型的文件一起工作（比如一个设备或一个套接字）而不是简单的普通文件。它也意味着使用IPC 交换最少的信息：客户向服务器文件名和打开模式，服务器向客户返回描述符。文件的内容没有使用IPC交换。


把服务器设计为独立的应用程序（或者是被客户执行的程序，如我们在本节开发的，或者是一个我们在下节开发的守护进程）有几个好处。


1、服务器可以简单地被任何客户联系，和客户服用一个库函数相似。我们不在应用里硬编码一个特定的服务，而是设计其它人可以使用的通用设施。


2、如果我们需要改变服务器，只有一个程序被影响。相比之下，更新一个库函数可能要求所有调用这个函数的程序都要被更新（也就是说，用链接器重链接）。共享库可以简化这个更新（7.7节）。


3、服务器可以是一个设置用户ID程序，提供它一个客户没有的额外权限。注意一个库函数（或共享库函数）不能提供这种能力。


客户进程创建一个s-pipe（一个基于STREAMS的管道或一个UNIX域套接字对）然后调用fork和exec来调用这个服务器。客户通过s-pipe发送请求，服务器通过s-pipe发回响应。


1、客户通过s-pipe向服务器发送一个形式为“open \0”的请求。是以ASCII十进制形式的open函数的第二个参数的数值。这个请求由一个空字节终止。


2、服务器发送回一个打开的描述符或一个错误，通过调用send_fd或send_err。


这是一个进程发送给它的父进程一个打开描述符的一个例子。在17.6节，我们将修改这个例子来使用单个守护服务器，这里服务器把一个描述符发送给一个完全无关的进程。


我们首先有头文件，open.h（下面的代码），它包含标准头文件并定义函数原型。



  1. #include <errno.h>

  3. #define CL_OPEN "open" /* client's request for server */

  5. int csopen(char *, int);


 main函数（下面的代码）是一个循环，从标准输出读取输入并把文件拷贝到标准输出。这个函数调用csopen来联系打开的服务器并返回一个打开的描述符。


  1. #include <fcntl.h>
  2. #include <stdio.h>
  3. #include <unistd.h>

  5. #define BUFFSIZE 8192
  6. #define MAXLINE 4096

  8. int
  9. main(int argc, char *argv[])
  10. {
  11.     int n, fd;
  12.     char buf[BUFFSIZE], line[MAXLINE];
  13.     
  14.     /* read filename to cat from stdin */
  15.     while (fgets(line, MAXLINE, stdin) != NULL) {
  16.         if (line[strlen(line) - 1] == '\n')
  17.             line[strlen(line) - 1] = 0; /* replace newline with null */

  19.         /* open the file */
  20.         if ((fd = csopen(line, O_RDONLY)) < 0)
  21.             continue; /* csopen() prints error from server */

  23.         /* and cat to stdout */
  24.         while ((n = read(fd, buf, BUFFSIZE)) > 0)
  25.             if (write(STDOUT_FILENO, buf, n) != n) {
  26.                 printf("write error\n");
  27.                 exit(1);
  28.             }

  30.         if (n < 0) {
  31.             printf("read error\n");
  32.             exit(1);
  33.         }
  34.         close(fd);
  35.     }
  36.     exit(0);
  37. }


函数csopen（下面的代码）执行服务器的fork和exec，在创建s-pipe之后。


  1. #include "open.h"
  2. #include <sys/uio.h> /* struct iovec */
  3. #include <fcntl.h>
  4. #include <unistd.h>

  6. /*
  7.  * Open the file by sending the "name" and "oflag" to the
  8.  * connection server and reading a file descriptor back.
  9.  */
  10. int
  11. csopen(char *name, int oflag)
  12. {
  13.     pid_t pid;
  14.     int len;
  15.     char buf[10];
  16.     struct iovec iov[3];
  17.     static int fd[2] = {-1, -1};

  19.     if (fd[0] < 0) { /* fork/exec our open server first time */
  20.         if (s_pipe(fd) < 0) {
  21.             printf("s_pipe error\n");
  22.             exit(1);
  23.         }
  24.         if ((pid = fork()) < 0) {
  25.             printf("fork error\n");
  26.             exit(1);
  27.         } else if (pid == 0) { /* child */
  28.             close(fd[0]);
  29.             if (fd[1] != STDIN_FILENO &&
  30.                     dup2(fd[1], STDIN_FILENO) != STDIN_FILENO) {
  31.                 printf("dup2 error to stdin\n");
  32.                 exit(1);
  33.             }
  34.             if (fd[1] != STDOUT_FILENO &&
  35.                     dup2(fd[1], STDOUT_FILENO) != STDOUT_FILENO) {
  36.                 printf("dup2 error to stdout\n");
  37.                 exit(1);
  38.             }
  39.             if (execl("./opend", "opend", (char *)0) < 0) {
  40.                 printf("execl error\n");
  41.                 exit(1);
  42.             }
  43.         }
  44.         close(fd[1]); /* parent */
  45.     }
  46.     sprintf(buf, " %d", oflag); /* oflag to ascii */
  47.     iov[0].iov_base = CL_OPEN " "; /* string concatenation */
  48.     iov[0].iov_len = strlen(CL_OPEN) + 1;
  49.     iov[1].iov_base = name;
  50.     iov[1].iov_len = strlen(name);
  51.     iov[2].iov_base = buf;
  52.     iov[2].iov_len = strlen(buf) + 1; /* +1 for null at end of buf */
  53.     len = iov[0].iov_len + iov[1].iov_len + iov[2].iov_len;
  54.     if (writev(fd[0], &iov[0], 3) != len) {
  55.         printf("writev error\n");
  56.         exit(1);
  57.     }

  59.     /* read descriptor, returned errors handled by write() */
  60.     return(recv_fd(fd[0], write));
  61. }


子进程关闭了管道的一端，父进程关掉另一端。对于它执行的服务器，子进程也复制管道的它的那端到它的标准输入和标准输出上。（另一个选项会是把描述符fd[1]的ASCII表示作为服务器的一个参数。）

父进程发送给服务包含路径名和打开模式的请求。最后，父进程调用recv_fd来返回描述符或个错误。如果一个错误由服务器返回，write被调用来向标准错误输出。


现在让我们看下打开服务器。它是上面代码里客户执行的程序opend。首先，我们有opend.h（下面的代码），它包含标准头文件并声明全局变量和函数原型。



  1. #include <errno.h>

  3. #define CL_OPEN "open" /* client's request for server */

  5. extern char errmsg[]; /* error message string to return to client */
  6. extern int oflag; /* open() flag: O_xxx ... */
  7. extern char *pathname; /* of file to open() for client */

  9. int cli_args(int, char **);
  10. void request(char *, int, int);

main函数（下面的代码）在s-pipe（它的标准输入）上从客户端读取请求并调用函数request。


  1. #include "opend.h"
  2. #include <unistd.h>

  4. #define BUFFSIZE 8192
  5. #define MAXLINE 4096

  7. char errmsg[MAXLINE];
  8. int oflag;
  9. char *pathname;

  11. int
  12. main(void)
  13. {
  14.     int nread;
  15.     char buf[BUFFSIZE];
  16.     
  17.     for ( ; ; ) { /* read arg buffer from client, process request */
  18.         if ((nread = read(STDIN_FILENO, buf, MAXLINE)) < 0) {
  19.             printf("read error on stream pipe\n");
  20.             exit(1);
  21.         } else if (nread == 0)
  22.             break; /* client has closed the stream pipe */
  23.         request(buf, nread, STDOUT_FILENO);
  24.     }
  25.     exit(0);
  26. }

下面代码的request函数做了所有的工作。它调用函数buf_args来把客户的请求分解为argv风格的参数列表并调用函数 cli_args来处理客户的参数。如果所有的事情都成功，那么open被调用来打开文件，然后send_fd把描述符通过s-pipe（它的标准输出） 发送回给客户。如果碰到错误，send_err被调用来把一个错误消息发送回去，使用我们之前描述的客户－服务器协议。


  1. #include "opend.h"
  2. #include <fcntl.h>

  4. void
  5. request(char *buf, int nread, int fd)
  6. {
  7.     int newfd;

  9.     if (buf[nread-1] != 0) {
  10.         sprintf(errmsg, "request not null terminated: %*.*s\n",
  11.                 nread, nread, buf);
  12.         send_err(fd, -1, errmsg);
  13.         return;
  14.     }
  15.     if (buf_args(buf, cli_args) < 0) { /* parse args & set options */
  16.         send_err(fd, -1, errmsg);
  17.         return;
  18.     }
  19.     if ((newfd = open(pathname, oflag)) < 0) {
  20.         sprintf(errmsg, "can't open %s: %s\n", pathname, strerror(errno));
  21.         send_err(fd, -1, errmsg);
  22.         return;
  23.     }
  24.     if (send_fd(fd, newfd) < 0) { /* send the descriptor */
  25.         printf("send_fd error\n");
  26.         exit(1);
  27.     }
  28.     close(newfd); /* we're done with descriptor */
  29. }

客户的请求是一个null终止的空白字符分隔的参数字符串。下面代码里的函数buf_args把这个字符串分解成标准的argv风格的参数列 表并调用一个用户函数来处理参数。我们将使用本章后面的buf_args函数。我们使用ISO C函数strtok来语素化字符串为分隔的参数。


  1. #include <stddef.h>
  2. #include <string.h>

  4. #define MAXARGC 50 /* max number of arguments in buf */
  5. #define WHITE " \t\n" /* white space for tokenizing arguments */

  7. /*
  8.  * buf[] contains white-space-separated arguments. We conver it to an
  9.  * argv-style array of pointers, and call the user's function (optfunc)
  10.  * to process the array. We return -1 if there's a problem parsing buf,
  11.  * else we return whatever optfunc() returns. Note that user's buf[]
  12.  * array is modified (nulls placed after each token).
  13.  */
  14. int
  15. buf_args(char *buf, int (*optfunc)(int, char **))
  16. {
  17.     char *ptr, *argv[MAXARGC];
  18.     int argc;

  20.     if (strtok(buf, WHITE) == NULL) /* an argv[0] is required */
  21.         return(-1);
  22.     argv[argc = 0] = buf;

  24.     while ((ptr = strtok(NULL, WHITE)) != NULL) {
  25.         if (++argc >= MAXARGC-1) /* -1 for room for NULL at end */
  26.             return(-1);
  27.         argv[argc] = ptr;
  28.     }
  29.     argv[++argc] = NULL;
  30.     /*
  31.      * Since argv[] pointers point into the user's buf[],
  32.      * user's funciton can just copy the pointers, event
  33.      * though argv[] array will disappear on return.
  34.      */
  35.     return((*optfunc)(argc, argv));
  36. }


被buf_args调用的服务器的函数是cli_args（下面的代码）。它验证客户发送了正确数量的参数并把路径名和打开模式存储在全局变量里。


  1. #include "opend.h"
  2. #include <string.h>

  4. /*
  5.  * This function is called by buf_args(), which is called by
  6.  * request(*). buf_args() has broken up the client's buffer
  7.  * into an argv[]-style array, which we now process.
  8.  */
  9. cli_args(int argc, char **argv)
  10. {
  11.     if (argc != 3 || strcmp(argv[0], CL_OPEN) != 0) {
  12.         strcpy(errmsg, "usage: \n");
  13.         return(-1);
  14.     }
  15.     pathname = argv[1]; /* save ptr to pathname to open */
  16.     oflag = atoi(argv[2]);
  17.     return(0);
  18. }


这完成了客户通过fork和exec调用的打开服务器。单个s-pipe在fork之前被创建，并用来在客户和服务器之间通信。使用这种布署，我们为每个客户都有一个服务器。
阅读(1439) | 评论(0) | 转发(0) |
0

上一篇：第十七章＊高级IPC（四）－－传递文件描述符（Passing File Descriptors）

下一篇：第十七章＊高级IPC（六）－－一个打开服务器，版本2 （An Open Server， Version 2）

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6