同一端口，如何区分不同的socket

2.很多防火墙只允许特定目标端口的数据包通过。

3.服务程序在listen某个端口并accept某个连接请求之后，会生成一个新的socket来对请求进行处理，

于是一个困惑我很久的问题产生了，如果一个socket创建后并与80端口绑定后，是否就意味着该socket占用了80端口呢？

如果是这样的，那么当其accept一个请求之后，生成的新的socket到底使用的是什么端口呢？（我一直以为系统会默认给其分配一个空闲的端口号）

如果是一个空闲的端口号，那么一定不是80端口了，于是以后的TCP数据包端口肯定就不是80 了--防火墙会阻止他通过的。

实际上我们可以看到，防火墙并没有阻止这样的连接，而且这是最常见的连接 请求和处理方式，我不理解的就是为什么防火墙没有阻止这样的连接，他是如何判断那条连接是因为connect80端口生成的？是不是TCP数据包里面有什么特别的标志，或者防火墙已经记住了什么东西？

后来我又仔细读了TCP/IP协议栈原理，对很多概念有了更深刻的认识，比如TCP和UDP同属于传输层，共同假设在IP层之上，而IP层主要负责在节点之间的数据包传输，这里的节点是一台网络设备，比如计算机，因为IP曾只负责把数据送到节点之上，而不能区分上面的不同应用，所以TCP、UDP在协议的基础上加入了端口的信息，端口是标识的是一个节点上的应用，处理增加端口信息，UDP协议基本就没有对IP层的数据进行任何处理了，而TCP协议还加入了更复杂的传输控制，比如滑动的数据发送窗口，以及接受确认和重发机制，以达到数据的可靠传输，不管应用层看到的是怎么样一个稳定的TCP数据流，下面传送的都是一个个的IP数据包，需要由TCP协议来进行数据*。

所以我有理由怀疑，防火墙并没有足够的信息判断TCP数据包的更多信息，除了IP地址和端口号，而且我们也看到，所谓的端口是为了区分不同的应用的，以在不同的IP包来到的时候能够正确的转发。

TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口，就像操作系统会提供标准的编程接口，比如Win32编程接口一样，TCP、IP也必须对外提供编程接口，这就是Socket编程接口--原来就是这么回事

在Socket编程接口里，设计者提出了一个很重要的概念，那就是socket。这个socket跟文件句柄很相似，实际上，在BSD系统里就是跟文件句柄一样存放在一样的进程句柄里。这个socket其实是一个序号，表示其在句柄表中的位置。这一点，我们已经见过很多了，比如文件句柄，窗口句柄等。这些句柄，其实是代表了系统中的某些特定的对象，用于在各种函数中作为参数传入，以对特定对象进行操作——这其实是C语言的问题，在C 语言里，这个句柄其实就是this指针，实际就是对象指针啦。

现在我们知道，socket跟TCP/IP并没有必然的联系。Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所以，socket的出现只是可以更方便的使用TCP/IP协议栈而已，其对TCP/IP进行了抽象，形成了几个最基本的函数接口。比如create, listen, accept, connect, read和write等。

现在我们明白，如果一个程序创建了一个socket，并让其监听80端口，其实是向TCP/IP协议栈声明了其对80端口的占有。以后，所有目标是80端口的TCP数据包都会转发给该程序(这里的程序，因为使用的是Socket编程接口，所以首先由Socekt层来处理)。所谓的accept函数，其实抽象的是TCP的连接建立过程。accept函数返回的新socket其实指代的是本次创建的连接，而一个连接是包括两部分信息的，一个是源IP和源端口，另一个宿IP和宿端口。这样的话，这些socket宿端口就可以都是80！而同时，防火墙的对IP包的处理规则也是清晰明了，不存在前面设想的种种复杂的情形。

明白socket只是对TCP/IP协议栈操作的抽象，而不是简单的映射关系，这很重要！

昨天和朋友聊了下网络编程，关于Socket，这里写一下我个人的一些理解:)

程序里可以创建Socket，分为普通Socket和原始Socket两种类型。

一：普通Socket是对TCP/IP协议栈中传输层的操作的编程接口(一种API)。

有面向连接的流式套接字(SOCK_STREAM)，属于针对TCP方式的应用；

有无连接数据包式套接字(SOCK_DGRAM)，属于针对UDP方式的应用。

对于普通Socket，我曾经有个模糊的问题，在多线程情况下，服务器端监听(listen)某个端口(假设8080)后，每accept一个客户端的连接就会产生一个新的Socket。那么这些新产生的Socket的端口是什么？程序里肯定没有指定，那就应该有两种可能，1：产生随机端口。2：还是8080端口。第一种假设想了就觉得不可能，防火墙非常有可能会阻止这些随机端口的包。那么就是第二种假设了，服务端端口还是8080。但这推翻了我原有的认识，就是“一个端口被程序占有，其他程序就不能用该端口了”。我觉得其实最有可能的是范围不同：就是在程序与程序间不能用同一端口，但是在程序内部不同的Socket还是可以用同一端口的。所以，为了能够使“客户端发给服务端的同一端口(8080)不同线程(即不同的Socket连接)的包能够被区分开并进行组合”，必须得有一个区分包是来自不同连接的显著特征，那就是传输层包头里的源端口了，即一个Socket连接里客户端那方的端口。总结一下，对于这种情况，就是传输层包头里源端口(客户端)会随着产生的Socket不同，而宿端口相同(服务器端)。

很多疑问都在文章里里找到了答案，特别是“端口是用来区分不同应用程序的”，之前也困惑多线程下，每个线程建立连接的端口是否可以相同。 另外文中说每accept一个连接会得到一个新的socket，这个表述不是很完美，其实不是一个新的socket而是得到了客户端的socket，这个socket里的ip和端口当然是客户端的ip和端口了。表达accept客户端之后，服务端用的是哪个端口。

单个进程监听多个端口

单个进程创建多个 socket 绑定不同的端口，TCP, UDP 都行

多个进程监听同一个端口(multiple processes listen on same port)

通过 fork 创建子进程的方式可以实现，其他情况下不行。

多线程情况下，服务器端监听(listen)某个端口后，每accept一个客户端的连接就会产生一个新的Socket

新产生的Socket的端口是多少？

答案是服务器端口还是Listen端口。

进程间不能用同一端口，但是进程内部不同Socket可以用同一个端口。

Client端发送给Server同一端口的不同Socket怎么区分。

用Client端Socket端口区分！

Socket是TCP/IP协议的网络接口 socket是对TCP/IP协议操作的抽象

客户端connect函数是开始调用到函数返回正好是三次握手的过程，第三次握手成功则返回

server端三次握手之后内核调用accept函数，accept函数执行后会产生一个新的socket与client端进行连接。

Q:编写 TCP/SOCK_STREAM 服务程序时，SO_REUSEADDR到底什么意思？

A:这个套接字选项通知内核，如果端口忙，但TCP状态位于 TIME_WAIT ，可以重用端口。如果端口忙，

而TCP状态位于其他状态，重用端口时依旧得到一个错误信息，指明"地址已经使用中"。如果你的服务程序停止

后想立即重启，而新套接字依旧使用同一端口，此时SO_REUSEADDR 选项非常有用。必须意识到，此时任何

非期望数据到达，都可能导致服务程序反应混乱，不过这只是一种可能，事实上很不可能。

端口复用最常用的用途应该是防止服务器重启时之前绑定的端口还未释放或者程序突然退出而系统没有释放端口。这种情况下如果设定了端口复用，则新启动的服务器进程可以直接绑定端口。如果没有设定端口复用，绑定会失败，提示ADDR已经在使用中——那只好等等再重试了，麻烦！

那如何让sockfd_one, sockfd_two两个套接字都能成功绑定8000端口呢？这时候就需要要到端口复用了。端口复用允许在一个应用程序可以把 n 个套接字绑在一个端口上而不出错。

设置socket的SO_REUSEADDR选项，即可实现端口复用：

int opt = 1; // sockfd为需要端口复用的套接字 setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

SO_REUSEADDR可以用在以下四种情况下。 (摘自《Unix网络编程》卷一，即UNPv1)

1、当有一个有相同本地地址和端口的socket1处于TIME_WAIT状态时，而你启动的程序的socket2要占用该地址和端口，你的程序就要用到该选项。

2、SO_REUSEADDR允许同一port上启动同一服务器的多个实例(多个进程)。但每个实例绑定的IP地址是不能相同的。在有多块网卡或用IP Alias技术的机器可以测试这种情况。

3、SO_REUSEADDR允许单个进程绑定相同的端口到多个socket上，但每个socket绑定的ip地址不同。这和2很相似，区别请看UNPv1。

4、SO_REUSEADDR允许完全相同的地址和端口的重复绑定。但这只用于UDP的多播，不用于TCP。

需要注意的是，设置端口复用函数要在绑定之前调用，而且只要绑定到同一个端口的所有套接字都得设置复用：

// sockfd_one, sockfd_two都要设置端口复用 // 在sockfd_one绑定bind之前，设置其端口复用 int opt = 1; setsockopt( sockfd_one, SOL_SOCKET,SO_REUSEADDR, (const void *)&opt, sizeof(opt) ); err_log = bind(sockfd_one, (struct sockaddr*)&my_addr, sizeof(my_addr)); // 在sockfd_two绑定bind之前，设置其端口复用 opt = 1; setsockopt( sockfd_two, SOL_SOCKET,SO_REUSEADDR,(const void *)&opt, sizeof(opt) ); err_log = bind(sockfd_two, (struct sockaddr*)&my_addr, sizeof(my_addr));

端口复用允许在一个应用程序可以把 n 个套接字绑在一个端口上而不出错。同时，这 n 个套接字发送信息都正常，没有问题。但是，这些套接字并不是所有都能读取信息，只有最后一个套接字会正常接收数据。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <pthread.h> // 线程1的回调函数 void *recv_one(void *arg) { printf("===========recv_one==============\n"); int sockfd = (int )arg; while(1){ int recv_len; char recv_buf[512] = ""; struct sockaddr_in client_addr; char cli_ip[INET_ADDRSTRLEN] = "";//INET_ADDRSTRLEN=16 socklen_t cliaddr_len = sizeof(client_addr); recv_len = recvfrom(sockfd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&client_addr, &cliaddr_len); inet_ntop(AF_INET, &client_addr.sin_addr, cli_ip, INET_ADDRSTRLEN); printf("\nip:%s ,port:%d\n",cli_ip, ntohs(client_addr.sin_port)); printf("sockfd_one =========== data(%d):%s\n",recv_len,recv_buf); } return NULL; } // 线程2的回调函数 void *recv_two(void *arg) { printf(" recv_two \n"); int sockfd = (int )arg; while(1){ int recv_len; char recv_buf[512] = ""; struct sockaddr_in client_addr; char cli_ip[INET_ADDRSTRLEN] = "";//INET_ADDRSTRLEN=16 socklen_t cliaddr_len = sizeof(client_addr); recv_len = recvfrom(sockfd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&client_addr, &cliaddr_len); inet_ntop(AF_INET, &client_addr.sin_addr, cli_ip, INET_ADDRSTRLEN); printf("\nip:%s ,port:%d\n",cli_ip, ntohs(client_addr.sin_port)); printf("sockfd_two @@@@@@@@@@@@@@@ data(%d):%s\n",recv_len,recv_buf); } return NULL; } int main(int argc, char *argv[]) { int err_log; /////////////////////////sockfd_one int sockfd_one; sockfd_one = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字one if(sockfd_one < 0) { perror("sockfd_one"); exit(-1); } // 设置本地网络信息 struct sockaddr_in my_addr; bzero(&my_addr, sizeof(my_addr)); my_addr.sin_family = AF_INET; my_addr.sin_port = htons(8000); // 端口为8000 my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 在sockfd_one绑定bind之前，设置其端口复用 int opt = 1; setsockopt( sockfd_one, SOL_SOCKET,SO_REUSEADDR, (const void *)&opt, sizeof(opt) ); // 绑定，端口为8000 err_log = bind(sockfd_one, (struct sockaddr*)&my_addr, sizeof(my_addr)); if(err_log != 0) { perror("bind sockfd_one"); close(sockfd_one); exit(-1); } //接收信息线程1 pthread_t tid_one; pthread_create(&tid_one, NULL, recv_one, (void *)sockfd_one); /////////////////////////sockfd_two int sockfd_two; sockfd_two = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字two if(sockfd_two < 0) { perror("sockfd_two"); exit(-1); } // 在sockfd_two绑定bind之前，设置其端口复用 opt = 1; setsockopt( sockfd_two, SOL_SOCKET,SO_REUSEADDR, (const void *)&opt, sizeof(opt) ); // 新套接字sockfd_two，继续绑定8000端口，成功 err_log = bind(sockfd_two, (struct sockaddr*)&my_addr, sizeof(my_addr)); if(err_log != 0) { perror("bind sockfd_two"); close(sockfd_two); exit(-1); } //接收信息线程2 pthread_t tid_two; pthread_create(&tid_two, NULL, recv_two, (void *)sockfd_two); while(1){ // 让程序阻塞在这，不结束 NULL; } close(sockfd_one); close(sockfd_two); return 0; }

接着，通过网络调试助手给这个服务器发送数据，结果显示，只有最后一个套接字sockfd_two会正常接收数据。

一个连接的唯一标识是[server ip, server port, client ip, client port]也就是说。操作系统，接收到一个端口发来的数据时，会在该端口，产生的连接中，查找到符合这个唯一标识的并传递信息到对应缓冲区。

所以说一个socket可以对应多个tcp连接。