Chinaunix首页 | 论坛 | 博客

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

首页　| 　博文目录　| 　关于我

yourtommy

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

全部博文（438）

文章存档

2019年（1）

2013年（8）

2012年（429）

我的朋友
最近访客
推荐博文
相关博文
第十六章＊网络IPC：套接字（五）－－数据传输（Data Transfer）

分类： 系统运维

2012-04-03 09:51:31

因为一个套接字终端作为一个文件描述符表示，所以我们可以使用read和write来和一个套接字通信，只要它被连接。回想一个数据报套接字可以是 “连接的”如果我们使用connect函数设置默认伙伴地址。使用read和write操作套接字描述符是很有意义的，因为它表示我们可以传递套接字描述 符到一个函数，它最初被设计为工作在本地文件上。我们可以安排把套接字描述符传递给执行程序的对套接字一无所知的子进程。


尽管我们可以使用read和write交换数据，但是这大概是我们用这两个函数能做的所有事情。如果我们想指定选项，从多个客户接收包，或发送不同频道的数据，那么我们需要使用为数据传输设计的6个套接字函数中的某个。


三个函数可用来发送数据，而三个可用来接收数据。首先，我们将看下用来发送数据的那些。


最简单的一个是send。它和write相似，但是允许我们指定标志来改变我们想要的数据是如何被对待的。



  1. #include <sys/socket.h>

  3. ssize_t send(int sockfd, const void *buf, size_t nbytes, int flags);

  5. 成功返回发送的字节数，错误返回-1。


像write一样，套接字必须被连接才能使用send。buf和nbytes参数有和在write里时相同的意义。

然而，不像write一样，send支持第4个标志参数。两个标志被SUS定义，但是实现普遍支持补充的。它们在下表汇总。


send套接字调用使用的标志
标志描述POSIX.1FreeBSD 5.2.1Linux 2.4.22Mac OS X 10.3Solaris 9
MSG_DONTROUTE不要路由本地网络之外的包
****
MSG_DONTWAIT启用非阻塞操作（等价于使用O_NONBLOCK）。
***
MSG_EOR如果被协议支持，这是记录末尾****
MSG_OOB发送out-of-band数据，如果被协议支持（16.7节）*****


如果send返回成功，它也不必表示连接的另一端的进程收到了数据。所有我们被保证的是当send成功时，数据被分发给网络驱动器而没有错误。


使用一个支持消息边界的协议时，如果我们尝试发送单个比协议支持的最大值还要大的消息，那么send会失败并设置errno为EMSGSIZE。使用一个基于流的协议时，send会阻塞，直到整个数据被传送。


sendto函数和send相似。区别在于sendto允许我们指定一个用于无连接套接字的目的地址。



  1. #include <sys/socket.h>

  3. ssize_t sendto(int sockfd, const void *buf, size_t nbytes, int flags, const struct sockaddr *destaddr, socklen_t destlen);

  5. 成功返回发送的字节量，错误返回-1。


使用一个面向连接的套接字时，目的地址被忽略，因为目的地被连接隐含。使用一个无连接的套接字时，我们不能使用send，除非目的地址事先通过调用connect设置，所以sendto给我们发送一个消息的另一种方式。


我们在通过套接字传输数据时还有一个选择。我们调用sendmsg，使用一个msghdr结构体来指明多个缓冲，从这些缓冲来传输数据，和writev函数相似（14.7节）。



  1. #include <sys/socket.h>

  3. ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);

  5. 成功返回字节数，错误返回-1。


POSIX.1定义msghdr结构体，包含至少以下成员：
struct msghdr {
  void  *msg_name;  /* optional address */
  socklen_t  msg_namelen;  /* address size in bytes */
  struct iovec  *msg_iov;  /* array of I/O buffers */
  int  msg_iovlen;  /* number of elements in array */
  void  *msg_control;  /* ancillary data */
  socklen_t  msg_controllen;  /* number of ancillary bytes */
  int  msg_flags;  /* flags for received message */
  ...
};


我们在14.7节看到iovec结构体。我们将在17.4.2节看到补充数据的使用。


recv函数和read相似，但允许我们指定一个选项来控制我们如何收到数据。



  1. #include <sys/socket.h>

  3. ssize_t recv(int sockfd, void *buf, size_t nbytes, int flags);

  5. 返回消息的字节尺寸，如果没有可用的消息且同伴执行了一个有规则的关闭则返回0，错误返回-1。


可以传递给recv的标志在下表汇总。只有三个被定义在SUS里。


recv套接字调用使用的标志
标志描述POSIX.1FreeBSD 5.2.1Linux 2.4.22Mac OS X 10.3Solaris 9
MSG_OOB如果被协议支持则接受不在同一频道的数据（16.7节）*****
MSG_PEEK返回包内容而不消费包。*****
MSG_TRUNC请求被返回的包的真实长度，即使它被裁切

*

MSG_WAITALL等待直到数据可用（只用于SOCK_STREAM）*****


当我们指定MSG_PEEK标志时，我们可以瞟一下下一个要读的数据，而不真正消费它。下一个read调用或某个recv函数会返回我们瞟过的相同的数据。


使 用SOCK_STREAM套接字时，我们可以接收比我们请求更少的数据。MSG_WAITALL标志抑制这种行为，避免recv返回，直到所有我们请求的 数据被接收到。使用SOCK_DGRAM和SOCK_SEQPACKET套接字时，MSG_WAITALL标志在行为上没有提供改变，因为这些基于消息的 套接字类型在单个读里已经返回整个消息了。


如果发送者已经调用了shutdown（16.2节）来结束传输，或网络协议默认支持有规则的关闭且发送者已经关闭这个套接字，那么recv将返回0，当我们已收到所有数据时。



  1. #include <sys/socket.h>

  3. ssize_t recvfrom(int sockfd, void *restrict buf, size_t len, int flags, struct sockaddr *restrict addr, socklen_t *restrict addrlen);

  5. 返回消息的字节长度，如果没有消息可用且同伴已经执行有规则的关闭则返回0，错误返回-1。


如果addr为非空，那么它将包含套接字终端的地址，数据从那里发送过来。当调用recvfrom时，我们需要设置addrlen参数来指向一个包含addr指向的套接字缓冲字节尺寸的整型。在返回时，这个整型被设置为地址真实的字节尺寸。


因为我们被允许得到发送者的地址，所能recvfrom通常用在无连接的套接字上。否则，recvfrom和recv的行为一样。


为了接收数据到多个缓冲里，和readv类似（14.7节），或者我们想接收附加数据（17.4.2节），那么我们可以使用recvmsg。



  1. #include <sys/socket.h>

  3. ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

  5. 返回消息的字节长度，如果没有消息可用且同伴已经执行有规则的关闭则返回0，错误返回-1。


msghdr 结构体（我们在sendmsg那里看过了）被recvmsg用来指定用来接收数据的输入缓冲。我们可以设置flags参数来改变recvmsg的默认行 为。在返回时，msghdr结构体的msg_flags域被设置来指定收到的数据的各种特性。（msg_flags域在recvmsg的入口被忽略）。在 从recvmsg返回时的可能值在下表汇总。我们将看到一个使用recvmsg的例子，在17章。


recvmsg返回的msg_flags的标志
标志描述POSIX.1FreeBSD 5.2.1Linux 2.4.22Mac OS X 10.3Solaris 9
MSG_CTRUNC控制数据被裁切＊＊＊＊＊
MSG_DONTWAITrecvmsg以非阻塞模式被调用

＊
＊
MSG_EOR记录末尾被收到＊＊＊＊＊
MSG_OOB不同频道的数据被收到＊＊＊＊＊
MSG_TRUNC普通数据被裁切＊＊＊＊＊


下面的代码展示了一个和服务器通信来获得一个系统uptime命令的输出的客户端命令。我们称这个服务为“远程uptime”（或“ruptime”）。



  1. #include <netdb.h>
  2. #include <errno.h>
  3. #include <sys/socket.h>
  4. #include <unistd.h>
  5. #include <stdio.h>

  7. #define MAXDDRLEN 256
  8. #define BUFLEN 128

  10. extern int connect_retry(int, const struct sockaddr *, socklen_t);

  12. void
  13. print_uptime(int sockfd)
  14. {
  15.     int n;
  16.     char buf[BUFLEN];

  18.     while ((n = recv(sockfd, buf, BUFLEN, 0)) > 0)
  19.         write(STDOUT_FILENO, buf, n);
  20.     if (n < 0) {
  21.         printf("recv error\n");
  22.         exit(1);
  23.     }
  24. }

  26. int
  27. main(int argc, char *argv[])
  28. {
  29.     struct addrinfo *ailist, *aip;
  30.     struct addrinfo hint;
  31.     int sockfd, err;

  33.     if (argc != 2) {
  34.         printf("usage: ruptime hostanme");
  35.         exit(1);
  36.     }
  37.     hint.ai_flags = 0;
  38.     hint.ai_family = 0;
  39.     hint.ai_socktype = SOCK_STREAM;
  40.     hint.ai_protocol = 0;
  41.     hint.ai_addrlen = 0;
  42.     hint.ai_canonname = NULL;
  43.     hint.ai_addr = NULL;
  44.     hint.ai_next = NULL;
  45.     if ((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0) {
  46.         printf("getaddrinfo error: %s\n", gai_strerror(err));
  47.         exit(1);
  48.     }
  49.     for (aip = ailist; aip != NULL; aip = aip->ai_next) {
  50.         if ((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0)
  51.             err = errno;
  52.         if (connect_retry(sockfd, aip->ai_addr, aip->ai_addrlen) < 0) {
  53.             err = errno;
  54.         } else {
  55.             print_uptime(sockfd);
  56.             exit(0);
  57.         }
  58.     }
  59.     fprintf(stderr, "can't connect to %s: %s\n", argv[1], strerror(err));
  60.     exit(1);
  61. }

这个程序连接到一个服务器，读取从服务器发送的字符串，并把字符串打印到标准输出。因为我们正使用一个SOCK_STREAM套接字，所以我们不能被保证我们将在一次recv调用里读取到整个字符串，所以我们需要重复这个调用，直到它返回0。


getaddrinfo函数可能为我们返回多个可使用的候选地址，如果服务器支持多个网络接口或多个网络协议。我们依次尝试每一个，当找到一个允许我们连接到服务时便放弃。我们使用connect_retry函数来建立一个到服务器的连接。


下面的代码展示了提供uptime命令的输出给上面的客户程序的服务器。



  1. #include <netdb.h>
  2. #include <stdio.h>
  3. #include <syslog.h>
  4. #include <errno.h>

  6. #define BUFLEN 128
  7. #define QLEN 10

  9. #ifndef HOST_NAME_MAX
  10. #define HOST_NAME_MAX 256
  11. #endif

  13. extern void daemonize(const char *);
  14. extern int initserver(int, struct sockaddr *, socklen_t, int);

  16. void
  17. serve(int sockfd)
  18. {
  19.     int clfd;
  20.     FILE *fp;
  21.     char buf[BUFLEN];

  23.     for (;;) {
  24.         syslog(LOG_INFO, "ruptimed: start to accept");
  25.         clfd = accept(sockfd, NULL, NULL);
  26.         if (clfd < 0) {
  27.             syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
  28.             exit(1);
  29.         }
  30.         else {
  31.             syslog(LOG_INFO, "ruptimed: succeed to accept");
  32.         }
  33.         if ((fp = popen("/usr/bin/uptime", "r")) == NULL) {
  34.             sprintf(buf, "error: %s\n", strerror(errno));
  35.             send(clfd, buf, strlen(buf), 0);
  36.         } else {
  37.             while (fgets(buf, BUFLEN, fp) != NULL)
  38.                 send(clfd, buf, strlen(buf), 0);
  39.             pclose(fp);
  40.         }
  41.         close(clfd);
  42.     }
  43. }

  45. int
  46. main(int argc, char *argv[])
  47. {
  48.     struct addrinfo *ailist, *aip;
  49.     struct addrinfo hint;
  50.     int sockfd, err, n;
  51.     char *host;

  53.     if (argc != 1) {
  54.         printf("usage: ruptimed1");
  55.         exit(1);
  56.     }
  57. #ifdef _SC_HOST_NAME_MAX
  58.     n = sysconf(_SC_HOST_NAME_MAX);
  59.     if (n < 0) /* best guess */
  60. #endif
  61.         n = HOST_NAME_MAX;
  62.     host = malloc(n);
  63.     if (host == NULL) {
  64.         printf("malloc error");
  65.         exit(1);
  66.     }
  67.     if (gethostname(host, n) < 0) {
  68.         printf("gethostname error\n");
  69.         exit(1);
  70.     }
  71.     daemonize("ruptimed");
  72.     hint.ai_flags = AI_CANONNAME;
  73.     hint.ai_family = 0;
  74.     hint.ai_socktype = SOCK_STREAM;
  75.     hint.ai_protocol = 0;
  76.     hint.ai_addrlen = 0;
  77.     hint.ai_canonname = NULL;
  78.     hint.ai_addr = NULL;
  79.     hint.ai_next = NULL;
  80.     if ((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0) {
  81.         syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", gai_strerror(err));
  82.         exit(1);
  83.     }
  84.     for (aip = ailist; aip != NULL; aip = aip->ai_next) {
  85.         if ((sockfd = initserver(SOCK_STREAM, aip->ai_addr, aip->ai_addrlen, QLEN)) >= 0) {
  86.             serve(sockfd);
  87.             exit(0);
  88.         }
  89.     }
  90.     exit(1);
  91. }

为了找到它的地址，服务器需要得到它运行的主机的名字。一些系统没有定义_SC_HOST_NAME_MAX常量，所以我们在这种情况下使用 HOST_NAME_NAME。如果系统没有定义HOST_NAME_MAX，那么我们自己定义。POSIX.1指定主机名的最小值是255字节，不包括 最后的终止空字符，所以我们定义HOST_NAME_MAX为256来包含终止符。

服务器通过调用gethostname得到主机名并查找远程uptime服务器的地址。可能有多个地址返回，但是我们简单挑选第一个我们可以为其建立一个被动套接字终端的那个。


我们使用16.4节的initserver函数来初始化套接字终端，在它上面我们将等待连接请求的到达。（事实上， 我们使用16.6节的版本，我们将在讨论套接字选项时看到为什么。）


（要让上面的代码正常工作，首先确保/etc/services文件有ruptime这个服务，没有的话需要加上这项。然后，在客户端程序的命令行里必须指定主机的真实名字，而不能用localhost这样的。）


在 前面，我们指定使用文件描述符来访问套接字是意义重大的，因为它允许不知道网络的程序在网络环境下运行。下面的代码是上面服务器的另一个版本，它演示这 点。作为从uptime命令的输出读并发送它到客户端的替代，服务器把uptime命令的标准输出和标准错误安排到和客户端连接的套接字终端。



  1. #include <netdb.h>
  2. #include <syslog.h>
  3. #include <errno.h>
  4. #include <unistd.h>

  6. #define QLEN 10

  8. #ifndef HOST_NAME_MAX
  9. #define HOST_NAME_MAX 256
  10. #endif

  12. extern void daemonize(const char *);
  13. extern int initserver(int, struct sockaddr *, socklen_t, int);

  15. void
  16. serve(int sockfd)
  17. {
  18.     int clfd, status;
  19.     pid_t pid;

  21.     for (;;) {
  22.         clfd = accept(sockfd, NULL, NULL);
  23.         if (clfd < 0) {
  24.             syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
  25.             exit(1);
  26.         }
  27.         if ((pid = fork()) < 0) {
  28.             syslog(LOG_ERR, "ruptimed: fork error: %s", strerror(errno));
  29.             exit(1);
  30.         } else if (pid == 0) { /* child */
  31.             /*
  32.              * The parent called daemonize, so
  33.              * STDIN_FILENO, STDOUT_FILENO, and STDERROR_FILENO
  34.              * are already open to /dev/null. Thus, the call to
  35.              * close doesn't need to be protected by checks that
  36.              * clfd isn't already equal to one of these values.
  37.              */
  38.             if (dup2(clfd, STDOUT_FILENO) != STDOUT_FILENO ||
  39.               dup2(clfd, STDERR_FILENO) != STDERR_FILENO) {
  40.                 syslog(LOG_ERR, "ruptimed: unexpected error");
  41.                 exit(1);
  42.             }
  43.             close(clfd);
  44.             execl("/usr/bin/uptime", "uptime", (char *)0);
  45.             syslog(LOG_ERR, "ruptimed: unexpected return from exec: %s", strerror(errno));
  46.         } else { /* parent */
  47.             close(clfd);
  48.             waitpid(pid, &status, 0);
  49.         }
  50.     }
  51. }

  53. int
  54. main(int argc, char *argv[])
  55. {
  56.     struct addrinfo *ailist, *aip;
  57.     struct addrinfo hint;
  58.     int sockfd, err, n;
  59.     char *host;

  61.     if (argc != 1) {
  62.         printf("usage: ruptimed1");
  63.         exit(1);
  64.     }
  65. #ifdef _SC_HOST_NAME_MAX
  66.     n = sysconf(_SC_HOST_NAME_MAX);
  67.     if (n < 0) /* best guess */
  68. #endif
  69.         n = HOST_NAME_MAX;
  70.     host = malloc(n);
  71.     if (host == NULL) {
  72.         printf("malloc error");
  73.         exit(1);
  74.     }
  75.     if (gethostname(host, n) < 0) {
  76.         printf("gethostname error\n");
  77.         exit(1);
  78.     }
  79.     daemonize("ruptimed");
  80.     hint.ai_flags = AI_CANONNAME;
  81.     hint.ai_family = 0;
  82.     hint.ai_socktype = SOCK_STREAM;
  83.     hint.ai_protocol = 0;
  84.     hint.ai_addrlen = 0;
  85.     hint.ai_canonname = NULL;
  86.     hint.ai_addr = NULL;
  87.     hint.ai_next = NULL;
  88.     if ((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0) {
  89.         syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", gai_strerror(err));
  90.         exit(1);
  91.     }
  92.     for (aip = ailist; aip != NULL; aip = aip->ai_next) {
  93.         if ((sockfd = initserver(SOCK_STREAM, aip->ai_addr, aip->ai_addrlen, QLEN)) >= 0) {
  94.             serve(sockfd);
  95.             exit(0);
  96.         }
  97.     }
  98.     exit(1);
  99. }

作为使用popen来运行uptime命令并从和命令的标准输出连接的管道的输出读取的替代，我们使用fork来创建一个子进程然后使用 dup2来把子进程的STDIN_FILENO布署到/dev/null并把STDOUT_FILENO和STDERR_FILENO同时布署到套接字的 端点。当我们执行uptime时，这个命令把结果写到它的标准输出，它和套接字相连，而数据被发送回给ruptime的客户命令。

父 进程可以安全地关闭和客户连接的文件描述符，因为子进程仍然打开着它。父进程在进行运行前等待子进程完成，以便子进程不会变成僵尸。因为运行uptime 命令不应该花太长时间，所以父进程可以等待得起子进程退出，在接受下个连接请求之前。然而，这个策略可能不合适，如果子进程花费很长的时间。


前面的例子使用面向连接的套接字。但是我们怎么选择合适的类型呢？我们什么时候使用面向连接的套接字，而什么时候使用一个无连接的套接字呢？答案取决于我们想完成多少工作，以及我们对错误有什么类型的容忍。


通 过一个无连接套接字，包可以不按顺序到达，所以如果我们不能在一个包里填满所有数据，那么我们将必须在应用里担心排序的问题。最大的包尺寸是一个通信协议 的特性。还有，通过一个无连接套接字，包可能被丢失。如果我们的应用不能容忍这种丢失，那么我们应该使用面向连接的套接字。


容忍包的丢失意味着我们有两种选择。如果我们倾向于在和我们伙伴之间要有可靠的通信，那么我们必须编号我们的包并当我们察觉到一个丢失的包时请求从伙伴应用重新发送。我们也将必须标识重复的包并舍弃它们，因为一个包可以延迟而看起来被丢失，但是在我们请求重发后又出现。


另一个选择是能让用处重试命令的方式处理这个错误。对于简单的应用，它可能足够，但是对于复杂的应用，这通常不是可行的方法，所以在这种情况下我们通常使用面向连接的套接字。


面向连接的套接字的缺陷是需要更多时间和工作来建立一个连接，且每个连接从操作系统消耗掉更多的资源。


下面的代码是uptime客户命令的另一个版本，它使用数据报套接字接口。



  1. #include <netdb.h>
  2. #include <errno.h>
  3. #include <sys/socket.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6. #include <signal.h>

  8. #define BUFLEN 128
  9. #define TIMEOUT 20

  11. void
  12. sigalrm(int signo)
  13. {
  14. }

  16. void
  17. print_uptime(int sockfd, struct addrinfo *aip)
  18. {
  19.     int n;
  20.     char buf[BUFLEN];

  22.     buf[0] = 0;
  23.     if (sendto(sockfd, buf, 1, 0, aip->ai_addr, aip->ai_addrlen) < 0) {
  24.         printf("sendto error\n");
  25.         exit(1);
  26.     }
  27.     alarm(TIMEOUT);
  28.     if ((n = recvfrom(sockfd, buf, BUFLEN, 0, NULL, NULL)) < 0) {
  29.         if (errno != EINTR)
  30.             alarm(0);
  31.         printf("recv error\n");
  32.         exit(1);
  33.     }
  34.     alarm(0);
  35.     write(STDOUT_FILENO, buf, n);
  36. }

  38. int
  39. main(int argc, char *argv[])
  40. {
  41.     struct addrinfo *ailist, *aip;
  42.     struct addrinfo hint;
  43.     int sockfd, err;
  44.     struct sigaction sa;

  46.     if (argc != 2) {
  47.         printf("usage: ruptime hostanme");
  48.         exit(1);
  49.     }
  50.     sa.sa_handler = sigalrm;
  51.     sa.sa_flags = 0;
  52.     sigemptyset(&sa.sa_mask);
  53.     if (sigaction(SIGALRM, &sa, NULL) < 0) {
  54.         printf("sigaction error\n");
  55.         exit(1);
  56.     }
  57.     hint.ai_flags = 0;
  58.     hint.ai_family = 0;
  59.     hint.ai_socktype = SOCK_DGRAM;
  60.     hint.ai_protocol = 0;
  61.     hint.ai_addrlen = 0;
  62.     hint.ai_canonname = NULL;
  63.     hint.ai_addr = NULL;
  64.     hint.ai_next = NULL;
  65.     if ((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0) {
  66.         printf("getaddrinfo error: %s\n", gai_strerror(err));
  67.         exit(1);
  68.     }
  69.     for (aip = ailist; aip != NULL; aip = aip->ai_next) {
  70.         if ((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0)
  71.             err = errno;
  72.         else {
  73.             print_uptime(sockfd, aip);
  74.             exit(0);
  75.         }
  76.     }
  77.     fprintf(stderr, "can't connect to %s: %s\n", argv[1], strerror(err));
  78.     exit(1);
  79. }

基于数据报的客户端的main函数和面向连接的客户端的那个相似，只是加上了对SIGALRM的信号处理。我们使用alarm函数来避免在recvfrom函数上无尽地阻塞。

通 过面向连接的协议，我们需要在交换数据前连接到服务器。连接请求的到达对于服务器来说已经足够确定它需要为一个客户提供服务。但是使用基于数据报的协议， 我们需要一种方法来通知服务器我们想让它代理我们执行它的服务。在这个例子里，我们简单地发送给服务器一个字节的消息。服务器将收到它，从包里得到我们的 地址，并使用这个地址来传送它的响应。如果服务器提供多个服务，我们可以使用这个请求消息来指明我们想要的服务，但是既然服务器只做一件事，那么一字节的 消息内容无关紧要。


如果服务器没有运行，那么客户会无尽地阻塞在recvfrom调用上。如面向连接的例子一样，connect调用会失败，如果服务器没有运行。为了避免无尽地阻塞，我们在调用recvfrom前设置一个闹钟。


下面的代码是uptime服务器的数据报的版本。



  1. #include <netdb.h>
  2. #include <stdio.h>
  3. #include <syslog.h>
  4. #include <errno.h>

  6. #define BUFLEN 128
  7. #define MAXADDRLEN 10

  9. #ifndef HOST_NAME_MAX
  10. #define HOST_NAME_MAX 256
  11. #endif

  13. extern void daemonize(const char *);
  14. extern int initserver(int, struct sockaddr *, socklen_t, int);

  16. void
  17. serve(int sockfd)
  18. {
  19.     int n;
  20.     socklen_t alen;
  21.     FILE *fp;
  22.     char buf[BUFLEN];
  23.     char abuf[MAXADDRLEN];

  25.     for (;;) {
  26.         alen = MAXADDRLEN;
  27.         if ((n = recvfrom(sockfd, buf, BUFLEN, 0,
  28.           (struct sockaddr *)abuf, &alen)) < 0) {
  29.             syslog(LOG_ERR, "ruptimed: recvfrom error: %s", strerror(errno));
  30.             exit(1);
  31.         }
  32.         if ((fp = popen("/usr/bin/uptime", "r")) == NULL) {
  33.             sprintf(buf, "error: %s\n", strerror(errno));
  34.             sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)abuf, alen);
  35.         } else {
  36.             if (fgets(buf, BUFLEN, fp) != NULL)
  37.                 sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)abuf, alen);
  38.             pclose(fp);
  39.         }
  40.     }
  41. }

  43. int
  44. main(int argc, char *argv[])
  45. {
  46.     struct addrinfo *ailist, *aip;
  47.     struct addrinfo hint;
  48.     int sockfd, err, n;
  49.     char *host;

  51.     if (argc != 1) {
  52.         printf("usage: ruptimed1");
  53.         exit(1);
  54.     }
  55. #ifdef _SC_HOST_NAME_MAX
  56.     n = sysconf(_SC_HOST_NAME_MAX);
  57.     if (n < 0) /* best guess */
  58. #endif
  59.         n = HOST_NAME_MAX;
  60.     host = malloc(n);
  61.     if (host == NULL) {
  62.         printf("malloc error");
  63.         exit(1);
  64.     }
  65.     if (gethostname(host, n) < 0) {
  66.         printf("gethostname error\n");
  67.         exit(1);
  68.     }
  69.     daemonize("ruptimed");
  70.     hint.ai_flags = AI_CANONNAME;
  71.     hint.ai_family = 0;
  72.     hint.ai_socktype = SOCK_DGRAM;
  73.     hint.ai_protocol = 0;
  74.     hint.ai_addrlen = 0;
  75.     hint.ai_canonname = NULL;
  76.     hint.ai_addr = NULL;
  77.     hint.ai_next = NULL;
  78.     if ((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0) {
  79.         syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", gai_strerror(err));
  80.         exit(1);
  81.     }
  82.     for (aip = ailist; aip != NULL; aip = aip->ai_next) {
  83.         if ((sockfd = initserver(SOCK_DGRAM, aip->ai_addr, aip->ai_addrlen, 0)) >= 0) {
  84.             serve(sockfd);
  85.             exit(0);
  86.         }
  87.     }
  88.     exit(1);
  89. }

服务器为一个服务请求而阻塞在recvfrom里。当一个请求到达时，我们保存请求者的地址并使用popen来运行upteime命令。我们把输出发送回给客户，通过sendto函数，把目的地址设置为请求者的地址。
阅读(1568) | 评论(0) | 转发(0) |
0

上一篇：第十六章＊网络IPC：套接字（四）－－连接建立（Connection Establishment）

下一篇：第十六章＊网络IPC：套接字（六）－－套接字选项

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

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

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

16024965号-6