#include <sys/socket.h>

int shutdown(int sockfd, int how);

#include <unistd.h>

int close(int fd);

int select(int nfds, fd_set *_Nullable restrict readfds,
                  fd_set *_Nullable restrict writefds,
                  fd_set *_Nullable restrict exceptfds,
                  struct timeval *_Nullable restrict timeout);

WARNING:  select()  can monitor only file descriptors numbers that are less than FD_SETSIZE (1024)—an unreasonably low limit for many
modern applications—and this limitation will not change.  All modern applications should instead use poll(2) or  epoll(7),  which  do
not suffer this limitation.

select()  allows a program to monitor multiple file descriptors, waiting until one or more of the file descriptors become "ready" for
some class of I/O operation (e.g., input possible).  A file descriptor is considered ready if it is possible to perform a correspond‐
ing I/O operation (e.g., read(2), or a sufficiently small write(2)) without blocking.

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

DESCRIPTION
       poll()  performs  a  similar  task  to  select(2): it waits for one of a set of file descriptors to become ready to perform I/O.  The
       Linux-specific epoll(7) API performs a similar task, but offers features beyond those found in poll().

       The set of file descriptors to be monitored is specified in the fds argument, which is an array of structures of the following form:

           struct pollfd {
               int   fd;         /* file descriptor */
               short events;     /* requested events */
               short revents;    /* returned events */
           };

       The caller should specify the number of items in the fds array in nfds.

       The field fd contains a file descriptor for an open file.  If this field is negative, then the corresponding events field is  ignored
       and  the  revents  field returns zero.  (This provides an easy way of ignoring a file descriptor for a single poll() call: simply set
       the fd field to its bitwise complement.)

       The field events is an input parameter, a bit mask specifying the events the application is interested in for the file descriptor fd.
       This field may be specified as zero, in which case the only events that can be returned in revents are POLLHUP, POLLERR, and POLLNVAL
       (see below).

       The field revents is an output parameter, filled by the kernel with the events that actually occurred.  The bits returned in  revents
       can  include any of those specified in events, or one of the values POLLERR, POLLHUP, or POLLNVAL.  (These three bits are meaningless
       in the events field, and will be set in the revents field whenever the corresponding condition is true.)

       If none of the events requested (and no error) has occurred for any of the file descriptors, then poll()  blocks  until  one  of  the
       events occurs.

       The  timeout  argument  specifies  the number of milliseconds that poll() should block waiting for a file descriptor to become ready.
       The call will block until either:

       •  a file descriptor becomes ready;

       •  the call is interrupted by a signal handler; or

       •  the timeout expires.

       Note that the timeout interval will be rounded up to the system clock granularity, and kernel scheduling delays mean that the  block‐
       ing  interval may overrun by a small amount.  Specifying a negative value in timeout means an infinite timeout.  Specifying a timeout
       of zero causes poll() to return immediately, even if no file descriptors are ready.

       The bits that may be set/returned in events and revents are defined in <poll.h>:

NAME
       epoll - I/O event notification facility

SYNOPSIS
       #include <sys/epoll.h>

DESCRIPTION
       The epoll API performs a similar task to poll(2): monitoring multiple file descriptors to see if I/O is possible on any of them.  The
       epoll API can be used either as an edge-triggered or a level-triggered interface and scales well to large numbers of watched file de‐
       scriptors.

       The  central concept of the epoll API is the epoll instance, an in-kernel data structure which, from a user-space perspective, can be
       considered as a container for two lists:

       •  The interest list (sometimes also called the epoll set): the set of file descriptors that the process has registered  an  interest
          in monitoring.

       •  The ready list: the set of file descriptors that are "ready" for I/O.  The ready list is a subset of (or, more precisely, a set of
          references to) the file descriptors in the interest list.  The ready list is dynamically populated by the kernel as  a  result  of
          I/O activity on those file descriptors.

       The following system calls are provided to create and manage an epoll instance:

       •  epoll_create(2)  creates  a  new  epoll  instance  and  returns  a  file  descriptor referring to that instance.  (The more recent
          epoll_create1(2) extends the functionality of epoll_create(2).)

       •  Interest in particular file descriptors is then registered via epoll_ctl(2), which adds items to the interest list  of  the  epoll
          instance.

       •  epoll_wait(2)  waits  for  I/O events, blocking the calling thread if no events are currently available.  (This system call can be
          thought of as fetching items from the ready list of the epoll instance.)

 Level-triggered and edge-triggered
       The epoll event distribution interface is able to behave both as edge-triggered (ET) and as level-triggered (LT).  The difference be‐
       tween the two mechanisms can be described as follows.  Suppose that this scenario happens:

       (1)  The file descriptor that represents the read side of a pipe (rfd) is registered on the epoll instance.

       (2)  A pipe writer writes 2 kB of data on the write side of the pipe.

       (3)  A call to epoll_wait(2) is done that will return rfd as a ready file descriptor.

       (4)  The pipe reader reads 1 kB of data from rfd.

       (5)  A call to epoll_wait(2) is done.

       If  the  rfd file descriptor has been added to the epoll interface using the EPOLLET (edge-triggered) flag, the call to epoll_wait(2)
       done in step 5 will probably hang despite the available data still present in the file input buffer; meanwhile the remote peer  might
       be expecting a response based on the data it already sent.  The reason for this is that edge-triggered mode delivers events only when
       changes occur on the monitored file descriptor.  So, in step 5 the caller might end up waiting for some data that is already  present
       inside  the  input  buffer.   In the above example, an event on rfd will be generated because of the write done in 2 and the event is
       consumed in 3.  Since the read operation done in 4 does not consume the whole buffer data, the call to epoll_wait(2) done in  step  5
       might block indefinitely.

       An  application that employs the EPOLLET flag should use nonblocking file descriptors to avoid having a blocking read or write starve
       a task that is handling multiple file descriptors.  The suggested way to use epoll as an edge-triggered  (EPOLLET)  interface  is  as
       follows:

       (1)  with nonblocking file descriptors; and

       (2)  by waiting for an event only after read(2) or write(2) return EAGAIN.

       By contrast, when used as a level-triggered interface (the default, when EPOLLET is not specified), epoll is simply a faster poll(2),
       and can be used wherever the latter is used since it shares the same semantics.

       Since even with edge-triggered epoll, multiple events can be generated upon receipt of multiple chunks of data, the  caller  has  the
       option  to  specify the EPOLLONESHOT flag, to tell epoll to disable the associated file descriptor after the receipt of an event with
       epoll_wait(2).  When the EPOLLONESHOT flag is specified, it is the  caller's  responsibility  to  rearm  the  file  descriptor  using
       epoll_ctl(2) with EPOLL_CTL_MOD.

       If  multiple  threads  (or  processes,  if  child  processes  have inherited the epoll file descriptor across fork(2)) are blocked in
       epoll_wait(2) waiting on the same epoll file descriptor and a file descriptor in the interest list that is marked for  edge-triggered
       (EPOLLET)  notification  becomes  ready, just one of the threads (or processes) is awoken from epoll_wait(2).  This provides a useful
       optimization for avoiding "thundering herd" wake-ups in some scenarios.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <signal.h>
#include <string.h>


static void sig_handler(int sig)
{
   if(sig == SIGPIPE)
   {
        write(1,"server recv SIGPIPE\n",sizeof("server recv SIGPIPE\n"));
   }
}

int main(int argc,char *argv[])
{
   int fd = -1,clientfd = -1;
   struct sockaddr_in servAddr,clientAddr;
   int len,clientAddrLen;
   char buf[128];

   signal(SIGPIPE,sig_handler);


   fd = socket(AF_INET,SOCK_STREAM,0);
   if(fd < 0)
   {
      printf("create socket failure\n");
      exit(-1);
   }

   memset(&servAddr,0x0,sizeof(struct sockaddr_in));
   servAddr.sin_family = AF_INET;
   servAddr.sin_addr.s_addr = INADDR_ANY;
   servAddr.sin_port = htons(8010);   

   if(bind(fd,(struct sockaddr *)&servAddr,sizeof(struct sockaddr_in)) < 0)
   {
      printf("bind addr failure\n");
      exit(-1);
   }

   listen(fd,5);

   clientAddrLen = sizeof(struct sockaddr_in);
   clientfd = accept(fd,(struct sockaddr *)&clientAddr,&clientAddrLen);
      
   len = send(clientfd,"welcome to my server",sizeof("welcome to my server")-1,0);

   while((len = recv(clientfd,buf,128-1,0)) > 0)
   {
       buf[len] = 0;
       if(strcmp(buf,"SHUT_RD") == 0)
       {
          printf("SHUT_RD operation\n");

          shutdown(clientfd,SHUT_RD);
          send(clientfd,"recv SHUT_RD",sizeof("recv SHUT_RD")-1,0);
       }
       else if(strcmp(buf,"SHUT_WR") == 0)
       {
          printf("SHUT_WR operation\n");

          shutdown(clientfd,SHUT_WR);
          send(clientfd,"recv SHUT_WR",sizeof("recv SHUT_WR")-1,0);          
       }
       else if(strcmp(buf,"SHUT_RDWR") == 0)
       {
          printf("SHUT_RDWR operation\n");
          
          shutdown(clientfd,SHUT_RDWR);
          send(clientfd,"recv SHUT_RDWR",sizeof("recv SHUT_RDWR")-1,0);
       }
       else{
           printf("recv: %s\n",buf);
           send(clientfd,"server: hello,client",sizeof("server: hello,client")-1,0);
       }
   }
   
   printf("quit(len: %d)\n",len);
   if(len == 0)
   {
       while(1)
         sleep(1000);
   }
   return 0x0;
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <signal.h>
#include <arpa/inet.h>

void signal_handler(int sig)
{
    if(sig == SIGPIPE)
    {
         write(1,"client recv SIGPIPE\n",sizeof("client recv SIGPIPE\n"));
    }
}

static void *thread_proc(void *arg)
{
     char buf[128];
     int sz;
     int fd = (int)arg;
     printf("proc fd: %d\n",fd);

     while(1)
     {
          sz = recv(fd,buf,128-1,0);
          if(sz < 0)
          {
             printf("recv error\n");
             pthread_exit(0);
          }
          else if(sz == 0)
          {
             printf("server closed\n");
             pthread_exit(0);
          }
          else{
             buf[sz] = 0;
             printf("->: %s\n",buf);
          }
     }
}


int main(int argc,char *argv[])
{
     int fd;
     struct sockaddr_in serverAddr;
     char buf[128];
     int sz;
     pthread_t pid;

     signal(SIGPIPE,signal_handler);  

     fd = socket(AF_INET,SOCK_STREAM,0);
     if(fd < 0)
     {
         printf("create socket failure\n");
         exit(-1);
     }

     memset(&serverAddr,0x0,sizeof(struct sockaddr_in));

     serverAddr.sin_family = AF_INET;
     serverAddr.sin_addr.s_addr = inet_addr(argv[1]);
     serverAddr.sin_port = htons(atoi(argv[2]));

     if(connect(fd,(struct sockaddr *)&serverAddr,sizeof(struct sockaddr_in)) < 0)
     {
        printf("connect %s:%s failure\n",argv[1],argv[2]);
        exit(-1);
     }
     
     printf("connect %s:%s successful\n",argv[1],argv[2]);
     
     if(pthread_create(&pid,NULL,thread_proc,(void *)fd) < 0)
     {
         printf("create thread failure\n");
         exit(-2);
     }
     printf("pass fd: %d\n",fd);

     while(1)
     {
         sz = read(0,buf,128);
         if(sz < 0)
         {
             printf("read input error\n");
             break;
         }
         buf[sz-1]=0;    //clear the "\n"

         if(strcmp(buf,"CLOSE_RD") == 0)
         {
             printf("Client close RD\n");
             shutdown(fd,SHUT_RD);
         }
         else if(strcmp(buf,"CLOSE_WR") == 0)
         {
              printf("Client close WR\n");
              shutdown(fd,SHUT_WR);
         }
         else if(strcmp(buf,"CLOSE_RDWR") == 0)
         {
              printf("Client close RDWR\n");
              shutdown(fd,SHUT_RDWR);
         }
         else{
            sz = send(fd,buf,sz,0);
            if(sz < 0)
            {
               printf("send error\n");
               break;
            }
         }
     }
    while(1)
        sleep(1000);
}

# ./client 127.0.0.1 8010
connect 127.0.0.1:8010 successful
pass fd: 3
proc fd: 3
->: welcome to my server
SHUT_RD
->: recv SHUT_RD
hello
world
hello1
world1