/* A simple server in the internet domain using TCP
   The port number is passed as an argument */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <netinet/in.h>

void error(const char *msg)
{
    perror(msg);
    exit(1);
}

int main(int argc, char *argv[])
{
     if (argc < 2) {
         fprintf(stderr,"ERROR, no port provided\n");
         exit(1);
     }
     int sockfd, newsockfd, portno;
     socklen_t clilen;
     char buffer[256];
     struct sockaddr_in serv_addr, cli_addr;
    
     //1. create socket
     sockfd = socket(AF_INET, SOCK_STREAM, 0);
     if (sockfd < 0) 
        error("ERROR opening socket");

     bzero((char *) &serv_addr, sizeof(serv_addr));
     portno = atoi(argv[1]);
     serv_addr.sin_family = AF_INET;
     serv_addr.sin_addr.s_addr = INADDR_ANY;
     serv_addr.sin_port = htons(portno);
     // 2. 绑定端口
     if (bind(sockfd, (struct sockaddr *) &serv_addr,
              sizeof(serv_addr)) < 0) 
              error("ERROR on binding");
     // 3. 开始监听
     listen(sockfd,1);	 
     clilen = sizeof(cli_addr);
     while(1){
	//sleep(10000);
     // 4. 阻塞在这里，直到有连接进来
     newsockfd = accept(sockfd, 
                 (struct sockaddr *) &cli_addr, 
                 &clilen);
     
     if (newsockfd < 0) 
          error("ERROR on accept");
     bzero(buffer,256);
     int n;
     while((n=read(newsockfd,buffer,255))>0){
        printf("get data:%s",buffer);
        if(write(newsockfd,buffer,n) != n){
            error("ERROR write");
        }
     }
     close(newsockfd);
     }
     close(sockfd);
     return 0; 
}

 int sysctl_max_syn_backlog = 256;
 int reqsk_queue_alloc(struct request_sock_queue *queue, unsigned int nr_table_entries) {
         size_t lopt_size = sizeof(struct listen_sock);
         struct listen_sock *lopt;
 
         nr_table_entries = min_t(u32, nr_table_entries, sysctl_max_syn_backlog);
         nr_table_entries = max_t(u32, nr_table_entries, 8);
         nr_table_entries = roundup_pow_of_two(nr_table_entries + 1);
         lopt_size += nr_table_entries * sizeof(struct request_sock *);
         if (lopt_size > PAGE_SIZE)
                 lopt = __vmalloc(lopt_size,
                         GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO,
                         PAGE_KERNEL);
         else
                 lopt = kzalloc(lopt_size, GFP_KERNEL);
         if (lopt == NULL)
                 return -ENOMEM;
 
         for (lopt->max_qlen_log = 3;
              (1 << lopt->max_qlen_log) < nr_table_entries;
              lopt->max_qlen_log++);
 
         get_random_bytes(&lopt->hash_rnd, sizeof(lopt->hash_rnd));
         rwlock_init(&queue->syn_wait_lock);
         queue->rskq_accept_head = NULL;
         lopt->nr_table_entries = nr_table_entries;
 
         write_lock_bh(&queue->syn_wait_lock);
         queue->listen_opt = lopt;
         write_unlock_bh(&queue->syn_wait_lock);
 
         return 0;
 }