unix网络模型

转载自http://blog.csdn.net/yfkiss/article/details/7516589

IO模型在Richard Stevens的《UNIX网络编程，第一卷》（程序猿必备！）一书中有非常详尽的描述，以下简要介绍，并给出代码示例。

另外比较好的总结性blog，推荐：
使用异步 I/O 大大提高应用程序的性能
IO - 同步，异步，阻塞，非阻塞 （亡羊补牢篇）

常见网络IO模型：阻塞式IO、无阻塞式IO、IO复用、异步IO、信号驱动

阻塞式IO：
在一个进程发出IO请求后，进入阻塞状态，直到内核返回数据，才重新运行，如图：

代码
sever端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>

 int main()
 {
     int sockfd, new_fd;
     int sin_size, numbytes;
     struct sockaddr_in addr, cliaddr;

     //创建socket
     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
     {
         perror("createSocket");
         return -1;
     }

     //初始化socket结构
     memset(&addr, 0, sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_port = htons(7092);
     addr.sin_addr.s_addr = htonl(INADDR_ANY);

     //绑定套接口
     if(bind(sockfd,(struct sockaddr *)&addr,sizeof(struct sockaddr))==-1)
     {
         perror("bind");
         return -1;
     }

     //创建监听套接口
     if(listen(sockfd,10)==-1)
     {
         perror("listen");
         return -1;
     }


     printf("server is running!\n");

     char buff[1024];
     //等待连接
     while(1)
     {
         sin_size = sizeof(struct sockaddr_in);

         //接受连接
         if((new_fd = accept(sockfd, (struct sockaddr *)&cliaddr, (socklen_t*)&sin_size))==-1)
         {
             perror("accept");
             return -1;
         }

         //生成一个子进程来完成和客户端的会话，父进程继续监听
         if(!fork())
         {
             //读取客户端发来的信息
             memset(buff,0,sizeof(buff));
             if((numbytes = recv(new_fd,buff,sizeof(buff),0))==-1)
             {
                 perror("recv");
                 return -1;
             }
             printf("buff=%s\n",buff);

             //将从客户端接收到的信息再发回客户端
             if(send(new_fd,buff,strlen(buff),0)==-1)
             {
                 perror("send");
             }

             close(new_fd);
             return 0;
         }
         //父进程关闭new_fd
         close(new_fd);
     }
     close(sockfd);
 }

client端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <netdb.h>
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>

 int main(int argc,char *argv[])
 {
     if(argc!=3)
     {
         printf("%s: input IP & port\n",argv[0]);
         return 1;
     }
     int sockfd,numbytes;
     char buf[100] = "hello world";
     struct hostent *he;
     struct sockaddr_in their_addr;

     //将基本名字和地址转换
     he = gethostbyname(argv[1]);

     //建立一个TCP套接口
     if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1)
     {
         perror("socket");
         exit(1);
     }

     //初始化结构体
     their_addr.sin_family = AF_INET;
     their_addr.sin_port = htons(atoi(argv[2]));
     their_addr.sin_addr = *((struct in_addr *)he->h_addr);
     bzero(&(their_addr.sin_zero),8);

     //和服务器建立连接
     if(connect(sockfd,(struct sockaddr *)&their_addr,sizeof(struct sockaddr))==-1)
     {
         perror("connect");
         exit(1);
     }

     //向服务器发送字符串
     if(send(sockfd,buf,strlen(buf),0)==-1)
     {
         perror("send");
         exit(1);
     }
     memset(buf,0,sizeof(buf));

     //接受从服务器返回的信息
     if((numbytes = recv(sockfd,buf,100,0))==-1)
     {
         perror("recv");
         exit(1);
     }

     close(sockfd);
     return 0;
 }

运行：
$ ./bin/server 
server is running!
buff=hello world
buff=hello world

$ ./bin/client 10.32.49.10 7092
$ ./bin/client 10.32.49.10 7092

无阻塞式IO：
在一个进程发出IO请求后，不阻塞，如果数据没有准备好，就直接返回错误码，如图：

可以通过fcntl控制socket描述符属性。
int flags;
flag=fcntl(sockfd,F_GETFL,0);
fcntl(sockfd,F_SETFL,flag|O_NONBLOCK)

非阻塞式I/O模型对4种I/O操作返回的错误
读操作：接收缓冲区无数据时返回EWOULDBLOCK
写操作：发送缓冲区无空间时返回EWOULDBLOCK；空间不够时部分拷贝，返回实际拷贝字节数
建立连接：启动3次握手，立刻返回错误EINPROGRESS；服务器客户端在同一主机上connect立即返回成功
接受连接：没有新连接返回EWOULDBLOCK

代码：
server端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>
 #include <fcntl.h>

 int main()
 {
     int sockfd, new_fd;
     int sin_size;
     struct sockaddr_in addr, cliaddr;

     //创建socket
     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
     {
         perror("createSocket");
         return -1;
     }

     //初始化socket结构
     memset(&addr, 0, sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_port = htons(7092);
     addr.sin_addr.s_addr = htonl(INADDR_ANY);

     //绑定套接口
     if(bind(sockfd,(struct sockaddr *)&addr,sizeof(struct sockaddr))==-1)
     {
         perror("bind");
         return -1;
     }

     //创建监听套接口
     if(listen(sockfd,10)==-1)
     {
         perror("listen");
         return -1;
     }

     printf("server is running!\n");

     char buff[1024];
     //等待连接
     while(1)
     {
         sin_size = sizeof(struct sockaddr_in);

         //接受连接
         if((new_fd = accept(sockfd, (struct sockaddr *)&cliaddr, (socklen_t*)&sin_size))==-1)
         {
             perror("accept");
             return -1;
         }

         //生成一个子进程来完成和客户端的会话，父进程继续监听
         if(!fork())
         {
             //设置new_fd无阻塞属性
             int flags;
             if((flags=fcntl(new_fd, F_GETFL, 0))<0)
             {
                 perror("fcntl F_GETFL");
             }
             flags |= O_NONBLOCK;
             if(fcntl(new_fd, F_SETFL,flags)<0)
             {
                 perror("fcntl F_SETFL");
             }

             //读取客户端发来的信息
             memset(buff,0,sizeof(buff));
             while(1)
             {
                 if((recv(new_fd,buff,sizeof(buff),0)) < 0)
                 {
                     if(errno==EWOULDBLOCK)
                     {
                         perror("recv error, wait....");
                         sleep(1);
                         continue;
                     }
                 }
                 else
                 {
                     printf("buff=%s\n",buff);
                 }
                 break;
             }

             //发送数据
             while(1)
             {
                 if(send(new_fd,buff,strlen(buff),0) < 0)
                 {
                     if(errno==EWOULDBLOCK)
                     {
                         perror("send error, wait....");
                         sleep(1);
                         continue;
                     }
                 }
                 else
                 {
                     printf("buff=%s\n",buff);
                 }
                 break;
             }

             close(new_fd);
             return 0;
         }
         //父进程关闭new_fd
         close(new_fd);
     }
     close(sockfd);
 }

client端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <netdb.h>
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>

 int main(int argc,char *argv[])
 {
     if(argc!=3)
     {
         printf("%s: input IP & port\n",argv[0]);
         return 1;
     }
     int sockfd,numbytes;
     char buf[100] = "hello world";
     struct hostent *he;
     struct sockaddr_in their_addr;

     //将基本名字和地址转换
     he = gethostbyname(argv[1]);

     //建立一个TCP套接口
     if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1)
     {
         perror("socket");
         exit(1);
     }

     //初始化结构体
     their_addr.sin_family = AF_INET;
     their_addr.sin_port = htons(atoi(argv[2]));
     their_addr.sin_addr = *((struct in_addr *)he->h_addr);
     bzero(&(their_addr.sin_zero),8);

     //和服务器建立连接
     if(connect(sockfd,(struct sockaddr *)&their_addr,sizeof(struct sockaddr))==-1)
     {
         perror("connect");
         exit(1);
     }

     sleep(5);

     //向服务器发送字符串
     if(send(sockfd,buf,strlen(buf),0)==-1)
     {
         perror("send");
         exit(1);
     }
     memset(buf,0,sizeof(buf));


     sleep(5);

     //接受从服务器返回的信息
     if((numbytes = recv(sockfd,buf,100,0))==-1)
     {
         perror("recv");
         exit(1);
     }

     close(sockfd);
     return 0;
 }

运行：
$ ./bin/server 
server is running!
recv error, wait....: Resource temporarily unavailable
recv error, wait....: Resource temporarily unavailable
recv error, wait....: Resource temporarily unavailable
recv error, wait....: Resource temporarily unavailable
recv error, wait....: Resource temporarily unavailable
buff=hello world
buff=hello world

$ ./bin/client 10.32.49.10 7092

IO复用：
IO复用阻塞在select、poll或epoll这样的系统调用上，通过这种方式，在不使用多线程的前提下，单个进程可以同时处理多个网络连接的IO。如图：

代码
sever端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/epoll.h>

 #define MAXEVENT 1024

 int create_server_socket(int& sockfd)
 {
     struct sockaddr_in addr;

     //创建socket
     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
     {
         perror("createSocket");
         return -1;
     }

     //初始化socket结构
     memset(&addr, 0, sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_port = htons(7092);
     addr.sin_addr.s_addr = htonl(INADDR_ANY);

     //绑定套接口
     if(bind(sockfd,(struct sockaddr *)&addr,sizeof(struct sockaddr))==-1)
     {
         perror("bind");
         return -1;
     }

     //创建监听套接口
     if(listen(sockfd,10)==-1)
     {
         perror("listen");
         return -1;
     }

     return 0;
 }

 int set_socket_non_blocking(int fd)
 {
     int flags, s;

     flags = fcntl (fd, F_GETFL, 0);
     if (flags == -1)
     {
         perror ("fcntl F_GETFL failed");
         return -1;
     }

     flags |= O_NONBLOCK;
     s = fcntl (fd, F_SETFL, flags);
     if (s == -1)
     {
         perror ("fcntl F_SETFL failed");
         return -1;
     }

     return 0;
 }

 int main()
 {
     int sockfd, efd;
     struct epoll_event event;
     struct epoll_event *events;
     int s;

     if(create_server_socket(sockfd) != 0)
     {
         perror("create server sock failed\n");
         return 1;
     }
     set_socket_non_blocking(sockfd);

     printf("server is running!\n");

     //创建一个epoll的句柄
     //int epoll_create(int size)
     //Since Linux 2.6.8, the size argument is unused. (The kernel dynamically sizes the required data structures without needing this initial hint.)
     efd = epoll_create(MAXEVENT);
     if (efd == -1)
     {
         perror ("epoll_create");
         abort ();
     }

     //注册新事件到epoll efd
     event.data.fd = sockfd;
     event.events = EPOLLIN | EPOLLET;
     s = epoll_ctl(efd, EPOLL_CTL_ADD, sockfd, &event);
     if (s == -1)
     {
         perror ("epoll_ctl EPOLL_CTL_ADD failed");
         abort ();
     }

     events = (epoll_event*)calloc(MAXEVENT, sizeof(event));

     while (1)
     {
         int n, i;
         n = epoll_wait(efd, events, MAXEVENT, -1);
         for (i = 0; i < n; i++)
         {
             //fd error
             if ((events[i].events & EPOLLERR) ||
                 (events[i].events & EPOLLHUP) ||
               (!(events[i].events & EPOLLIN)))
             {
                 perror("epoll error\n");
                 close (events[i].data.fd);
                 continue;
             }
             //新连接
             else if (sockfd == events[i].data.fd)
             {
                 while (1)
                 {  //当使用epoll的ET模型来工作时，当产生了一个EPOLLIN事件后，  读数据的时候需要考    //虑的是当recv()返回的大小如果等于请求的大小，那么很有可能是缓冲区还有数据未读                      //完，也意味着该次事件还没有处理完，所以还需要再次读取
                     struct sockaddr in_addr;
                     socklen_t in_len;
                     int infd;
                     char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                     //接受连接
                     in_len = sizeof(in_addr);
                     infd = accept(sockfd, &in_addr, &in_len);
                     if (infd == -1)
                     {
                         if ((errno == EAGAIN) ||
                           (errno == EWOULDBLOCK))
                         {
                             //已接受所有连接
                             break;
                         }
                         else
                         {
                             perror ("accept");
                             break;
                         }
                     }

                     s = getnameinfo (&in_addr, in_len,
                                    hbuf, sizeof hbuf,
                                    sbuf, sizeof sbuf,
                                    NI_NUMERICHOST | NI_NUMERICSERV);
                     if (s == 0)
                     {
                       printf("Accepted connection on descriptor %d "
                              "(host=%s, port=%s)\n", infd, hbuf, sbuf);
                     }

                     /* 设置新接受的socket连接无阻塞*/
                     s = set_socket_non_blocking (infd);
                     if (s == -1)
                     {
                     return 1;
                     }

                     //注册新事件到epoll
                     event.data.fd = infd;
                     event.events = EPOLLIN | EPOLLET;
                     s = epoll_ctl(efd, EPOLL_CTL_ADD, infd, &event);
                     if (s == -1)
                     {
                       perror ("epoll_ctl");
                       return 1;
                     }
                 }
                 continue;
             }
             //数据可读
             else
             {
               int done = 0;
               while (1)
               {
   //当使用epoll的ET模型来工作时，当产生了一个EPOLLIN事件后，  读数据的时候需要考           //虑的是当recv()返回的大小如果等于请求的大小，那么很有可能是缓冲区还有数据未读                     //完，也意味着该次事件还没有处理完，所以还需要再次读取
                   ssize_t count;
                   char buf[512];
                   count = read(events[i].data.fd, buf, sizeof(buf));
                   if(count == -1)
                   {
                       //出错，如果等于EAGAIN表示数据读完
                       if (errno != EAGAIN)
                       {
                           perror ("read");
                           done = 1;
                       }
                       break;
                   }
                   else if(count == 0)
                   {
                       /* End of file. The remote has closed the
                          connection. */
                       done = 1;
                       break;
                    }

                   printf("recv: %s\n", buf);
                 }

               if (done)
               {
                   printf ("Closed connection on descriptor %d\n", events[i].data.fd);
                   close (events[i].data.fd);
               }
             }
         }
     }

   free (events);
   close(sockfd);
   return 0;
 }

client端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <netdb.h>
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>

 int main(int argc,char *argv[])
 {
     if(argc!=3)
     {
         printf("%s: input IP & port\n",argv[0]);
         return 1;
     }
     int sockfd,numbytes;
     char buf[100] = "hello world";
     struct hostent *he;
     struct sockaddr_in their_addr;

     //将基本名字和地址转换
     he = gethostbyname(argv[1]);

     //建立一个TCP套接口
     if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1)
     {
         perror("socket");
         exit(1);
     }

     //初始化结构体
     their_addr.sin_family = AF_INET;
     their_addr.sin_port = htons(atoi(argv[2]));
     their_addr.sin_addr = *((struct in_addr *)he->h_addr);
     bzero(&(their_addr.sin_zero),8);

     //和服务器建立连接
     if(connect(sockfd,(struct sockaddr *)&their_addr,sizeof(struct sockaddr))==-1)
     {
         perror("connect");
         exit(1);
     }


     //向服务器发送字符串
     while(1)
     {
         if(send(sockfd,buf,strlen(buf),0)==-1)
         {
             perror("send");
             exit(1);
         }
         sleep(2);
     }
     memset(buf,0,sizeof(buf));

     close(sockfd);
     return 0;
 }

运行：
$ ./bin/server    
server is running!
Accepted connection on descriptor 5 (host=10.32.49.10, port=39001)
recv: hello world
recv: hello world
recv: hello world
recv: hello world

./bin/client 10.32.49.10 7092

异步IO：
在一个进程发出IO请求后直接返回，内核在整个操作（包括将数据复制到进程缓冲区）完成后通知进程，如图：

代码
server端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <aio.h>
 #include <pthread.h>

 #define BUF_SIZE 1024


 void aio_completion_handler(sigval_t sigval);

 void setup_io(int fd, aiocb& my_aiocb)
 {
     //初始化AIO请求
     bzero( (char *)&my_aiocb, sizeof(struct aiocb) );
     my_aiocb.aio_fildes = fd;
     my_aiocb.aio_buf = malloc(BUF_SIZE+1);
     my_aiocb.aio_nbytes = BUF_SIZE;
     my_aiocb.aio_offset = 0;

     //设置线程回调函数
     my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;
     my_aiocb.aio_sigevent.sigev_notify_function = aio_completion_handler;
     my_aiocb.aio_sigevent.sigev_notify_attributes = NULL;
     my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;
 }

 //回调函数
 void aio_completion_handler(sigval_t sigval)
 {
     struct aiocb *req;
     int ret;

     req = (struct aiocb *)sigval.sival_ptr;

     if (aio_error(req) == 0)
     {
         if((ret = aio_return(req)) > 0)
         {
             printf("Thread id %u recv:%s\n", (unsigned int)pthread_self(), (char*)req->aio_buf);
         }
     }

     char* buf = (char*)req->aio_buf;

     if(send(req->aio_fildes, buf, strlen(buf), 0) == -1)
     {
         perror("send");
         return;
     }

     close(req->aio_fildes);

     return;
 }

 int main()
 {
     int sockfd;
     int sin_size;
     struct sockaddr_in addr, cliaddr;

     //创建socket
     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
     {
         perror("createSocket");
         return -1;
     }

     //初始化socket结构
     memset(&addr, 0, sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_port = htons(7092);
     addr.sin_addr.s_addr = htonl(INADDR_ANY);

     //绑定套接口
     if(bind(sockfd,(struct sockaddr *)&addr,sizeof(struct sockaddr))==-1)
     {
         perror("bind");
         return -1;
     }

     //创建监听套接口
     if(listen(sockfd,10)==-1)
     {
         perror("listen");
         return -1;
     }


     printf("server is running!\n");

     //等待连接
     while(1)
     {
         int new_fd;
         struct aiocb my_aiocb;
         sin_size = sizeof(struct sockaddr_in);

         //接受连接
         if((new_fd = accept(sockfd, (struct sockaddr *)&cliaddr, (socklen_t*)&sin_size))==-1)
         {
             perror("accept");
             return -1;
         }

         printf("Thread id %u accept connect, fd: %d\n", (unsigned int)pthread_self(), new_fd);

         setup_io(new_fd, my_aiocb);
         aio_read(&my_aiocb);
     }
     close(sockfd);
 }

client端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <netdb.h>
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>

 int main(int argc,char *argv[])
 {
     if(argc!=3)
     {
         printf("%s: input IP & port\n",argv[0]);
         return 1;
     }
     int sockfd,numbytes;
     char buf[100] = "hello world";
     struct hostent *he;
     struct sockaddr_in their_addr;

     //将基本名字和地址转换
     he = gethostbyname(argv[1]);

     //建立一个TCP套接口
     if((sockfd = socket(AF_INET,SOCK_STREAM,0))==-1)
     {
         perror("socket");
         exit(1);
     }

     //初始化结构体
     their_addr.sin_family = AF_INET;
     their_addr.sin_port = htons(atoi(argv[2]));
     their_addr.sin_addr = *((struct in_addr *)he->h_addr);
     bzero(&(their_addr.sin_zero),8);

     //和服务器建立连接
     if(connect(sockfd,(struct sockaddr *)&their_addr,sizeof(struct sockaddr))==-1)
     {
         perror("connect");
         exit(1);
     }


     //向服务器发送字符串
     if(send(sockfd,buf,strlen(buf),0)==-1)
     {
         perror("send");
         exit(1);
     }

         //接收数据
     if((numbytes = recv(sockfd, buf, 100, 0)) == -1)
     {
         perror("recv");
         return 1;
     }

     printf("recv: %s\n", buf);

     close(sockfd);
     return 0;
 }

运行：
$ ./bin/server 
server is running!
Thread id  2505492000 accept connect, fd: 4
Thread id  1084246368 recv:hello world
（注意：线程ID不一样）

$ ./bin/client 10.32.49.10 7092
recv: hello world


信号驱动IO：
使用信号驱动I/O时，当网络套接字可读后，内核通过发送 SIGIO信号通知应用进程，于是应用可以开始读取数据。如图：

为了让套接字描述符可以工作于信号驱动I/O模式，应用进程必须完成如下三步设置： 
1.注册SIGIO信号处理程序。(安装信号处理器) 
2.使用fcntl的F_SETOWN命令，设置套接字所有者。（设置套接字的所有者） 
3.使用fcntl的F_SETFL命令，置O_ASYNC标志，允许套接字信号驱动I/O。（允许这个套接字进行信号输入输出）
注意，必须保证在设置套接字所有者之前，向系统注册信号处理程序，否则就有可能在fcntl调用后，信号处理程序注册前内核向应用交付SIGIO信号，导致应用丢失此信号。

在UDP编程中使用信号驱动I/O，此时SIGIO信号产生于下面两种情况： 
套接字收到一个数据报。 
套接字上发生了异步错误。 
因此，当应用因为收到一个UDP数据报而产生的SIGIO时，要么可以调用recvfrom读取该数据报，要么得到一个异步错误。 
对于TCP编程，信号驱动I/O就没有太大意义了，因为对于流式套接字而言，有很多情况都可以导致SIGIO产生，而应用又无法区分是什么具体情况导致该信号产生的