UNP学习笔记（第八章 基本UDP套接字编程）

UDP应用程序客户不与服务器建立连接，而是只管使用sendto函数给服务器发送数据报，其中必须指定目的地的地址作为参数。

下图给出典型的UDP客户/服务器程序的函数调用。

recvfrom和sendto函数

这两个函数类似于标准的read和write函数，不过需要3个额外的参数

#include <sys/socket.h>
ssize_t recvfrom(int sockfd, void *buff, size_t nbytes, int flags,struct sockaddr *src_addr, socklen_t *addrlen);
ssize_t sendto(int sockfd, const void *buff, size_t nbytes, int flags,const struct sockaddr *to, socklen_t addrlen);
                                                                         //均返回：若成功则为读或写的字节数，若出错则为-1

UDP回射服务器程序

main函数

 #include    "unp.h"

 int
 main(int argc, char **argv)
 {
     int                    sockfd;
     struct sockaddr_in    servaddr, cliaddr;

     sockfd = Socket(AF_INET, SOCK_DGRAM, );

     bzero(&servaddr, sizeof(servaddr));
     servaddr.sin_family      = AF_INET;
     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
     servaddr.sin_port        = htons(SERV_PORT);

     Bind(sockfd, (SA *) &servaddr, sizeof(servaddr));

     dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr));
 }

dg_echo函数

 #include    "unp.h"

 void
 dg_echo(int sockfd, SA *pcliaddr, socklen_t clilen)
 {
     int            n;
     socklen_t    len;
     char        mesg[MAXLINE];

     for ( ; ; ) {
         len = clilen;
         n = Recvfrom(sockfd, mesg, MAXLINE, , pcliaddr, &len);

         Sendto(sockfd, mesg, n, , pcliaddr, len);
     }
 }

UDP回射客户程序

main函数

 #include    "unp.h"

 int
 main(int argc, char **argv)
 {
     int                    sockfd;
     struct sockaddr_in    servaddr;

     if (argc != )
         err_quit("usage: udpcli <IPaddress>");

     bzero(&servaddr, sizeof(servaddr));
     servaddr.sin_family = AF_INET;
     servaddr.sin_port = htons(SERV_PORT);
     Inet_pton(AF_INET, argv[], &servaddr.sin_addr);

     sockfd = Socket(AF_INET, SOCK_DGRAM, );

     dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr));

     exit();
 }

dg_cli函数

 #include    "unp.h"

 void
 dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
 {
     int    n;
     char    sendline[MAXLINE], recvline[MAXLINE + ];

     while (Fgets(sendline, MAXLINE, fp) != NULL) {

         Sendto(sockfd, sendline, strlen(sendline), , pservaddr, servlen);

         n = Recvfrom(sockfd, recvline, MAXLINE, , NULL, NULL);

         recvline[n] = ;    /* null terminate */
         Fputs(recvline, stdout);
     }
 }

验证接收到的相应

知道客户临时端口的任何进程都可往客户发送数据报，而且这些数据报会与正常的服务器应答混杂。

我们应该修改recvfrom调用以返回数据报的发送者的IP地址和端口号，保留来自数据报所发往服务器的应答，而忽略任何其他数据报。

下面是验证返回套接字地址的dg_cli函数版本

 #include    "unp.h"

 void
 dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
 {
     int                n;
     char            sendline[MAXLINE], recvline[MAXLINE + ];
     socklen_t        len;
     struct sockaddr    *preply_addr;

     preply_addr = Malloc(servlen);

     while (Fgets(sendline, MAXLINE, fp) != NULL) {

         Sendto(sockfd, sendline, strlen(sendline), , pservaddr, servlen);

         len = servlen;
         n = Recvfrom(sockfd, recvline, MAXLINE, , preply_addr, &len);
         if (len != servlen || memcmp(pservaddr, preply_addr, len) != ) {
             printf("reply from %s (ignored)\n",
                     Sock_ntop(preply_addr, len));
             continue;
         }

         recvline[n] = ;    /* null terminate */
         Fputs(recvline, stdout);
     }
 }

UDP的connect函数

UDP套接字可以调用connect，但是跟TCP套接字不一样，它不会有三次握手过程。

对于已连接的套接字，与默认的未连接套接字相比，发生了三个变化：

1.我们再也不能给输出操作指定目的IP地址和端口号。也就是说，我们不使用sendto而改用write或send。

2.我们并不必使用recvfrom以获悉数据报的发送者，而改用read、recv或recvmsg。

3.由已连接UDP套接字引发的异步错误会返回给它们所在的进程，而未连接UDP套接字不接受任何异步错误。

一个已连接的UDP套接字可以再次调用connect以用于：

1.指定新的IP地址和端口号

2.断开套接字

dg_cli函数（修订版）

把上面dg_cli函数重写成调用connect的新函数

 #include    "unp.h"

 void
 dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
 {
     int        n;
     char    sendline[MAXLINE], recvline[MAXLINE + ];

     Connect(sockfd, (SA *) pservaddr, servlen);

     while (Fgets(sendline, MAXLINE, fp) != NULL) {

         Write(sockfd, sendline, strlen(sendline));

         n = Read(sockfd, recvline, MAXLINE);

         recvline[n] = ;    /* null terminate */
         Fputs(recvline, stdout);
     }
 }

使用select的TCP和UDP回射服务器程序

 /* include udpservselect01 */
 #include    "unp.h"

 int
 main(int argc, char **argv)
 {
     int                    listenfd, connfd, udpfd, nready, maxfdp1;
     char                mesg[MAXLINE];
     pid_t                childpid;
     fd_set                rset;
     ssize_t                n;
     socklen_t            len;
     const int            on = ;
     struct sockaddr_in    cliaddr, servaddr;
     void                sig_chld(int);

         /* 4create listening TCP socket */
     listenfd = Socket(AF_INET, SOCK_STREAM, );

     bzero(&servaddr, sizeof(servaddr));
     servaddr.sin_family      = AF_INET;
     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
     servaddr.sin_port        = htons(SERV_PORT);

     Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
     Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));

     Listen(listenfd, LISTENQ);

         /* 4create UDP socket */
     udpfd = Socket(AF_INET, SOCK_DGRAM, );

     bzero(&servaddr, sizeof(servaddr));
     servaddr.sin_family      = AF_INET;
     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
     servaddr.sin_port        = htons(SERV_PORT);

     Bind(udpfd, (SA *) &servaddr, sizeof(servaddr));
 /* end udpservselect01 */

 /* include udpservselect02 */
     Signal(SIGCHLD, sig_chld);    /* must call waitpid() */

     FD_ZERO(&rset);
     maxfdp1 = max(listenfd, udpfd) + ;
     for ( ; ; ) {
         FD_SET(listenfd, &rset);
         FD_SET(udpfd, &rset);
         if ( (nready = select(maxfdp1, &rset, NULL, NULL, NULL)) < ) {
             if (errno == EINTR)
                 continue;        /* back to for() */
             else
                 err_sys("select error");
         }

         if (FD_ISSET(listenfd, &rset)) {
             len = sizeof(cliaddr);
             connfd = Accept(listenfd, (SA *) &cliaddr, &len);

             if ( (childpid = Fork()) == ) {    /* child process */
                 Close(listenfd);    /* close listening socket */
                 str_echo(connfd);    /* process the request */
                 exit();
             }
             Close(connfd);            /* parent closes connected socket */
         }

         if (FD_ISSET(udpfd, &rset)) {
             len = sizeof(cliaddr);
             n = Recvfrom(udpfd, mesg, MAXLINE, , (SA *) &cliaddr, &len);

             Sendto(udpfd, mesg, n, , (SA *) &cliaddr, len);
         }
     }
 }
 /* end udpservselect02 */

sig_chld信号处理函数

 Signal(SIGCHLD,sig_chld);

 #include    "unp.h"

 void
 sig_chld(int signo)
 {
     pid_t    pid;
     int        stat;

     pid = wait(&stat);
     printf("child %d terminated\n", pid);
     return;
 }