Linux下各类TCP网络服务器的实现源代码

最新推荐文章于 2022-11-25 15:27:19 发布
最新推荐文章于 2022-11-25 15:27:19 发布
阅读量1k 收藏 1
点赞数
分类专栏： Linux 文章标签： linux 服务器 tcp 网络 socket descriptor

http://www.linuxeden.com/forum/t146870.html

 

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

首先，循环网络服务器编程实现的步骤是这样的：

这种服务器模型是典型循环服务，如果不加上多进程/线程技术，此种服务吞吐量有限，大家都可以看到，如果前一个连接服务数据没有收发完毕后面的连接没办法处理。所以一般有多进程技术，对一个新连接启用一个新进程去处理，而监听socket继续监听。

/************关于本文档********************************************
*filename: Linux下各类TCP网络服务器的实现源代码
*purpose: 记录Linux下各类tcp服务程序源代码
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
*date time:2006-07-04 22:00:00
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
* 但请遵循GPL
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
*********************************************************************/

一个循环TCP服务源代码（因为用fork进行多进程服务了，所以这种服务现实中也有用）如下：

[cpp]  view plain copy
  1. /*----------------------源代码开始--------------------------------------------*/  
  2.   
  3. #include <stdio.h>  
  4.   
  5. #include <stdlib.h>  
  6.   
  7. #include <errno.h>  
  8.   
  9. #include <string.h>  
  10.   
  11. #include <sys/types.h>  
  12.   
  13. #include <netinet/in.h>  
  14.   
  15. #include <sys/socket.h>  
  16.   
  17. #include <sys/wait.h>  
  18.   
  19. /********************************************************************* 
  20.  
  21. *filename: cycletcpserver.c 
  22.  
  23. *purpose: 循环tcp服务端程序 
  24.  
  25. *tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com) 
  26.  
  27. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  28.  
  29. *date time:2006-07-04 22:00:00 
  30.  
  31. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
  32.  
  33. * 但请遵循GPL 
  34.  
  35. *Thanks to: Google.com 
  36.  
  37. *********************************************************************/  
  38.   
  39. int main(int argc, char ** argv)  
  40.   
  41. {  
  42.   
  43.     int sockfd,new_fd; /* 监听socket: sock_fd,数据传输socket: new_fd */  
  44.   
  45.     struct sockaddr_in my_addr; /* 本机地址信息 */  
  46.   
  47.     struct sockaddr_in their_addr; /* 客户地址信息 */  
  48.   
  49.     unsigned int sin_size, myport, lisnum;  
  50.   
  51.   
  52.   
  53.     if(argv[1])  myport = atoi(argv[1]);  
  54.   
  55.     else myport = 7838;  
  56.   
  57.   
  58.   
  59.     if(argv[2])  lisnum = atoi(argv[2]);  
  60.   
  61.     else lisnum = 2;  
  62.   
  63.   
  64.   
  65.     if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {  
  66.   
  67.         perror("socket");  
  68.   
  69.         exit(1);  
  70.   
  71.     }  
  72.   
  73.     my_addr.sin_family=PF_INET;  
  74.   
  75.     my_addr.sin_port=htons(myport);  
  76.   
  77.     my_addr.sin_addr.s_addr = INADDR_ANY;  
  78.   
  79.     bzero(&(my_addr.sin_zero), 0);  
  80.   
  81.     if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {  
  82.   
  83.         perror("bind");  
  84.   
  85.         exit(1);  
  86.   
  87.     }  
  88.   
  89.   
  90.   
  91.     if (listen(sockfd, lisnum) == -1) {  
  92.   
  93.         perror("listen");  
  94.   
  95.         exit(1);  
  96.   
  97.     }  
  98.   
  99.     while(1) {  
  100.   
  101.         sin_size = sizeof(struct sockaddr_in);  
  102.   
  103.         if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) {  
  104.   
  105.             perror("accept");  
  106.   
  107.             continue;  
  108.   
  109.         }  
  110.   
  111.         printf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));  
  112.   
  113.         if (!fork()) { /* 子进程代码段 */  
  114.   
  115.             if (send(new_fd, "Hello, world!\n", 14, 0) == -1) {  
  116.   
  117.                 perror("send");  
  118.   
  119.                 close(new_fd);  
  120.   
  121.                 exit(0);  
  122.   
  123.             }  
  124.   
  125.         }  
  126.   
  127.         close(new_fd); /*父进程不再需要该socket*/  
  128.   
  129.         waitpid(-1,NULL,WNOHANG);/*等待子进程结束，清除子进程所占用资源*/  
  130.   
  131.     }  
  132.   
  133. }  
  134.   
  135. /*----------------------源代码结束--------------------------------------------*/  


 

一个测试客户端代码如下：

[cpp]  view plain copy
  1. /*----------------------源代码开始--------------------------------------------*/  
  2.   
  3. #include <stdio.h>  
  4.   
  5. #include <stdlib.h>  
  6.   
  7. #include <errno.h>  
  8.   
  9. #include <string.h>  
  10.   
  11. #include <netdb.h>  
  12.   
  13. #include <sys/types.h>  
  14.   
  15. #include <netinet/in.h>  
  16.   
  17. #include <sys/socket.h>  
  18.   
  19. #define MAXDATASIZE 100 /*每次最大数据传输量 */  
  20.   
  21. /********************************************************************* 
  22.  
  23. *filename: cycletcpclient.c 
  24.  
  25. *purpose: 循环tcp客户端程序 
  26.  
  27. *tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com) 
  28.  
  29. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  30.  
  31. *date time:2006-07-04 22:20:00 
  32.  
  33. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
  34.  
  35. * 但请遵循GPL 
  36.  
  37. *Thanks to: Google.com 
  38.  
  39. *Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
  40.  
  41. *********************************************************************/  
  42.   
  43.   
  44.   
  45. int main(int argc, char *argv[])  
  46.   
  47. {  
  48.   
  49.     int sockfd, numbytes;  
  50.   
  51.     char buf[MAXDATASIZE];  
  52.   
  53.     struct hostent *he;  
  54.   
  55.     struct sockaddr_in their_addr;  
  56.   
  57.     unsigned int myport;  
  58.   
  59.   
  60.   
  61.     if(argv[2]) myport = atoi(argv[2]);  
  62.   
  63.     else myport = 7838;  
  64.   
  65.   
  66.   
  67.     if (argc != 3) {  
  68.   
  69.         fprintf(stderr,"usage: %s hostname port\n", argv[0]);  
  70.   
  71.         exit(1);  
  72.   
  73.     }  
  74.   
  75.     if((he=gethostbyname(argv[1]))==NULL) {  
  76.   
  77.         herror("gethostbyname");  
  78.   
  79.         exit(1);  
  80.   
  81.     }  
  82.   
  83.     if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {  
  84.   
  85.         perror("socket");  
  86.   
  87.         exit(1);  
  88.   
  89.     }  
  90.   
  91.     their_addr.sin_family=PF_INET;  
  92.   
  93.     their_addr.sin_port=htons(myport);  
  94.   
  95.     their_addr.sin_addr = *((struct in_addr *)he->h_addr);  
  96.   
  97.     bzero(&(their_addr.sin_zero),0);  
  98.   
  99.     if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1) {  
  100.   
  101.         perror("connect");  
  102.   
  103.         exit(1);  
  104.   
  105.     }  
  106.   
  107.     if ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) == -1) {  
  108.   
  109.         perror("recv");  
  110.   
  111.         exit(1);  
  112.   
  113.     }  
  114.   
  115.     buf[numbytes] = 0;  
  116.   
  117.     printf("Received: %s\n",buf);  
  118.   
  119.     close(sockfd);  
  120.   
  121.     return 0;  
  122.   
  123. }  
  124.   
  125. /*----------------------源代码结束--------------------------------------------*/  


 

用gcc cycletcpserver.c -o tcpserver和gcc cycletcpclient.c -o tcpclient分别编译上述代码后运行情况如下：
服务端运行显示：

administrator@ubuzlf:/data/example/c$ ./tcpserver
server: got connection from 127.0.0.1
server: got connection from 127.0.0.1
server: got connection from 127.0.0.1


客户端运行显示：

administrator@ubuzlf:/data/example/c$ ./tcpclient 127.0.0.1 7838
Received: Hello, world!

administrator@ubuzlf:/data/example/c$ ./tcpclient 127.0.0.1 7838
Received: Hello, world!

administrator@ubuzlf:/data/example/c$ ./tcpclient 127.0.0.1 7838
Received: Hello, world!


不得不说的一个概念性问题：阻塞与非阻塞
在阻塞服务中，当服务器运行到accept语句而没有客户连接服务请求到来，那么会发生什么情况? 这时服务器就会停止在accept语句上等待连接服务请求的到来；同样，当程序运行到接收数据语句recv时，如果没有数据可以读取，则程序同样会停止在接收语句上。这种情况称为阻塞(blocking)。
但如果你希望服务器仅仅注意检查是否有客户在等待连接，有就接受连接;否则就继续做其他事情，则可以通过将 socket设置为非阻塞方式来实现:非阻塞socket在没有客户在等待时就使accept调用立即返回 。
通过设置socket为非阻塞方式，可以实现“轮询”若干socket。当企图从一个没有数据等待处理的非阻塞socket读入数据时，函数将立即返回，并且返回值置为-1，并且errno置为EWOULDBLOCK。但是这种“轮询”会使CPU处于忙等待方式，从而降低性能。考虑到这种情况，假设你希望服务器监听连接服务请求的同时从已经建立的连接读取数据，你也许会想到用一个accept语句和多个recv()语句，但是由于accept及recv都是会阻塞的，所以这个想法显然不会成功。
调用非阻塞的socket会大大地浪费系统资源。而调用select()会有效地解决这个问题，它允许你把进程本身挂起来，而同时使系统内核监听所要求的一组文件描述符的任何活动，只要确认在任何被监控的文件描述符上出现活动，select()调用将返回指示该文件描述符已准备好的信息，从而实现了为进程选出随机的变化，而不必由进程本身对输入进行测试而浪费CPU开销。

其次，并发服务器，在上述cycletcpserver.c中，由于使用了fork技术也可以称之为并发服务器，但这种服务器并不是真正意义上的IO多路复用的并发服务器，并且由于没有处理阻塞问题，实际应用有各种各样的问题。

一个典型IO多路复用的单进程并发服务器流程如下：
/*IO多路复用并发服务流程图*/

下面是一个演示IO多路复用的源程序，是一个端口转发程序，但它的用处相当大，实际应用中的各类代理软件或端口映射软件都是基于这样的代码的，比如Windows下的WinGate、WinProxy等都是在此基础上实现的。源代码如下：

[cpp]  view plain copy
  1. /*----------------------源代码开始--------------------------------------------*/  
  2.   
  3. #include <stdlib.h>  
  4.   
  5. #include <stdio.h>  
  6.   
  7. #include <unistd.h>  
  8.   
  9. #include <sys/time.h>  
  10.   
  11. #include <sys/types.h>  
  12.   
  13. #include <string.h>  
  14.   
  15. #include <signal.h>  
  16.   
  17. #include <sys/socket.h>  
  18.   
  19. #include <netinet/in.h>  
  20.   
  21. #include <arpa/inet.h>  
  22.   
  23. #include <errno.h>  
  24.   
  25.   
  26.   
  27. static int forward_port;  
  28.   
  29.   
  30.   
  31. #undef max  
  32.   
  33. #define max(x,y) ((x) > (y) ? (x) : (y))  
  34.   
  35.   
  36.   
  37. /*************************关于本文档************************************ 
  38.  
  39. *filename: tcpforwardport.c 
  40.  
  41. *purpose: 演示了select的用法，这是一个极好的代理软件核心，专门作端口映射用 
  42.  
  43. *tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com) 
  44.  
  45. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  46.  
  47. *date time:2006-07-05 19:00:00 
  48.  
  49. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
  50.  
  51. * 但请遵循GPL 
  52.  
  53. *Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码 
  54.  
  55. *Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
  56.  
  57. *********************************************************************/  
  58.   
  59.   
  60.   
  61. static int listen_socket (int listen_port) {  
  62.   
  63.     struct sockaddr_in a;  
  64.   
  65.     int s;  
  66.   
  67.     int yes;  
  68.   
  69.     if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {  
  70.   
  71.         perror ("socket");  
  72.   
  73.         return -1;  
  74.   
  75.     }  
  76.   
  77.     yes = 1;  
  78.   
  79.     if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, sizeof (yes)) <  
  80.   
  81. 0) {  
  82.   
  83.         perror ("setsockopt");  
  84.   
  85.         close (s);  
  86.   
  87.         return -1;  
  88.   
  89.     }  
  90.   
  91.     memset (&a, 0, sizeof (a));  
  92.   
  93.     a.sin_port = htons (listen_port);  
  94.   
  95.     a.sin_family = AF_INET;  
  96.   
  97.     if (bind(s, (struct sockaddr *) &a, sizeof (a)) < 0) {  
  98.   
  99.         perror ("bind");  
  100.   
  101.         close (s);  
  102.   
  103.         return -1;  
  104.   
  105.     }  
  106.   
  107.     printf ("accepting connections on port %d\n", (int) listen_port);  
  108.   
  109.     listen (s, 10);  
  110.   
  111.     return s;  
  112.   
  113. }  
  114.   
  115.   
  116.   
  117. static int connect_socket (int connect_port, char *address) {  
  118.   
  119.     struct sockaddr_in a;  
  120.   
  121.     int s;  
  122.   
  123.     if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {  
  124.   
  125.         perror ("socket");  
  126.   
  127.         close (s);  
  128.   
  129.         return -1;  
  130.   
  131.     }  
  132.   
  133.   
  134.   
  135.     memset (&a, 0, sizeof (a));  
  136.   
  137.     a.sin_port = htons (connect_port);  
  138.   
  139.     a.sin_family = AF_INET;  
  140.   
  141.   
  142.   
  143.     if (!inet_aton(address, (struct in_addr *) &a.sin_addr.s_addr)) {  
  144.   
  145.         perror ("bad IP address format");  
  146.   
  147.         close (s);  
  148.   
  149.         return -1;  
  150.   
  151.     }  
  152.   
  153.   
  154.   
  155.     if (connect(s, (struct sockaddr *) &a, sizeof (a)) < 0) {  
  156.   
  157.         perror ("connect()");  
  158.   
  159.         shutdown (s, SHUT_RDWR);  
  160.   
  161.         close (s);  
  162.   
  163.         return -1;  
  164.   
  165.     }  
  166.   
  167.     return s;  
  168.   
  169. }  
  170.   
  171.   
  172.   
  173. #define SHUT_FD1 { \  
  174.   
  175.     if (fd1 >= 0) {   \  
  176.   
  177.         shutdown (fd1, SHUT_RDWR);  \  
  178.   
  179.         close (fd1);  \  
  180.   
  181.         fd1 = -1;     \  
  182.   
  183.     }   \  
  184.   
  185. }  
  186.   
  187.   
  188.   
  189. #define SHUT_FD2 { \  
  190.   
  191.     if (fd2 >= 0) {   \  
  192.   
  193.         shutdown (fd2, SHUT_RDWR);  \  
  194.   
  195.         close (fd2);  \  
  196.   
  197.         fd2 = -1;     \  
  198.   
  199.     }   \  
  200.   
  201. }  
  202.   
  203.   
  204.   
  205. #define BUF_SIZE 1024  
  206.   
  207.   
  208.   
  209. int main (int argc, char **argv) {  
  210.   
  211.     int h;  
  212.   
  213.     int fd1 = -1, fd2 = -1;  
  214.   
  215.     char buf1[BUF_SIZE], buf2[BUF_SIZE];  
  216.   
  217.     int buf1_avail, buf1_written;  
  218.   
  219.     int buf2_avail, buf2_written;  
  220.   
  221.   
  222.   
  223.     if (argc != 4) {  
  224.   
  225.         fprintf (stderr, "Usage\n\tfwd   \n");  
  226.   
  227.         exit (1);  
  228.   
  229.     }  
  230.   
  231.   
  232.   
  233.     signal (SIGPIPE, SIG_IGN);  
  234.   
  235.   
  236.   
  237.     forward_port = atoi (argv[2]);  
  238.   
  239.   
  240.   
  241.     /*建立监听socket*/  
  242.   
  243.     h = listen_socket (atoi (argv[1]));  
  244.   
  245.     if (h < 0) exit (1);  
  246.   
  247.   
  248.   
  249.     for (;;) {  
  250.   
  251.         int r, nfds = 0;  
  252.   
  253.         fd_set rd, wr, er;  
  254.   
  255.         FD_ZERO (&rd);  
  256.   
  257.         FD_ZERO (&wr);  
  258.   
  259.         FD_ZERO (&er);  
  260.   
  261.         FD_SET (h, &rd);  
  262.   
  263.   
  264.   
  265.         /*把监听socket和可读socket三个一起放入select的可读句柄列表里*/  
  266.   
  267.         nfds = max (nfds, h);  
  268.   
  269.         if (fd1 > 0 && buf1_avail < BUF_SIZE) {  
  270.   
  271.             FD_SET (fd1, &rd);  
  272.   
  273.             nfds = max (nfds, fd1);  
  274.   
  275.         }  
  276.   
  277.         if (fd2 > 0 && buf2_avail < BUF_SIZE) {  
  278.   
  279.             FD_SET (fd2, &rd);  
  280.   
  281.             nfds = max (nfds, fd2);  
  282.   
  283.         }  
  284.   
  285.   
  286.   
  287.         /*把可写socket两个一起放入select的可写句柄列表里*/  
  288.   
  289.         if (fd1 > 0 && buf2_avail - buf2_written > 0) {  
  290.   
  291.             FD_SET (fd1, &wr);  
  292.   
  293.             nfds = max (nfds, fd1);  
  294.   
  295.         }  
  296.   
  297.         if (fd2 > 0 && buf1_avail - buf1_written > 0) {  
  298.   
  299.             FD_SET (fd2, &wr);  
  300.   
  301.             nfds = max (nfds, fd2);  
  302.   
  303.         }  
  304.   
  305.   
  306.   
  307.         /*把有异常数据的socket两个一起放入select的异常句柄列表里*/  
  308.   
  309.         if (fd1 > 0) {  
  310.   
  311.             FD_SET (fd1, &er);  
  312.   
  313.             nfds = max (nfds, fd1);  
  314.   
  315.         }  
  316.   
  317.         if (fd2 > 0) {  
  318.   
  319.             FD_SET (fd2, &er);  
  320.   
  321.             nfds = max (nfds, fd2);  
  322.   
  323.         }  
  324.   
  325.   
  326.   
  327.         /*开始select*/  
  328.   
  329.         r = select (nfds + 1, &rd, &wr, &er, NULL);  
  330.   
  331.   
  332.   
  333.         if (r == -1 && errno == EINTR) continue;  
  334.   
  335.         if (r < 0) {  
  336.   
  337.             perror ("select()");  
  338.   
  339.             exit (1);  
  340.   
  341.         }  
  342.   
  343.   
  344.   
  345.         /*处理新连接*/  
  346.   
  347.         if (FD_ISSET (h, &rd)) {  
  348.   
  349.             unsigned int l;  
  350.   
  351.             struct sockaddr_in client_address;  
  352.   
  353.             memset (&client_address, 0, l = sizeof (client_address));  
  354.   
  355.             r = accept (h, (struct sockaddr *)&client_address, &l);  
  356.   
  357.             if (r < 0) {  
  358.   
  359.                 perror ("accept()");  
  360.   
  361.             } else {  
  362.   
  363.                 /*关闭原有连接，把新连接作为fd1，同时连接新的目标fd2*/  
  364.   
  365.                 SHUT_FD1;  
  366.   
  367.                 SHUT_FD2;  
  368.   
  369.                 buf1_avail = buf1_written = 0;  
  370.   
  371.                 buf2_avail = buf2_written = 0;  
  372.   
  373.                 fd1 = r;  
  374.   
  375.                 fd2 = connect_socket (forward_port, argv[3]);  
  376.   
  377.                 if (fd2 < 0) {  
  378.   
  379.                     SHUT_FD1;  
  380.   
  381.                 } else  
  382.   
  383.                     printf ("connect from %s\n", inet_ntoa(client_address.sin_addr));  
  384.   
  385.             }  
  386.   
  387.         }  
  388.   
  389.   
  390.   
  391.         /* NB: read oob data before normal reads */  
  392.   
  393.         if (fd1 > 0)  
  394.   
  395.         if (FD_ISSET (fd1, &er)) {  
  396.   
  397.             char c;  
  398.   
  399.             errno = 0;  
  400.   
  401.             r = recv (fd1, &c, 1, MSG_OOB);  
  402.   
  403.             if (r < 1) {  
  404.   
  405.                 SHUT_FD1;  
  406.   
  407.             } else  
  408.   
  409.                 send (fd2, &c, 1, MSG_OOB);  
  410.   
  411.         }  
  412.   
  413.   
  414.   
  415.         if (fd2 > 0)  
  416.   
  417.         if (FD_ISSET (fd2, &er)) {  
  418.   
  419.             char c;  
  420.   
  421.             errno = 0;  
  422.   
  423.             r = recv (fd2, &c, 1, MSG_OOB);  
  424.   
  425.             if (r < 1) {  
  426.   
  427.                 SHUT_FD1;  
  428.   
  429.             } else  
  430.   
  431.                 send (fd1, &c, 1, MSG_OOB);  
  432.   
  433.         }  
  434.   
  435.   
  436.   
  437.         /* NB: read data from fd1 */  
  438.   
  439.         if (fd1 > 0)  
  440.   
  441.         if (FD_ISSET (fd1, &rd)) {  
  442.   
  443.             r = read (fd1, buf1 + buf1_avail, BUF_SIZE - buf1_avail);  
  444.   
  445.             if (r < 1) {  
  446.   
  447.                 SHUT_FD1;  
  448.   
  449.             } else  
  450.   
  451.                 buf1_avail += r;  
  452.   
  453.         }  
  454.   
  455.   
  456.   
  457.         /* NB: read data from fd2 */  
  458.   
  459.         if (fd2 > 0)  
  460.   
  461.         if (FD_ISSET (fd2, &rd)) {  
  462.   
  463.             r = read (fd2, buf2 + buf2_avail, BUF_SIZE - buf2_avail);  
  464.   
  465.             if (r < 1) {  
  466.   
  467.                 SHUT_FD2;  
  468.   
  469.             } else  
  470.   
  471.                 buf2_avail += r;  
  472.   
  473.         }  
  474.   
  475.   
  476.   
  477.         /* NB: write data to fd1 */  
  478.   
  479.         if (fd1 > 0)  
  480.   
  481.         if (FD_ISSET (fd1, &wr)) {  
  482.   
  483.             r = write (fd1, buf2 + buf2_written, buf2_avail - buf2_written);  
  484.   
  485.             if (r < 1) {  
  486.   
  487.                 SHUT_FD1;  
  488.   
  489.             } else  
  490.   
  491.                 buf2_written += r;  
  492.   
  493.         }  
  494.   
  495.   
  496.   
  497.         /* NB: write data to fd1 */  
  498.   
  499.         if (fd2 > 0)  
  500.   
  501.         if (FD_ISSET (fd2, &wr)) {  
  502.   
  503.             r = write (fd2, buf1 + buf1_written, buf1_avail - buf1_written);  
  504.   
  505.             if (r < 1) {  
  506.   
  507.                 SHUT_FD2;  
  508.   
  509.             } else  
  510.   
  511.                 buf1_written += r;  
  512.   
  513.         }  
  514.   
  515.   
  516.   
  517.         /* check if write data has caught read data */  
  518.   
  519.         if (buf1_written == buf1_avail) buf1_written = buf1_avail = 0;  
  520.   
  521.         if (buf2_written == buf2_avail) buf2_written = buf2_avail = 0;  
  522.   
  523.   
  524.   
  525.         /* one side has closed the connection, keep writing to the other side until empty */  
  526.   
  527.         if (fd1 < 0 && buf1_avail - buf1_written == 0) {  
  528.   
  529.             SHUT_FD2;  
  530.   
  531.         }  
  532.   
  533.         if (fd2 < 0 && buf2_avail - buf2_written == 0) {  
  534.   
  535.             SHUT_FD1;  
  536.   
  537.         }  
  538.   
  539.     }  
  540.   
  541.     return 0;  
  542.   
  543. }  
  544.   
  545. /*----------------------源代码结束--------------------------------------------*/  


 

用gcc tcpforwardport.c -o MyProxy编译此程序后运行效果如下：

./MyProxy 8000 80 172.16.100.218
accepting connections on port 8000
connect from 127.0.0.1


当有用户访问本机的8000端口时，MyProxy程序将把此请求转发到172.16.100.218主机的80端口，即实现了一个http代理。

关于select函数：
其函数原型为：
int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
此函数的功能是由内核检测在timeout时间内，是否有readfds，writefds，exceptfds三个句柄集(file descriptors)里的某个句柄（file descriptor)的状态符合寻求，即readfds句柄集里有句柄可读或writefds句柄集里有可写或exceptfds句柄集里有例外发生，任何一个有变化函数就立即返回，返回值为timeout发生状态变化的句柄个数。
n是所有readfds，writefds，exceptfds三个句柄集(file descriptors)里编号最大值加1。比如：要检测两个socket句柄fd1和fd2在timeout时间内是否分别可读和可写就可以这样：
先把两个句柄集(file descriptors)清零：
        FD_ZERO (&readfds);
        FD_ZERO (&writefds);
然后把fd1加入读检测集：
        FD_SET (fd1, &readfds);
然后把fd2加入写检测集：
        FD_SET (fd2, &writefds);
再给timeout设置值，timeout是这样的一个结构：
              struct timeval {
                  long    tv_sec;         /* seconds */
                  long    tv_usec;        /* microseconds */
              };
你可以这样赋值：
        timeout.tv_sec=1;
        timeout.tv_uec=0;
表示检测在1秒钟内是否有句柄状态发生变化。
如果有句柄发生变化，就可以用FD_ISSET检测各个句柄，比如：
                FD_ISSET (fd1, &readfds);//检测是否fd1变成可读的了
                FD_ISSET (fd2, &writefds);//检测是否fd2变成可写的了
示意程序代码如下：

[cpp]  view plain copy
  1. /*----------------------示意代码开始--------------------------------------------*/  
  2.   
  3.     fd1 = socket();//创建一个socket  
  4.   
  5.     fd2 = socket();//创建一个socket  
  6.   
  7.     while(1)  {  
  8.   
  9.         FD_ZERO (&readfds);  
  10.   
  11.         FD_ZERO (&writefds);  
  12.   
  13.         FD_SET (fd1, &readfds);  
  14.   
  15.         FD_SET (fd2, &writefds);  
  16.   
  17.         timeout.tv_sec=1;  
  18.   
  19.         timeout.tv_uec=0;  
  20.   
  21.         ret = select(fd1>fd2?(fd1+1):(fd2+1), &readfds, &writefds, NULL, &timeout);  
  22.   
  23.         if(ret < 0) {printf("系统错误，select出错，错误代码：%d, 错误信息：%s", errno, strerror(errno));}  
  24.   
  25.         else if(ret == 0) {printf("select超时返回，没有任何句柄状态发生变化！");}  
  26.   
  27.         //有句柄状态发生了变化  
  28.   
  29.         if(FD_ISSET(fd1, &readfds)) {  
  30.   
  31.             fd1有数据可读;  
  32.   
  33.             fd1里的数据被读出来;  
  34.   
  35.         }  
  36.   
  37.         if(FD_ISSET(fd2, &writefds)) {  
  38.   
  39.             fd2可写;  
  40.   
  41.             fd2里发送数据给对方;  
  42.   
  43.         }  
  44.   
  45.     }  
  46.   
  47. /*----------------------示意代码结束--------------------------------------------*/  


 

用gcc tcpforwardport.c -o MyProxy编译此程序后运行效果如下：
./MyProxy 8000 80 172.16.100.218
accepting connections on port 8000
connect from 127.0.0.1


当有用户访问本机的8000端口时，MyProxy程序将把此请求转发到172.16.100.218主机的80端口，即实现了一个http代理。

关于select函数：
其函数原型为：
int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
此函数的功能是由内核检测在timeout时间内，是否有readfds，writefds，exceptfds三个句柄集(file descriptors)里的某个句柄（file descriptor)的状态符合寻求，即readfds句柄集里有句柄可读或writefds句柄集里有可写或exceptfds句柄集里有例外发生，任何一个有变化函数就立即返回，返回值为timeout发生状态变化的句柄个数。
n是所有readfds，writefds，exceptfds三个句柄集(file descriptors)里编号最大值加1。比如：要检测两个socket句柄fd1和fd2在timeout时间内是否分别可读和可写就可以这样：
先把两个句柄集(file descriptors)清零：
        FD_ZERO (&readfds);
        FD_ZERO (&writefds);
然后把fd1加入读检测集：
        FD_SET (fd1, &readfds);
然后把fd2加入写检测集：
        FD_SET (fd2, &writefds);
再给timeout设置值，timeout是这样的一个结构：
              struct timeval {
                  long    tv_sec;         /* seconds */
                  long    tv_usec;        /* microseconds */
              };
你可以这样赋值：
        timeout.tv_sec=1;
        timeout.tv_uec=0;
表示检测在1秒钟内是否有句柄状态发生变化。
如果有句柄发生变化，就可以用FD_ISSET检测各个句柄，比如：
                FD_ISSET (fd1, &readfds);//检测是否fd1变成可读的了
                FD_ISSET (fd2, &writefds);//检测是否fd2变成可写的了
示意程序代码如下：

[cpp]  view plain copy
  1. /*----------------------示意代码开始--------------------------------------------*/  
  2.   
  3.     fd1 = socket();//创建一个socket  
  4.   
  5.     fd2 = socket();//创建一个socket  
  6.   
  7.     while(1)  {  
  8.   
  9.         FD_ZERO (&readfds);  
  10.   
  11.         FD_ZERO (&writefds);  
  12.   
  13.         FD_SET (fd1, &readfds);  
  14.   
  15.         FD_SET (fd2, &writefds);  
  16.   
  17.         timeout.tv_sec=1;  
  18.   
  19.         timeout.tv_uec=0;  
  20.   
  21.         ret = select(fd1>fd2?(fd1+1):(fd2+1), &readfds, &writefds, NULL, &timeout);  
  22.   
  23.         if(ret < 0) {printf("系统错误，select出错，错误代码：%d, 错误信息：%s", errno, strerror(errno));}  
  24.   
  25.         else if(ret == 0) {printf("select超时返回，没有任何句柄状态发生变化！");}  
  26.   
  27.         //有句柄状态发生了变化  
  28.   
  29.         if(FD_ISSET(fd1, &readfds)) {  
  30.   
  31.             fd1有数据可读;  
  32.   
  33.             fd1里的数据被读出来;  
  34.   
  35.         }  
  36.   
  37.         if(FD_ISSET(fd2, &writefds)) {  
  38.   
  39.             fd2可写;  
  40.   
  41.             fd2里发送数据给对方;  
  42.   
  43.         }  
  44.   
  45.     }  
  46.   
  47. /*----------------------示意代码结束--------------------------------------------*/  


 

经常用到的几个自定义函数：
1、开启监听的函数

[cpp]  view plain copy
  1. /*----------------------源代码代码开始--------------------------------------------*/  
  2.   
  3. int  
  4.   
  5. OpenSCPServer(int port, int total, int sendbuflen, int recvbuflen, int blockORnot, int reuseORnot)    {  
  6.   
  7. /*************************关于本函数************************************ 
  8.  
  9. *function_name: OpenSCPServer 
  10.  
  11. *参数说明：port整数型监听端口号，total整数型监听个数，sendbuflen整数型发送缓冲区大小 
  12.  
  13. *          recvbuflen整数型接收缓冲区大小，blockORnot整数型是否阻塞，reuseORnot整数型是否端口重用 
  14.  
  15. *purpose: 用来建立一个tcp服务端socket 
  16.  
  17. *tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com) 
  18.  
  19. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  20.  
  21. *date time:2006-07-05 20:00:00 
  22.  
  23. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
  24.  
  25. * 但请遵循GPL 
  26.  
  27. *Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码 
  28.  
  29. *Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
  30.  
  31. *Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含GetCurrentTime.h头文件 
  32.  
  33. *********************************************************************/  
  34.   
  35.     int    sockfd = 0, ret = 0, opt = 0, flags=1;  
  36.   
  37.     struct sockaddr_in    laddr;  
  38.   
  39.   
  40.   
  41.     ret = sockfd = socket(PF_INET, SOCK_STREAM, 0);  
  42.   
  43.     if(ret < 0)    {  
  44.   
  45.         sprintf(errorMessage, "OpenTCPServer socket() error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  46.   
  47.         return -1;  
  48.   
  49.     }  
  50.   
  51.   
  52.   
  53.     ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuseORnot, sizeof(int));  
  54.   
  55.     if(ret < 0)    {  
  56.   
  57.         sprintf(errorMessage, "OpenTCPServer setsockopt() reuse error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  58.   
  59.         return -2;  
  60.   
  61.     }  
  62.   
  63.   
  64.   
  65.     ret = setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &recvbuflen, sizeof(int));  
  66.   
  67.     if ( ret < 0)    {  
  68.   
  69.         sprintf(errorMessage, "OpenTCPServer setsockopt() recvbuf error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  70.   
  71.         return -3;  
  72.   
  73.     }  
  74.   
  75.   
  76.   
  77.     ret = setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &sendbuflen, sizeof(int));  
  78.   
  79.     if (ret < 0)    {  
  80.   
  81.         sprintf(errorMessage, "OpenTCPServer setsockopt() sendbuf error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  82.   
  83.         return -4;  
  84.   
  85.     }  
  86.   
  87.   
  88.   
  89.     ioctl(sockfd,FIONBIO,&blockORnot);/*block or not*/  
  90.   
  91.   
  92.   
  93.     laddr.sin_family = PF_INET;  
  94.   
  95.     laddr.sin_port = htons(port);  
  96.   
  97.     laddr.sin_addr.s_addr = INADDR_ANY;  
  98.   
  99.     bzero(&(laddr.sin_zero), 8);  
  100.   
  101.   
  102.   
  103.     ret = bind(sockfd, (struct sockaddr *)&laddr, sizeof(struct sockaddr));  
  104.   
  105.     if(ret < 0)    {  
  106.   
  107.         sprintf(errorMessage, "OpenTCPServer bind() error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  108.   
  109.         close(sockfd);  
  110.   
  111.         return -5;  
  112.   
  113.     }  
  114.   
  115.     ret = listen(sockfd, total);  
  116.   
  117.     if(ret < 0)    {  
  118.   
  119.         sprintf(errorMessage, "OpenTCPServer listen() error! return:%d, errno=%d, errortext:'%s' %s", ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  120.   
  121.         close(sockfd);  
  122.   
  123.         return -6;  
  124.   
  125.     }  
  126.   
  127.     sprintf(errorMessage, "OpenTCPServer opened on port.%d(%d) OK, socket(%d), buf(%d:%d)! %s", port, total, sockfd, sendbuflen, recvbuflen, GetCurrentTime(0, 0));  
  128.   
  129.     return sockfd;  
  130.   
  131. }  
  132.   
  133. /*----------------------源代码代码结束--------------------------------------------*/  


 

2、连接服务器的函数

[cpp]  view plain copy
  1. /*----------------------源代码代码开始--------------------------------------------*/  
  2.   
  3. int  
  4.   
  5. ConnectSCPServer(char * serverip, int serverport, int blockORnot)    {  
  6.   
  7. /*************************关于本函数************************************ 
  8.  
  9. *function_name: ConnectSCPServer 
  10.  
  11. *参数说明：serverip服务器IP地址或主机名，serverport服务器端口，blockORnot整数型是否阻塞 
  12.  
  13. *purpose: 用来建立一个tcp客户端socket 
  14.  
  15. *tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com) 
  16.  
  17. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  18.  
  19. *date time:2006-07-05 20:40:00 
  20.  
  21. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
  22.  
  23. * 但请遵循GPL 
  24.  
  25. *Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码 
  26.  
  27. *Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
  28.  
  29. *Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含自己编写的GetCurrentTime.h头文件 
  30.  
  31. *********************************************************************/  
  32.   
  33.     int    serversock = 0, ret = 0;  
  34.   
  35.     unsigned long    addr;  
  36.   
  37.     struct sockaddr_in    sin;  
  38.   
  39.     struct hostent *he;  
  40.   
  41.   
  42.   
  43.     if((he=gethostbyname(serverip))== 0) {  
  44.   
  45.         sprintf(errorMessage, "ConnectSCPServer IP address '%s' error! return:-1 %s", serverip, GetCurrentTime(0, 0));  
  46.   
  47.         return -1;  
  48.   
  49.     }  
  50.   
  51.   
  52.   
  53.     serversock = socket(PF_INET, SOCK_STREAM, 0);  
  54.   
  55.     if(serversock == -1)    {  
  56.   
  57.         sprintf(errorMessage, "ConnectSCPServer socket() error! return:-2, errno=%d, errortext:'%s' %s", errno, strerror(errno), GetCurrentTime(0, 0));  
  58.   
  59.         return -2;  
  60.   
  61.     }  
  62.   
  63.   
  64.   
  65.     ioctl(serversock, FIONBIO, &blockORnot);  //block or not  
  66.   
  67.   
  68.   
  69.     memset((char*)&sin, 0, sizeof(struct sockaddr_in));  
  70.   
  71.     sin.sin_family = PF_INET;  
  72.   
  73.     sin.sin_port = htons(serverport);  
  74.   
  75.     sin.sin_addr = *((struct in_addr *)he->h_addr);  
  76.   
  77.   
  78.   
  79.     ret = connect(serversock, (struct sockaddr *)&sin, sizeof(sin));  
  80.   
  81.   
  82.   
  83.     if(ret == -1)    {  
  84.   
  85.         sprintf(errorMessage, "ConnectSCPServer connect() error! return:-3, errno=%d, errortext:'%s' %s", errno, strerror(errno), GetCurrentTime(0, 0));  
  86.   
  87.         close(serversock);  
  88.   
  89.         return -3;  
  90.   
  91.     }  
  92.   
  93.   
  94.   
  95.     return serversock;  
  96.   
  97. }  
  98.   
  99. /*----------------------源代码代码结束--------------------------------------------*/  


发送数据函数Send

[cpp]  view plain copy
  1. /*----------------------源代码代码开始--------------------------------------------*/  
  2.   
  3. int  
  4.   
  5. Send(int sock, char * buf, size_t size, int flag, int timeout)    {  
  6.   
  7. /*************************关于本函数************************************ 
  8.  
  9. *function_name: Send 
  10.  
  11. *参数说明：sock整数型socket，buf待发送的内容，size要发送的大小，flag发送选项，timeout超时时间值 
  12.  
  13. *purpose: 用来通过一个socket在指定时间内发送数据 
  14.  
  15. *tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com) 
  16.  
  17. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  18.  
  19. *date time:2006-07-05 20:58:00 
  20.  
  21. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
  22.  
  23. * 但请遵循GPL 
  24.  
  25. *Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码 
  26.  
  27. *Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
  28.  
  29. *Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含自己编写的GetCurrentTime.h头文件 
  30.  
  31. *********************************************************************/  
  32.   
  33.     int i = 0, ret = 0, intretry = 0;  
  34.   
  35.   
  36.   
  37.     struct timeval tival;  
  38.   
  39.     fd_set writefds;  
  40.   
  41.     int maxfds = 0;  
  42.   
  43.   
  44.   
  45.     tival.tv_sec = timeout;  
  46.   
  47.     tival.tv_usec = 0;  
  48.   
  49.   
  50.   
  51.     FD_ZERO(&writefds);  
  52.   
  53.   
  54.   
  55.     if(sock > 0) {  
  56.   
  57.         FD_SET(sock, &writefds);  
  58.   
  59.         maxfds=((sock > maxfds)?sock:maxfds);  
  60.   
  61.     }  
  62.   
  63.     else    {  
  64.   
  65.         sprintf(errorMessage, "Send socket:%d error! return:-2 %s", sock, GetCurrentTime(0, 0));  
  66.   
  67.         return -2;  
  68.   
  69.     }  
  70.   
  71.   
  72.   
  73.     ret = select(maxfds + 1, NULL, &writefds, NULL, &tival);  
  74.   
  75.     if(ret <= 0) {  
  76.   
  77.         if(ret < 0)    sprintf(errorMessage, "Send socket:%d select() error! return:%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  78.   
  79.         else sprintf(errorMessage, "Send socket:%d select timeout(%d)! %s", sock, timeout, GetCurrentTime(0, 0));  
  80.   
  81.         close(sock);  
  82.   
  83.         return -3;  
  84.   
  85.     }  
  86.   
  87.     if(!(FD_ISSET(sock, &writefds)))    {  
  88.   
  89.         sprintf(errorMessage, "Send socket:%d not in writefds! %s", sock, GetCurrentTime(0, 0));  
  90.   
  91.         close(sock);  
  92.   
  93.         return -4;  
  94.   
  95.     }  
  96.   
  97.   
  98.   
  99.     while(i < size)    {  
  100.   
  101.         ret = send(sock, buf + i, size - i, flag);  
  102.   
  103.         if(ret <= 0)    {  
  104.   
  105.             sprintf(errorMessage, "Send socket:%d send() error! return:%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  106.   
  107.   
  108.   
  109.             if (EINTR == errno)  
  110.   
  111.               if(intretry < 10)  {intretry++;continue;}  
  112.   
  113.               else sprintf(errorMessage, "Send socket:%d send() error!EINTR 10 times! %s", sock, GetCurrentTime(0, 0));  
  114.   
  115.   
  116.   
  117.             close(sock);  
  118.   
  119.             return -1;  
  120.   
  121.         }  
  122.   
  123.         else i += ret;  
  124.   
  125.     }  
  126.   
  127.     sprintf(errorMessage, "Send socket:%d send() OK! %d/%d bytes sent! %s", sock, i, size, GetCurrentTime(0, 0));  
  128.   
  129.     return i;  
  130.   
  131. }  
  132.   
  133. /*----------------------源代码代码结束--------------------------------------------*/  


 

4、接收数据函数Recv

[cpp]  view plain copy
  1. /*----------------------源代码代码开始--------------------------------------------*/  
  2.   
  3. int  
  4.   
  5. Recv(int sock, char * buf, size_t size, int flag, int timeout)    {  
  6.   
  7. /*************************关于本函数************************************ 
  8.  
  9. *function_name: Recv 
  10.  
  11. *参数说明：sock整数型socket，buf接收数据的缓冲区，size要接收数据的大小，flag接收选项，timeout超时时间值 
  12.  
  13. *purpose: 用来从一个socket在指定时间内读取数据 
  14.  
  15. *tidied by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com) 
  16.  
  17. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  18.  
  19. *date time:2006-07-05 21:10:00 
  20.  
  21. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
  22.  
  23. * 但请遵循GPL 
  24.  
  25. *Thanks to: Paul Sheer 感谢Paul Sheer在select_tut的man手册里提供了这份源代码 
  26.  
  27. *Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
  28.  
  29. *Note:要使用此函数需要自定义一个全局变量char errorMessage[1024];并包含自己编写的GetCurrentTime.h头文件 
  30.  
  31. *********************************************************************/  
  32.   
  33.     int i = 0, ret = 0, intretry = 0;  
  34.   
  35.   
  36.   
  37.     struct timeval tival;  
  38.   
  39.     fd_set readfds;  
  40.   
  41.     int maxfds = 0;  
  42.   
  43.   
  44.   
  45.     tival.tv_sec = timeout;  
  46.   
  47.     tival.tv_usec = 0;  
  48.   
  49.   
  50.   
  51.     FD_ZERO(&readfds);  
  52.   
  53.   
  54.   
  55.     if(sock > 0) {  
  56.   
  57.         FD_SET(sock, &readfds);  
  58.   
  59.         maxfds=((sock > maxfds)?sock:maxfds);  
  60.   
  61.     }  
  62.   
  63.     else    {  
  64.   
  65.         sprintf(errorMessage, "Recv socket:%d error! return:-2 %s", sock, GetCurrentTime(0, 0));  
  66.   
  67.         return -2;  
  68.   
  69.     }  
  70.   
  71.   
  72.   
  73.     ret = select(maxfds + 1, &readfds, NULL, NULL, &tival);  
  74.   
  75.     if(ret <= 0) {  
  76.   
  77.         if(ret < 0)    sprintf(errorMessage, "Recv socket:%d select() error! return:%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  78.   
  79.         else sprintf(errorMessage, "Recv socket:%d select timeout(%d)! %s", sock, timeout, GetCurrentTime(0, 0));  
  80.   
  81.         close(sock);  
  82.   
  83.         return -3;  
  84.   
  85.     }  
  86.   
  87.     if(!(FD_ISSET(sock, &readfds)))    {  
  88.   
  89.         sprintf(errorMessage, "Recv socket:%d not in readfds! %s", sock, GetCurrentTime(0, 0));  
  90.   
  91.         close(sock);  
  92.   
  93.         return -4;  
  94.   
  95.     }  
  96.   
  97.     while(i < size)    {  
  98.   
  99.         ret = recv(sock, buf + i, size - i, flag);  
  100.   
  101.         if(ret <= 0){  
  102.   
  103.             sprintf(errorMessage, "Recv socket:%d recv() error! return:%d, errno=%d, errortext:'%s' %s", sock, ret, errno, strerror(errno), GetCurrentTime(0, 0));  
  104.   
  105.             if(errno == EINTR)     
  106.   
  107.                 if(intretry < 10)  {intretry++;continue;}  
  108.   
  109.                 else sprintf(errorMessage, "Recv socket:%d recv() error! EINTR 10 times! %s", sock, GetCurrentTime(0, 0));  
  110.   
  111.             close(sock);  
  112.   
  113.             return -1;  
  114.   
  115.         }  
  116.   
  117.         else i += ret;  
  118.   
  119.     }  
  120.   
  121.     sprintf(errorMessage, "Recv socket:%d recv() OK! %d/%d bytes received! %s", sock, i, size, GetCurrentTime(0, 0));  
  122.   
  123.     return i;  
  124.   
  125. }  

最后需要说明的是：我这里讲到的源程序并不能实际地作为一个产品程序来用，实际情况下可能会有其它许多工作要做，比如可能要建立共享队列来存放 socket里读到的消息，也可能把发送消息先进行排队然后再调用Send函数。还有，如果不是全数字，在发送前一定要htonl转换为网络字节序，同理接收到后一定要先ntohl由网络字节序转换为主机字节序，否则对方发送过来的0x00000001在你这里可能是0x00010000，因为高低位顺序不同。

diy534
关注
专栏目录
Linux下TCP网络服务器实现源代码
03-16
Linux源代码,Linux下TCP网络服务器实现源代码
Linux下TCP/IP服务器实现源码解析(含源码)
10-20
对于菜鸟接触linux，网络是由浅入深的步步提高深化的源码解析笔记！ 其中不乏老鸟也需要深入的技术！ （内附赠送linux内核分析图和linux文件解析表） 希望大家互相交流 共同进步！！ 拜交好友！
socket相关3
weixin_34381687的博客
11-23 156
【分享】Linux下各类TCP网络服务器的实现源代码 Linux下各类TCP网络服务器的实现源代码大家都知道各类网络服务器程序的编写步骤，并且都知道网络服务器就两大类：循环服务和并发服务。这里附上源代码来个小结吧。首先，循环网络服务器编程实现的步骤是这样的：" target="_blank"&gt;http://这种服务器模型是典型循环服务，如果不加上多进程/线程技术，此种服务吞吐量有限...
linux简单tcp服务器,Linux下TCP网络服务器实现源代码4
weixin_34652835的博客
05-03 188
进入2.6内核时代,select应该进垃圾堆了高并发服务器用select效率极低,特别是使用非阻塞IO时更是慢得一蹋糊涂改用epoll会大大改善我一个程序监听从8000到18000共计1万个端口,启动1万个LISTEN用epoll来阻塞,系统非常轻松,完全没有惊群现象epoll用法比select简单初始化:创建epoll描述字;向epoll描述字添加需要响应的套接字,初始化过程只要一次即可使用:等...
Linux下各类TCP网络服务器的实现源代码.mht
12-10
Linux下各类TCP网络服务器的实现源代码,转之红联
Linux版 TCP调试工具(QT源代码)
04-04
以上是关于"Linux版TCP调试工具(QT源代码)"项目的核心知识点，涵盖网络编程、并发处理、GUI设计等多个领域，对于提升IT专业技能具有重要价值。通过对这些知识点的深入理解和实践，可以更好地开发和优化TCP服务端模型...
linux下多线程网络编程TCP服务器端数据传输代码
01-14
在提供的压缩包中，"linux下多线程网络编程TCP服务器端数据传输代码"应该包含了实现这些步骤的C语言源代码。在使用前，务必阅读readme.txt文件，了解代码的运行环境、依赖库和使用方法。 这个程序可能包含以下关键...
linux下各种TCP网络服务器的实现
12-28
TCP网络服务器实现源代码，对学习TCP网络有很大帮助
linuxC版TCP客户端和服务端源码
07-16
linuxC版TCP客户端和服务端源码
linux下TCP通信，客户端和服务端源码
03-30
TCP协议实验，linux下TCP通信，客户端和服务端源码
Linux下tcp通信程序
12-08
Linux下tcp通信程序，含客户端和服务器以及Makefile，多线程-可同时收发操作。 不足：退出机制不太完整。
linux tcp服务器软件,linux下tcp服务器源码示例
weixin_42505032的博客
04-30 97
#include #include #include #include #include #include #include #include #include #include #include struct _NSS_HEADER{unsigned short ProtocolVersion; /* 协议版本信息 */unsigned short ...
Linux下各类TCP网络服务器的实现源代码 转
qq515383106的专栏
07-13 1932
大家都知道各类网络服务器程序的编写步骤，并且都知道网络服务器就两大类：循环服务和并发服务。这里附上源代码来个小结吧。 首先，循环网络服务器编程实现的步骤是这样的： 这种服务器模型是典型循环服务，如果不加上多进程/线程技术，此种服务吞吐量有限，大家都可以看到，如果前一个连接服务数据没有收发完毕后面的连接没办法处理。所以一般有多进程技术，对一个新连接启用一个新进程去处理，而监听sock
Linux内核的TCP源码入门(一)
最新发布
lic721的博客
11-25 2351
在OSI(Open System Interconnection)体系结构中, 传输层的协议, 是实现在操作系统内核中的。 TCP是传输层的重要协议, 其源码在Linux中可以看到，本文采用的是Linux-5.19.9。Linux源码下载地址: Linux内核官网地址: 注意, 本文假设读者对TCP的相关概念有一定的了解, 未深入讲述概念.TCP协议本身逐步迭代了几个版本, 初版的TCP报文段中, 是没有"CWR"和"ECE"的: 参见 https://www.rfc-editor.org/rfc/inli
《Linux内核TCP/IP 实现》：协议栈源码总纲一
yexiangCSDN的专栏
01-07 7763
一.linux内核网络栈代码的准备知识 1.linux内核ipv4网络部分分层结构： BSD socket层：这一部分处理BSD socket相关操作，每个socket在内核中以struct socket结构体现。这一部分的文件主要有： /net/socket.c /net/protocols.c INET socket层：BSD socket是个可以用于各种网络协议的接口，而当...
nc 源代码分析（2），流程分析
linux-0.11调试教程
04-15 2676
nc调试版.rar for windows by chenghao0511 步骤1，机器A输入d回车，机器B里面显示d。 步骤2，机器A输入d未回车！机器B里面输入ee回车，然后输入ff回车。 机器A里面回车。 里面显示一些debug()宏函数的信息。 vc6下nmake后顺利编译通过。可下载调试版，实验。     if (istty) {
linux 网络服务器 源码下载,Linux下TCP网络服务器实现源代码(6)
weixin_32330765的博客
04-29 234
Linux下TCP网络服务器实现源代码(6)2009-05-13 01:20:11来源：未知 阅读 ()fd1=socket();//创建一个socketfd2=socket();//创建一个socketwhile(1){FD_ZERO(&readfds);FD_ZERO(&writefds);FD_SET(fd1,&readfds);FD_SET(fd2,&wri...
Linux下高性能网络服务器设计与实现探析
"基于Linux的高性能网络服务器设计，探讨了Linux环境下网络服务器的架构，通过TCP/IP协议分析，源代码研究，实现了一个小型IM服务器系统，经过测试，展示出良好的并发性能。" 在当今互联网时代，网络服务器的需求日...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值