int main(int argc, char **argv)
{
   int listenfd, connfd;
   struct sockaddr_in clientaddr;
   socklen_t clientlen = sizeof(clientaddr);
   Signal(SIGCHLD, sigchld_handler);
   listenfd = Open_listenfd(argv[1]);

   while (1) {
      connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen);

      if (Fork() == 0) {
         Close(listenfd); /* Child closes its listening socket */
         echo(connfd);    /* Child services client */
         Close(connfd);   /* Child closes connection with client */
         exit(0);         /* Child exits */
      }
      Close(connfd); /* Parent closes connected socket (important!) */
   }
}

int main(int argc, char **argv){
    int listenfd, *connfdp
    socklen_t clientlen;
    struct sockaddr_in clientaddr;
    pthread_t tid;
    
    if (argc != 2) {
        fprintf(stderr, "usage: %s <port>\n", argv[0]);
        exit(0);
    }

    listenfd = open_listenfd(argv[1]);
    while (1) {
        clientlen = sizeof(clientaddr);
        connfdp = Malloc(sizeof(int));
        *connfdp = Accept(listenfd,  
              (SA *)&clientaddr, &clientlen);
        Pthread_create(&tid, NULL, thread, connfdp);
    }
}

/* thread routine */
void *thread(void *vargp)
{
    int connfd = *((int *)vargp);

    Pthread_detach(pthread_self());
    Free(vargp);
    echo(connfd);
    Close(connfd);
    return NULL;
}

#include “csapp.h”

int main(int argc, argv)
{
    int listenfd, connfd;

    socklen_t clientlen=sizeof(struct sockaddr_in);
    struct sockaddr_in clientaddr;
    fd_set read_set, ready_set;

    if (argc != 2) {
       fprintf(stderr, “usage: %s <port>\n”,argv[0]);
       exit(0);
    }

    listenfd = Open_listenfd(argv[1]);
    FD_ZERO(&read_set);
    FD_SET(STDIN_FILENO, &read_set);
    FD_SET(listenfd, &read_set);

    while(1) {
        ready_set = read_set;
        Select(listenfd+1, &ready_set,
               NULL, NULL, NULL);
        if (FD_ISSET(STDIN_FILENO, &ready_set)
            /*read command line from stdin */
            command(); 
        if (FD_ISSET(listenfd, &ready_set)){
            connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
            echo(connfd);
        }
    }
}

#include “csapp.h”
typedef struct {/* represents a pool of connected descriptors */
  int maxfd;
  fd_set read_set;
  fd_set ready_set;
  int nready;
  int maxi;
  int clientfd[FD_SETSIZE];
  rio_t clientrio[FD_SETSIZE];
} pool;

 int byte_cnt = 0; /*counts total bytes received by server */
 
 
 int main()
 {
  int listenfd, connfd;

  socketlen_t clientlen = sizeof(struct sockaddr_in);
  struct sockaddr_in clientaddr;
  static pool pool ;
  if (argc != 2) {
  fprintf(stderr, “usage” %s <port>\n”, argv[0]);
  exit(0);
  }

  listenfd = Open_listenfd(argv[1]);
  init_pool(listenfd, &pool);

  while (1) {
    /* wait for listening/connected descriptor(s) to become ready*/
    pool.ready_set = pool.read_set;
    pool.nready = Select(pool.maxfd+1,&pool.ready_set,  NULL,NULL,NULL);
    /* If listening descriptor ready, add new client to pool*/
    if (FD_ISSET(listenfd, &pool.ready_set)) {
        connfd=Accept(listenfd, (SA *)&clientaddr, &clientlen);
        add_client(connfd, &pool);
    }
       /*Echo a text line form each ready connected descriptor */
    check_clients(&pool);
  }
}
void init_pool(int listenfd, pool *p)
{
  /*Initially, there are no connected descriptors */
  int i;
  p->maxi = -1;
  for (i = 0; i < FD_SETSIZE; i++)
      p->clientfd[i] = -1;
  /* Initially, listenfd is only member of select read set */
  p->maxfd = listenfd ;
  FD_ZERO(&p->read_set);
  FD_SET(listenfd, &p->read_set);
}

void add_client(int connfd, pool *p)
{
  int i;
  p->nready--;
  for (i = 0; i < FD_SETSIZE; i++)  /* Find an available slot */
  if (p->clientfd[i] < 0) {
      /* Add connected descriptor to the pool */
      p->clientfd[i] = connfd;
      Rio_readinitb(&p->clientrio[i], connfd);
      /*Add the descriptor to descriptor set */
      FD_SET(connfd, &p->read_set);
      /* Update max descriptor and pool highwater mark */
      if (connfd > p->maxfd)
          p->maxfd = connfd ;
      if (i > p->maxi)
          p->maxi = i;
      break;
  }
  if (i == FD_SETSIZE)   /* Couldn’t find an empty slot */
  app_error(“add_client error: Too many clients”);
}

void check_clients(pool *p)
{
  int i, connfd, n;
  char buf[MAXLINE];
  rio_t rio;
  for (i = 0; (i <= p->maxi) && (p->nready > 0); i++) {
      connfd = p->clientfd[i];
      rio = p->clientrio[i];

      /*If the descriptor is ready, echo a text line from it */
      if ((connfd>0) && (FD_ISSET(connfd, &p->ready_set))) {

         p->nready--;
         if ((n = Rio_readlineb(&rio, buf, MAXLINE)) != 0) {
             byte_cnt += n;
             printf(“Server recerived %d (%d total)
                 bytes on fd %d\n”, n, byte_cnt, connfd);
             Rio_writen(connfd, buf, n);
          }

          /* EOF detected, remove descriptor from pool */
          else {
              Close(connfd);
              FD_CLR(connfd, &p->read_set);
              p->clientfd[i]=-1;
         }

     }
  }
}