大家都知道各类网络服务器程序的编写步骤，并且都知道网络服务器就两大类：循环服务和并发服务。这里附上源代码来个小结吧。

    下面是一个TCP循环服务器源程序，因为用fork()进行多进程服务，父进程负责监听和连接，子进程负责与客户端进行通信，所以这种服务现实中也有用。源代码如下：

 
  
  1. /*----------------------源代码开始--------------------------------------------*/ 
  2. #include <stdio.h> 
  3. #include <stdlib.h> 
  4. #include <errno.h> 
  5. #include <string.h> 
  6. #include <sys/types.h> 
  7. #include <netinet/in.h> 
  8. #include <sys/socket.h> 
  9. #include <sys/wait.h> 
  10. /********************************************************************* 
  11. *filename: cycletcpserver.c 
  12. *purpose: 循环tcp服务端程序 
  13. *tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.9999mb.com) 
  14. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  15. *date time:2006-07-04 22:00:00 
  16. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
  17. * 但请遵循GPL 
  18. *Thanks to: Google.com 
  19. *********************************************************************/ 
  20. int main(int argc, char ** argv) 
  21. { 
  22.     int sockfd,new_fd; /* 监听socket: sock_fd,数据传输socket: new_fd */ 
  23.     struct sockaddr_in my_addr; /* 本机地址信息 */ 
  24.     struct sockaddr_in their_addr; /* 客户地址信息 */ 
  25.     unsigned int sin_size, myport, lisnum; 
  26.  
  27.     if(argv[1])  myport = atoi(argv[1]); 
  28.     else myport = 7838; 
  29.  
  30.     if(argv[2])  lisnum = atoi(argv[2]); 
  31.     else lisnum = 2; 
  32.  
  33.     if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) { 
  34.         perror("socket"); 
  35.         exit(1); 
  36.     } 
  37.     my_addr.sin_family=PF_INET; 
  38.     my_addr.sin_port=htons(myport); 
  39.     my_addr.sin_addr.s_addr = INADDR_ANY; 
  40.     bzero(&(my_addr.sin_zero), 0); 
  41.     if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) { 
  42.         perror("bind"); 
  43.         exit(1); 
  44.     } 
  45.  
  46.     if (listen(sockfd, lisnum) == -1) { 
  47.         perror("listen"); 
  48.         exit(1); 
  49.     } 
  50.     while(1) { 
  51.         sin_size = sizeof(struct sockaddr_in); 
  52.         if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) { 
  53.             perror("accept"); 
  54.             continue; 
  55.         } 
  56.         printf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr)); 
  57.         if (!fork()) { /* 子进程代码段 */ 
  58.             if (send(new_fd, "Hello, world!\n", 14, 0) == -1) { 
  59.                 perror("send"); 
  60.                 close(new_fd); 
  61.                 exit(0); 
  62.             } 
  63.         } 
  64.         close(new_fd); /*父进程不再需要该socket*/ 
  65.         waitpid(-1,NULL,WNOHANG);/*等待子进程结束，清除子进程所占用资源*/ 
  66.     } 
  67. } 
  68. /*----------------------源代码结束--------------------------------------------*/ 
 
  
    下面是一个演示I/O多路复用的源程序，是一个端口转发程序，但它的用处相当大，实际应用中的各类代理软件或端口映射软件都是基于这样的代码的，比如Windows下的WinGate、WinProxy等都是在此基础上实现的。源代码如下：
 
  
 
  
  1. /*----------------------源代码开始--------------------------------------------*/ 
  2. #include <stdlib.h> 
  3. #include <stdio.h> 
  4. #include <unistd.h> 
  5. #include <sys/time.h> 
  6. #include <sys/types.h> 
  7. #include <string.h> 
  8. #include <signal.h> 
  9. #include <sys/socket.h> 
  10. #include <netinet/in.h> 
  11. #include <arpa/inet.h> 
  12. #include <errno.h> 
  13.  
  14. static int forward_port; 
  15.  
  16. #undef max 
  17. #define max(x,y) ((x) > (y) ? (x) : (y)) 
  18.  
  19. /*************************关于本文档************************************ 
  20. *filename: tcpforwardport.c 
  21. *purpose: 演示了select的用法，这是一个极好的代理软件核心，专门作端口映射用 
  22. *tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.9999mb.com) 
  23. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  24. *date time:2006-07-05 19:00:00 
  25. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
  26. * 但请遵循GPL 
  27. *Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码 
  28. *Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
  29. *********************************************************************/ 
  30.  
  31. static int listen_socket (int listen_port) { 
  32.     struct sockaddr_in a; 
  33.     int s; 
  34.     int yes; 
  35.     if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) { 
  36.         perror ("socket"); 
  37.         return -1; 
  38.     } 
  39.     yes = 1; 
  40.     if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, sizeof (yes)) < 
  41. 0) { 
  42.         perror ("setsockopt"); 
  43.         close (s); 
  44.         return -1; 
  45.     } 
  46.     memset (&a, 0, sizeof (a)); 
  47.     a.sin_port = htons (listen_port); 
  48.     a.sin_family = AF_INET; 
  49.     if (bind(s, (struct sockaddr *) &a, sizeof (a)) < 0) { 
  50.         perror ("bind"); 
  51.         close (s); 
  52.         return -1; 
  53.     } 
  54.     printf ("accepting connections on port %d\n", (int) listen_port); 
  55.     listen (s, 10); 
  56.     return s; 
  57. } 
  58.  
  59. static int connect_socket (int connect_port, char *address) { 
  60.     struct sockaddr_in a; 
  61.     int s; 
  62.     if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) { 
  63.         perror ("socket"); 
  64.         close (s); 
  65.         return -1; 
  66.     } 
  67.  
  68.     memset (&a, 0, sizeof (a)); 
  69.     a.sin_port = htons (connect_port); 
  70.     a.sin_family = AF_INET; 
  71.  
  72.     if (!inet_aton(address, (struct in_addr *) &a.sin_addr.s_addr)) { 
  73.         perror ("bad IP address format"); 
  74.         close (s); 
  75.         return -1; 
  76.     } 
  77.  
  78.     if (connect(s, (struct sockaddr *) &a, sizeof (a)) < 0) { 
  79.         perror ("connect()"); 
  80.         shutdown (s, SHUT_RDWR); 
  81.         close (s); 
  82.         return -1; 
  83.     } 
  84.     return s; 
  85. } 
  86.  
  87. #define SHUT_FD1 { \ 
  88.     if (fd1 >= 0) {   \ 
  89.         shutdown (fd1, SHUT_RDWR);  \ 
  90.         close (fd1);  \ 
  91.         fd1 = -1;     \ 
  92.     }   \ 
  93. } 
  94.  
  95. #define SHUT_FD2 { \ 
  96.     if (fd2 >= 0) {   \ 
  97.         shutdown (fd2, SHUT_RDWR);  \ 
  98.         close (fd2);  \ 
  99.         fd2 = -1;     \ 
  100.     }   \ 
  101. } 
  102.  
  103. #define BUF_SIZE 1024 
  104.  
  105. int main (int argc, char **argv) { 
  106.     int h; 
  107.     int fd1 = -1, fd2 = -1; 
  108.     char buf1[BUF_SIZE], buf2[BUF_SIZE]; 
  109.     int buf1_avail, buf1_written; 
  110.     int buf2_avail, buf2_written; 
  111.  
  112.     if (argc != 4) { 
  113.         fprintf (stderr, "Usage\n\tfwd   \n"); 
  114.         exit (1); 
  115.     } 
  116.  
  117.     signal (SIGPIPE, SIG_IGN); 
  118.  
  119.     forward_port = atoi (argv[2]); 
  120.  
  121.     /*建立监听socket*/ 
  122.     h = listen_socket (atoi (argv[1])); 
  123.     if (h < 0) exit (1); 
  124.  
  125.     for (;;) { 
  126.         int r, nfds = 0; 
  127.         fd_set rd, wr, er; 
  128.         FD_ZERO (&rd); 
  129.         FD_ZERO (&wr); 
  130.         FD_ZERO (&er); 
  131.         FD_SET (h, &rd); 
  132.  
  133.         /*把监听socket和可读socket三个一起放入select的可读句柄列表里*/ 
  134.         nfds = max (nfds, h); 
  135.         if (fd1 > 0 && buf1_avail < BUF_SIZE) { 
  136.             FD_SET (fd1, &rd); 
  137.             nfds = max (nfds, fd1); 
  138.         } 
  139.         if (fd2 > 0 && buf2_avail < BUF_SIZE) { 
  140.             FD_SET (fd2, &rd); 
  141.             nfds = max (nfds, fd2); 
  142.         } 
  143.  
  144.         /*把可写socket两个一起放入select的可写句柄列表里*/ 
  145.         if (fd1 > 0 && buf2_avail - buf2_written > 0) { 
  146.             FD_SET (fd1, &wr); 
  147.             nfds = max (nfds, fd1); 
  148.         } 
  149.         if (fd2 > 0 && buf1_avail - buf1_written > 0) { 
  150.             FD_SET (fd2, &wr); 
  151.             nfds = max (nfds, fd2); 
  152.         } 
  153.  
  154.         /*把有异常数据的socket两个一起放入select的异常句柄列表里*/ 
  155.         if (fd1 > 0) { 
  156.             FD_SET (fd1, &er); 
  157.             nfds = max (nfds, fd1); 
  158.         } 
  159.         if (fd2 > 0) { 
  160.             FD_SET (fd2, &er); 
  161.             nfds = max (nfds, fd2); 
  162.         } 
  163.  
  164.         /*开始select*/ 
  165.         r = select (nfds + 1, &rd, &wr, &er, NULL); 
  166.  
  167.         if (r == -1 && errno == EINTR) continue; 
  168.         if (r < 0) { 
  169.             perror ("select()"); 
  170.             exit (1); 
  171.         } 
  172.  
  173.         /*处理新连接*/ 
  174.         if (FD_ISSET (h, &rd)) { 
  175.             unsigned int l; 
  176.             struct sockaddr_in client_address; 
  177.             memset (&client_address, 0, l = sizeof (client_address)); 
  178.             r = accept (h, (struct sockaddr *)&client_address, &l); 
  179.             if (r < 0) { 
  180.                 perror ("accept()"); 
  181.             } else { 
  182.                 /*关闭原有连接，把新连接作为fd1，同时连接新的目标fd2*/ 
  183.                 SHUT_FD1; 
  184.                 SHUT_FD2; 
  185.                 buf1_avail = buf1_written = 0; 
  186.                 buf2_avail = buf2_written = 0; 
  187.                 fd1 = r; 
  188.                 fd2 = connect_socket (forward_port, argv[3]); 
  189.                 if (fd2 < 0) { 
  190.                     SHUT_FD1; 
  191.                 } else 
  192.                     printf ("connect from %s\n", inet_ntoa(client_address.sin_addr)); 
  193.             } 
  194.         } 
  195.  
  196.         /* NB: read oob data before normal reads */ 
  197.         if (fd1 > 0) 
  198.         if (FD_ISSET (fd1, &er)) { 
  199.             char c; 
  200.             errno = 0; 
  201.             r = recv (fd1, &c, 1, MSG_OOB); 
  202.             if (r < 1) { 
  203.                 SHUT_FD1; 
  204.             } else 
  205.                 send (fd2, &c, 1, MSG_OOB); 
  206.         } 
  207.  
  208.         if (fd2 > 0) 
  209.         if (FD_ISSET (fd2, &er)) { 
  210.             char c; 
  211.             errno = 0; 
  212.             r = recv (fd2, &c, 1, MSG_OOB); 
  213.             if (r < 1) { 
  214.                 SHUT_FD1; 
  215.             } else 
  216.                 send (fd1, &c, 1, MSG_OOB); 
  217.         } 
  218.  
  219.         /* NB: read data from fd1 */ 
  220.         if (fd1 > 0) 
  221.         if (FD_ISSET (fd1, &rd)) { 
  222.             r = read (fd1, buf1 + buf1_avail, BUF_SIZE - buf1_avail); 
  223.             if (r < 1) { 
  224.                 SHUT_FD1; 
  225.             } else 
  226.                 buf1_avail += r; 
  227.         } 
  228.  
  229.         /* NB: read data from fd2 */ 
  230.         if (fd2 > 0) 
  231.         if (FD_ISSET (fd2, &rd)) { 
  232.             r = read (fd2, buf2 + buf2_avail, BUF_SIZE - buf2_avail); 
  233.             if (r < 1) { 
  234.                 SHUT_FD2; 
  235.             } else 
  236.                 buf2_avail += r; 
  237.         } 
  238.  
  239.         /* NB: write data to fd1 */ 
  240.         if (fd1 > 0) 
  241.         if (FD_ISSET (fd1, &wr)) { 
  242.             r = write (fd1, buf2 + buf2_written, buf2_avail - buf2_written); 
  243.             if (r < 1) { 
  244.                 SHUT_FD1; 
  245.             } else 
  246.                 buf2_written += r; 
  247.         } 
  248.  
  249.         /* NB: write data to fd1 */ 
  250.         if (fd2 > 0) 
  251.         if (FD_ISSET (fd2, &wr)) { 
  252.             r = write (fd2, buf1 + buf1_written, buf1_avail - buf1_written); 
  253.             if (r < 1) { 
  254.                 SHUT_FD2; 
  255.             } else 
  256.                 buf1_written += r; 
  257.         } 
  258.  
  259.         /* check if write data has caught read data */ 
  260.         if (buf1_written == buf1_avail) buf1_written = buf1_avail = 0; 
  261.         if (buf2_written == buf2_avail) buf2_written = buf2_avail = 0; 
  262.  
  263.         /* one side has closed connection, keep writing to the other side until empty */ 
  264.         if (fd1 < 0 && buf1_avail - buf1_written == 0) { 
  265.             SHUT_FD2; 
  266.         } 
  267.         if (fd2 < 0 && buf2_avail - buf2_written == 0) { 
  268.             SHUT_FD1; 
  269.         } 
  270.     } 
  271.     return 0; 
  272. } 
  273. /*----------------------源代码结束--------------------------------------------*/