一个多socket绑定同一个端口的测试程序

 

测试目标：建立多个socket的测试

 

测试环境：suse Linux

 

测试步骤：建立了3个socket，但是由于绑定了不同的端口，可以邦定成功；假如绑定相同的端口，则相继失败。而关闭socket的时候，调用shutdown失败，而close却可以成功。

在stevens的书本中，则建议使用shutdown来关闭，但是，不成功。

 

测试结果：

goal: test multi socket could be binded in the same port
creating socket:
socket is created: 3
socket is created: 4
socket is created: 5

current pid: %d
18116

bind socket:

binding the 8000 port
binding the 8001 port
binding the 8002 port

shut down  the socket
shut down socket 1 error
shut down socket 2 error
shut down socket 333 error

疑问：

1、为什么一个程序不同的socket不可以邦定同一个端口呢？

2、为什么shutdown失败？而close则可以成功呢？

3、为什么多个进程里面，每个进程都有一个socket，多个进程绑定的却是同一个端口，还是失败呢？

 

测试源代码：

 

3. #include <stdlib.h>
4. #include <stdio.h>
5. #include <unistd.h>
6. #include <sys/time.h>
7. #include <sys/types.h>
8. #include <string.h>
9. #include <signal.h>
10. #include <sys/socket.h>
11. #include <netinet/in.h>
12. #include <arpa/inet.h>
13. #include <errno.h>
14. #include <unistd.h>
16. #include <iostream>
17. using namespace std;
19. int bind_socket(int sock, int port);
20. int create_socket();
22. int main(int argc, char** argv)
23. {
24.     std::cout << "goal: test multi socket could be binded in the same port" << endl;
25.     
26.     int socket_1, socket_2, socket_3;
27.     int port_1 = 8000, port_2 = 8001, port_3 = 8002;
29.     std::cout << "creating socket:" << endl;    
30.     socket_1 = create_socket();
31.     std::cout << "socket is created: " << socket_1 << endl;
32.     
33.     socket_2 = create_socket();
34.     std::cout << "socket is created: " << socket_2 << endl;
35.          
36.     socket_3 = create_socket();
37.     std::cout << "socket is created: " << socket_3 << endl;
39.     std::cout << "/n/ncurrent pid: " << getpid() << endl;
40.     std::cout << "/n/nbind socket:/n" << endl;
42.     std::cout << "binding the " << port_1 << " port" << endl;
43.     if(bind_socket(socket_1, port_1) == -1 )
44.     {
45.         std::cout << "bind socket 1 error" << endl;    
46.     }
47.     
48.     std::cout << "binding the " << port_2 << " port" << endl;
49.     if(bind_socket(socket_2, port_2) == -1 )
50.     {
51.         std::cout << "bind socket 2 error" << endl;    
52.     }
53.     
54.     std::cout << "binding the " << port_3 << " port" << endl;
55.     if(bind_socket(socket_3, port_3) == -1 )
56.     {
57.         std::cout << "bind socket 3 error" << endl; 
58.     }
61.     std::cout << "/n/nshut down  the socket" << endl;
62.     if(shutdown(socket_1, SHUT_RDWR) == -1)
63.     {
64.         std::cout << "shut down socket 1 error" << endl;
65.      if(close(socket_1) == -1)
66.          std::cout << "close socket 1 failed" << endl;
67.     }
68.     
69.     if(shutdown(socket_2, SHUT_RDWR) == -1)
70.     {
71.         std::cout << "shut down socket 2 error" << endl;
72.     }
73.     
74.     if(shutdown(socket_3, SHUT_RDWR) == -1)
75.     {
76.         std::cout << "shut down socket 333 error" << endl;
77.     }
79.     return 1; 
80. }
82. int create_socket()
83. {
84.     int s;
85.     
86.     if((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
87.     {
88.         std::cout << "create socket failed!" << endl;
89.         close(s);
90.         return -1;
91.     }
92.     
93.     return s;
94. }
96. int bind_socket(int sock, int port)
97. {
98.     struct sockaddr_in addr;
99.     if(sock <= 0)
100.     {
101.         std::cout << "input socket error: " << sock << endl;    
102.         return -1;
103.     }
104.     
105.     if(port <= 1024)
106.     {
107.         std::cout << "intput port error: " << port << endl;
108.         return -1;    
109.     }
110.     
111.     memset(&addr, 0, sizeof(addr));
112.     addr.sin_port = htons (port);
113.     addr.sin_family = AF_INET;
114.     
115.     int ret = bind(sock,(struct sockaddr *)&addr, sizeof(addr));
116.     if( ret < 0) 
117.     {
118.         std::cout << "bind error: " << ret << endl;
119.         close(sock);
120.      std::cout << "close socket: " << sock << endl;
121.         return -1;
122.     }
123.     
124.     return ret;   
125. }

结果分析：

问题1：同事告诉我可以的，结果证明不行。说明Ericsson的TSP的强大性，哈哈

问题2：看来就用close吧。在TSP封装后的接口中，使用的是close而不是shutdown，在通用程序中，也是使用close居多。而两者的最大区别就是socket descriptor dup之后的差别，也就是说，不把socket descriptor dup的话，两者效果一样。

问题3：我使用的测试程序是：启动程序，然后fork两个进程，每个都建立一个socket，这样3个socket都绑定到了同一个端口，结果失败。因此，并不是每个进程都可以侦听同一个端口的。这样一说，也不难理解啦。

 

欢迎拍砖！