窥探Socket监听的秘密

本文转载自微信公众号「盼盼编程」，作者盼盼编程。转载本文请联系盼盼编程公众号。

员工经过长期磨合与沉淀，具备了协作精神，得以通过团队的力量开发出优质的产品。成都创新互联公司坚持“专注、创新、易用”的产品理念，因为“专注所以专业、创新互联网站所以易用所以简单”。公司专注于为企业提供成都网站制作、网站设计、微信公众号开发、电商网站开发，微信小程序开发，软件按需策划等一站式互联网企业服务。

socket用listen函数监听，listen从英语上理解就是一个"听"函数，实际上它也就是这个意思。

我们来看unix网络编程这本书是怎样对它的解释：listen函数把一个未连接的套接字转换成一个被动套接字，指示内核应该接受指向该套接字的链接请求。

该函数有2个参数，第一个我就不说了，第二参数规定了内核为相应套接字排队的最大连接个数。只看这些理论搞的人稀里糊涂，我们还是来测一下。

 
 
    
  
  
  1. [mapan@localhost test]$ ls 
    2. 
  
  
  2. client.cpp  makefile  server.cpp 
    3. 
  
  
  3. [mapan@localhost test]$  
    4. 
  
  
  4. [mapan@localhost test]$ cat server.cpp  
    5. 
  
  
  5. #include  
    6. 
  
  
  6. #include  
    7. 
  
  
  7. #include  
    8. 
  
  
  8. #include  
    9. 
  
  
  9. #include  
    10. 
  
  
  10. #include  
    11. 
  
  
  11. #include  
    12. 
  
  
  12. #include  
    13. 
  
  
  13. #include  
    14. 
  
  
  14. #include  
    15. 
  
  
  15. #include  
    16. 
  
  
  16. #include  
    17. 
  
  
  17. #include  
    18. 
  
  
  18. #include  
    19. 
  
  
  19. #include  
    20. 
  
  
  20. #include  
    21. 
  
  
  21. #include  
    22. 
  
  
  22. #include  
    23. 
  
  
  23. #include  
    24. 
  
  
  24. #include  
    25. 
  
  
  25. #define MAXLINE 4096 
    26. 
  
  
  26.  
    27. 
  
  
  27.  
    28. 
  
  
  28.  
    29. 
  
  
  29. void main() 
    30. 
  
  
  30. { 
    31. 
  
  
  31.    int listenfd,connfd; 
    32. 
  
  
  32.    socklen_t  clilen; 
    33. 
  
  
  33.    struct sockaddr_in cliaddr,servaddr; 
    34. 
  
  
  34.  
    35. 
  
  
  35.    listenfd=socket(AF_INET,SOCK_STREAM,0); 
    36. 
  
  
  36.    bzero(&servaddr,sizeof(servaddr)); 
    37. 
  
  
  37.  
    38. 
  
  
  38.    servaddr.sin_family=AF_INET; 
    39. 
  
  
  39.    servaddr.sin_addr.s_addr=INADDR_ANY; 
    40. 
  
  
  40.    servaddr.sin_port=htons(8888); 
    41. 
  
  
  41.  
    42. 
  
  
  42.    bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));   
    43. 
  
  
  43.    listen(listenfd,1); 
    44. 
  
  
  44.  
    45. 
  
  
  45.    getchar(); 
    46. 
  
  
  46.    connfd=accept(listenfd,(struct sockaddr *)&cliaddr,&clilen); 
    47. 
  
  
  47.  
    48. 
  
  
  48.  
    49. 
  
  
  49.  
    50. 
  
  
  50.    close(connfd); 
    51. 
  
  
  51.    close(listenfd); 
    52. 
  
  
  52. } 
    53. 
  
  
  53. [mapan@localhost test]$ cat client.cpp  
    54. 
  
  
  54. #include  
    55. 
  
  
  55. #include  
    56. 
  
  
  56. #include  
    57. 
  
  
  57. #include  
    58. 
  
  
  58. #include  
    59. 
  
  
  59. #include  
    60. 
  
  
  60. #include  
    61. 
  
  
  61. #include  
    62. 
  
  
  62. #include  
    63. 
  
  
  63. #include  
    64. 
  
  
  64. #include  
    65. 
  
  
  65. #include  
    66. 
  
  
  66. #include  
    67. 
  
  
  67. #include  
    68. 
  
  
  68. #include  
    69. 
  
  
  69. #include  
    70. 
  
  
  70. #include  
    71. 
  
  
  71. #include  
    72. 
  
  
  72. #include  
    73. 
  
  
  73. #include  
    74. 
  
  
  74. #define MAXLINE 4096 
    75. 
  
  
  75.  
    76. 
  
  
  76.  
    77. 
  
  
  77. void main() 
    78. 
  
  
  78. { 
    79. 
  
  
  79.    int sockfd; 
    80. 
  
  
  80.    struct sockaddr_in servaddr; 
    81. 
  
  
  81.  
    82. 
  
  
  82.  
    83. 
  
  
  83.    sockfd=socket(AF_INET,SOCK_STREAM,0); 
    84. 
  
  
  84.    bzero(&servaddr,sizeof(servaddr)); 
    85. 
  
  
  85.    servaddr.sin_family=AF_INET; 
    86. 
  
  
  86.    servaddr.sin_port=htons(8888); 
    87. 
  
  
  87.    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); 
    88. 
  
  
  88.  
    89. 
  
  
  89.    int ret=connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)); 
    90. 
  
  
  90.    getchar(); 
    91. 
  
  
  91.  
    92. 
  
  
  92.    close(sockfd); 
    93. 
  
  
  93. } 
    94. 
  
  
  94. [mapan@localhost test]$ cat makefile  
    95. 
  
  
  95. all:server client 
    96. 
  
  
  96.  
    97. 
  
  
  97. server.o:server.cpp 
    98. 
  
  
  98.   g++ -c server.cpp 
    99. 
  
  
  99. client.o:client.cpp 
    100. 
  
  
  100.   g++ -c client.cpp 
    101. 
  
  
  101. server:server.o 
    102. 
  
  
  102.   g++ -o server server.o 
    103. 
  
  
  103. client:client.o 
    104. 
  
  
  104.   g++ -o client client.o 
    105. 
  
  
  105.  
    106. 
  
  
  106. clean: 
    107. 
  
  
  107.   rm -f server client *.o 
    108. 
  
  
  108. [mapan@localhost test]$ 
    109.

请注意上面的服务端中，我是没有调用accept函数的，直接调用getchar()了,跑起来。

 
 
    
  
  
  1. [mapan@localhost test]$ make 
    2. 
  
  
  2. g++ -c server.cpp 
    3. 
  
  
  3. g++ -o server server.o 
    4. 
  
  
  4. g++ -c client.cpp 
    5. 
  
  
  5. g++ -o client client.o 
    6. 
  
  
  6. [mapan@localhost test]$ ./server  
    7. 
  
  
  7.  
    8. 
  
  
  8. 服务度开启，然后新打开一个窗口开启客户端。 
    9. 
  
  
  9. [mapan@localhost TCP]$ cd ../test/ 
    10. 
  
  
  10. [mapan@localhost test]$  
    11. 
  
  
  11. [mapan@localhost test]$ ./client 127.0.0.1 
    12.

查看网络：

 
 
    
  
  
  1. [mapan@localhost test]$ netstat -na | grep 8888 
    2. 
  
  
  2. tcp        0      0 0.0.0.0:8888                0.0.0.0:*                   LISTEN       
    3. 
  
  
  3. tcp        0      0 127.0.0.1:34846             127.0.0.1:8888              ESTABLISHED  
    4. 
  
  
  4. tcp        0      0 127.0.0.1:8888              127.0.0.1:34846             ESTABLISHED  
    5. 
  
  
  5. [mapan@localhost test]$ 
    6.

看，已经建立起一个连接了。但是我们没有调用accept函数，连接还是建立起来了，这说说明accept函数和TCP三次握手没啥关系，这也是一个知识盲点。好，在开启一个新窗口运行客户端，查看网络状态。(新开窗口运行客户端同上，这里就不用代码演示了)

 
 
    
  
  
  1. [mapan@localhost test]$ netstat -na | grep 8888 
    2. 
  
  
  2. tcp        0      0 0.0.0.0:8888                0.0.0.0:*                   LISTEN       
    3. 
  
  
  3. tcp        0      0 127.0.0.1:34846             127.0.0.1:8888              ESTABLISHED  
    4. 
  
  
  4. tcp        0      0 127.0.0.1:34848             127.0.0.1:8888              ESTABLISHED  
    5. 
  
  
  5. tcp        0      0 127.0.0.1:8888              127.0.0.1:34846             ESTABLISHED  
    6. 
  
  
  6. tcp        0      0 127.0.0.1:8888              127.0.0.1:34848             ESTABLISHED 
    7.

看，又建立起一个连接。在运行一个客户端，看网络状态。

 
 
    
  
  
  1. [mapan@localhost test]$ netstat -na | grep 8888 
    2. 
  
  
  2. tcp        0      0 0.0.0.0:8888                0.0.0.0:*                   LISTEN       
    3. 
  
  
  3. tcp        0      0 127.0.0.1:8888              127.0.0.1:34850             SYN_RECV     
    4. 
  
  
  4. tcp        0      0 127.0.0.1:34846             127.0.0.1:8888              ESTABLISHED  
    5. 
  
  
  5. tcp        0      0 127.0.0.1:34848             127.0.0.1:8888              ESTABLISHED  
    6. 
  
  
  6. tcp        0      0 127.0.0.1:8888              127.0.0.1:34846             ESTABLISHED  
    7. 
  
  
  7. tcp        0      0 127.0.0.1:8888              127.0.0.1:34848             ESTABLISHED  
    8. 
  
  
  8. tcp        0      0 127.0.0.1:34850             127.0.0.1:8888              ESTABLISHED 
    9.

当第三个客户端连接进来的时候，出现了一个SYN_RECV，这标明第三个客户端没有与服务端建立连接。

我们listen函数设置的监听队列为1，那么监听队列塞了2个之后就没有往里面塞了。这下大概懂了listen函数第二个参数的意义了吧，当参数为1的时候只能监听2个套接字，这应该是从0开始数的。

为什么是大概呢?其实unix网络编程上是这样说的：listen函数的第二个参数是ESTABLISHED和SYN_RECV之和，只是在监听队列没有满的情况下，SYN_RECV状态不容易重现。这时候在服务度输入一个字符会有啥效果呢?

答案告诉你，就是那个SYN_RECV状态变成ESTABLISHED了，这也是 accept函数的作用。accept函数会将已完成连接队列中的对头项返回给进程，所以SYN_RECV变成ESTABLISHED了。这个现象留给大家去实践一下吧，只有自己实践出来的东西才是自己的。

网站名称：窥探Socket监听的秘密
标题URL：http://www.zyruijie.cn/qtweb/news18/10768.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

建站公司知识

行业网站建设

三台网站建设　　 　成都品牌网站设计　　 　网站优化排名推广　　 　时嘉做网站　　 　简阳电信机房　　 　广安网站建设　　 　二枢服务器托管　　 　定制级高端网站建设　　 　成都艺考培训　　 　成都主机托管　　 　app开发　　 　响应式建站　　 　网站设计　　 　做网站设计　　 　香港云服务器租用　　 　深圳纱窗安装　　 　研学实践　　 　定制网站建设　　 　橡塑保温管　　 　宜宾网站建设