Socket

Socket是一种双向管道文件

文件属性

首先Socket是一个文件，就有读和写。当线程想要读取客户端传输来的数据时，就从客户端 Socket 文件中读取数据；当线程想要发送数据到客户端时，就向客户端 Socket 文件中写入数据。服务端为了区分不同应用，通常需要记录端口、客户端IP等

轮询扫描

多个Socket对象可以看作是一个集合（数组 / 链表），扫描的过程就是主动轮询遍历这个集合，观察Socket对象的变化，如果用一个线程去做也被称作 I/O多路复用技术。

响应式（观察者模式）

与主动轮询相对应的，被动监听Socket对象的改变，所有文件的读写都会经过操作系统，这一步叫事件注册。举例在Linux 的三种典型的 I/O 多路复用模型中 select、poll、epoll 模型中，采用 epoll，底层既是红黑二叉搜索树

附 epoll 实现的示例服务

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>
#define MAXEVENTS 64
static int
make_socket_non_blocking (int sfd)
{
int flags, s;
flags = fcntl (sfd, F_GETFL, 0);
if (flags == -1)
 {
   perror ("fcntl");
   return -1;
 }
flags |= O_NONBLOCK;
s = fcntl (sfd, F_SETFL, flags);
if (s == -1)
 {
   perror ("fcntl");
   return -1;
 }
return 0;
}
static int
create_and_bind (char *port)
{
struct addrinfo hints;
struct addrinfo *result, *rp;
int s, sfd;
memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */
hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
hints.ai_flags = AI_PASSIVE;     /* All interfaces */
s = getaddrinfo (NULL, port, &hints, &result);
if (s != 0)
 {
   fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
   return -1;
 }
for (rp = result; rp != NULL; rp = rp->ai_next)
 {
   sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
   if (sfd == -1)
     continue;
   s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
   if (s == 0)
     {
       /* We managed to bind successfully! */
       break;
     }
   close (sfd);
 }
if (rp == NULL)
 {
   fprintf (stderr, "Could not bind\n");
   return -1;
 }
freeaddrinfo (result);
return sfd;
}
int
main (int argc, char *argv[])
{
int sfd, s;
int efd;
struct epoll_event event;
struct epoll_event *events;
if (argc != 2)
 {
   fprintf (stderr, "Usage: %s [port]\n", argv[0]);
   exit (EXIT_FAILURE);
 }
sfd = create_and_bind (argv[1]);
if (sfd == -1)
 abort ();
s = make_socket_non_blocking (sfd);
if (s == -1)
 abort ();
s = listen (sfd, SOMAXCONN);
if (s == -1)
 {
   perror ("listen");
   abort ();
 }
efd = epoll_create1 (0);
if (efd == -1)
 {
   perror ("epoll_create");
   abort ();
 }
event.data.fd = sfd;
event.events = EPOLLIN | EPOLLET;
s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);
if (s == -1)
 {
   perror ("epoll_ctl");
   abort ();
 }
/* Buffer where events are returned */
events = calloc (MAXEVENTS, sizeof event);
/* The event loop */
while (1)
 {
   int n, i;
   n = epoll_wait (efd, events, MAXEVENTS, -1);
   for (i = 0; i < n; i++)
{
if ((events[i].events & EPOLLERR) ||
           (events[i].events & EPOLLHUP) ||
           (!(events[i].events & EPOLLIN)))
  {
           /* An error has occured on this fd, or the socket is not
              ready for reading (why were we notified then?) */
    fprintf (stderr, "epoll error\n");
    close (events[i].data.fd);
    continue;
  }
else if (sfd == events[i].data.fd)
  {
           /* We have a notification on the listening socket, which
              means one or more incoming connections. */
           while (1)
             {
               struct sockaddr in_addr;
               socklen_t in_len;
               int infd;
               char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
               in_len = sizeof in_addr;
               infd = accept (sfd, &in_addr, &in_len);
               if (infd == -1)
                 {
                   if ((errno == EAGAIN) ||
                       (errno == EWOULDBLOCK))
                     {
                       /* We have processed all incoming
                          connections. */
                       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);
                 }
               /* Make the incoming socket non-blocking and add it to the
                  list of fds to monitor. */
               s = make_socket_non_blocking (infd);
               if (s == -1)
                 abort ();
               event.data.fd = infd;
               event.events = EPOLLIN | EPOLLET;
               s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
               if (s == -1)
                 {
                   perror ("epoll_ctl");
                   abort ();
                 }
             }
           continue;
         }
       else
         {
           /* We have data on the fd waiting to be read. Read and
              display it. We must read whatever data is available
              completely, as we are running in edge-triggered mode
              and won't get a notification again for the same
              data. */
           int done = 0;
           while (1)
             {
               ssize_t count;
               char buf[512];
               count = read (events[i].data.fd, buf, sizeof buf);
               if (count == -1)
                 {
                   /* If errno == EAGAIN, that means we have read all
                      data. So go back to the main loop. */
                   if (errno != EAGAIN)
                     {
                       perror ("read");
                       done = 1;
                     }
                   break;
                 }
               else if (count == 0)
                 {
                   /* End of file. The remote has closed the
                      connection. */
                   done = 1;
                   break;
                 }
               /* Write the buffer to standard output */
               s = write (1, buf, count);
               if (s == -1)
                 {
                   perror ("write");
                   abort ();
                 }
             }
           if (done)
             {
               printf ("Closed connection on descriptor %d\n",
                       events[i].data.fd);
               /* Closing the descriptor will make epoll remove it
                  from the set of descriptors which are monitored. */
               close (events[i].data.fd);
             }
           }
       }
   }
 free (events);
 close (sfd);
 return EXIT_SUCCESS;
}