一、1個端口號可以同時被兩個進程綁定嗎？

根據端口號的綁定我們分以下幾種情況來討論：

1. 2個進程分別建立TCP server，使用同一個端口號8888
2. 2個進程分別建立UDP server，使用同一個端口號8888
3. 2個進程1個建立TCP server、1個建立UDP server，都使用端口號8888

1. 測試代碼

我們首先編寫兩個簡單的測試程序。

tcp.c

該程序僅僅創建tcp套接字并綁定端口號8888，沒有accept建立連接操作，并且sleep(1000)，讓進程不要太快退出。

/*******服務器程序TCPServer.c************/
#include
#include
#include
#include
#include
#include
#include
#include
#include

#defineWAITBUF10
#defineRECVBUFSIZE1024


intmain(intargc,char*argv[])
{
intsockfd,new_fd,nbytes;
structsockaddr_inserver_addr;
structsockaddr_inclient_addr;
intportnumber=8888;
socklen_tsin_size;
charhello[512];
charbuffer[RECVBUFSIZE];

/*端口號不對，退出*/

/*服務器端開始建立socket描述符*/
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
fprintf(stderr,"Socketerror:%s
a",strerror(errno));
exit(1);
}

/*服務器端填充sockaddr結構*/
bzero(&server_addr,sizeof(structsockaddr_in));
server_addr.sin_family=AF_INET;
/*自動填充主機IP*/
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
server_addr.sin_port=htons(portnumber);

/*捆綁sockfd描述符進程+端口號+ip+socket*/
if(bind(sockfd,(structsockaddr*)(&server_addr),sizeof(structsockaddr))==-1)
{
fprintf(stderr,"Binderror:%s
a",strerror(errno));
exit(1);
}

/*監聽sockfd描述符*/
if(listen(sockfd,WAITBUF)==-1)
{
fprintf(stderr,"Listenerror:%s
a",strerror(errno));
exit(1);
}

sleep(1000);//讓程序不要這么快的退出
close(sockfd);
exit(0);
}

udp.c

該程序僅僅創建udp套接字并綁定端口號8888，沒有accept建立連接操作，并且sleep(1000)，讓進程不要太快退出.

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#defineSERVER_PORT8888
#defineMAX_MSG_SIZE1024


intmain(void)
{
intsockfd;
structsockaddr_inaddr;

/*服務器端開始建立socket描述符*/
sockfd=socket(AF_INET,SOCK_DGRAM,0);
if(sockfd<0)
{
fprintf(stderr,"SocketError:%s
",strerror(errno));
exit(1);
}

/*服務器端填充sockaddr結構*/
bzero(&addr,sizeof(structsockaddr_in));
addr.sin_family=AF_INET;
addr.sin_addr.s_addr=htonl(INADDR_ANY);
addr.sin_port=htons(SERVER_PORT);

/*捆綁sockfd描述符*/
if(bind(sockfd,(structsockaddr*)&addr,sizeof(structsockaddr_in))<0)
{
fprintf(stderr,"BindError:%s
",strerror(errno));
exit(1);
}
sleep(1000);
close(sockfd);
}

編譯

gcctcp.c-otcp
gccudp.c-oudp

2. 執行結果

1).2個進程分別建立TCP server

從結果可知，第二個進程綁定端口號8888綁定失敗。

2).2個進程分別建立UDP server

從結果可知，第二個進程綁定端口號8888綁定失敗。

3).1個建立TCP server、1個建立UDP server

用netstat命令查看信息。

從結果可知，該種情形，兩個進程分別綁定成功。

3. 結果分析

由上述結果可知：TCP、UDP可以同時綁定一個端口8888，但是一個端口在同一時刻不可以被TCP或者UDP綁定2次。原因如下：

1. tcp的端口不是物理概念，僅僅是協議棧中的兩個字節；
2. TCP和UDP的端口完全沒有任何關系，完全有可能又有一種XXP基于IP，也有端口的概念，這是完全可能的；
3. TCP和UDP傳輸協議監聽同一個端口后，接收數據互不影響，不沖突。因為數據接收時時根據五元組**{傳輸協議，源IP，目的IP，源端口，目的端口}**判斷接受者的。

二、端口號的一些其他知識點

1. 端口號的作用

端口號可以用來標識同一個主機上通信的不同應用程序，端口號+IP地址就可以組成一個套接字，用來標識一個進程。

2. 端口號的應用場景

在TCP/IP協議中，用“源IP地址”，“目的IP地址”，“源端口號”，“目的端口號”,協議號（IP協議的協議號為4，TCP的協議號為6）這樣的一個五元組來標識一個通信，通信的雙方在發送消息時，消息的頭部會帶著這樣的五元組。

3. 端口范圍劃分

（1）0~1023：知名端口號，是留著備用的，一把都是用于協議，例如HTTP、FTP、SSH ；

（2）1024~65535：是操作系統動態分配的端口號，客戶端程序的端口號，就是由操作糸統從這個范圍來分配的，在TCP與UDP的套接字通信中，客戶端的端口號就是在此范圍中。

4. 知名的端口號與端口號對應的服務器

比如：

HTTP服務器：80
FTP服務器：21

ps：FTP有一個控制連接和一個數據連接，所以FTP是有兩個端口號的，控制連接的端口號是21，數據連接的端口號是20，但是如果FTP的端口號默認是21，如果指明FTP有兩個端口號的話，那就是21和20，否則FTP服務器的端口號就是21

TELNET服務器：23
SSH服務器：22
HTTPS：443
WEB服務器：25

5. 在linux中如何查看知名端口號？

cat/etc/services

6. 一個進程是否可以bind多個端口號？

可以

因為一個進程可以打開多個文件描述符，而每個文件描述符都對應一個端口號，所以一個進程可以綁定多個端口號。

Linux內核會給每一個socket分配一個唯一的文件描述符，進程通過該文件描述符來區分對應的套接字。

7. 一個端口號是否可以被多個進程綁定？

同種協議通常不可以，但有一種情況可以。

ps：如果進程先綁定一個端口號，然后在fork一個子進程，這樣的話就可以是實現多個進程綁定一個端口號，但是兩個不同的進程綁定同一個端口號是不可以的。

三、SO_REUSEADDR有什么用處和怎么使用？

當兩個socket的address和port相沖突，而我們又想重用地址和端口，則舊的socket和新的socket都要已經被設置了SO_REUSEADDR特性，只有兩者之一有這個特性還是有問題的。

SO_REUSEADDR可以用在以下四種情況下。(摘自《Unix網絡編程》卷一，即UNPv1)

1. 當有一個有相同本地地址和端口的socket1處于TIME_WAIT狀態時【4次握手】，而你啟動的程序的socket2要占用該地址和端口，你的程序就要用到該選項。

一般來說，一個端口釋放后會等待兩分鐘之后才能再被使用，SO_REUSEADDR是讓端口釋放后立即就可以被再次使用。

SO_REUSEADDR用于對TCP套接字處于TIME_WAIT狀態下的socket，才可以重復綁定使用。server程序總是應該在調用bind()之前設置SO_REUSEADDR套接字選項。TCP，先調用close()的一方會進入TIME_WAIT狀態。

4次握手順序見下圖：

2. SO_REUSEADDR允許同一port上啟動同一服務器的多個實例(多個進程)。但每個實例綁定的IP地址是不能相同的。在有多塊網卡或用IP Alias技術的機器可以測試這種情況。

3. SO_REUSEADDR允許單個進程綁定相同的端口到多個socket上，但每個socket綁定的ip地址不同。這和2很相似，區別請看UNPv1。

SO_REUSEADDR允許啟動一個監聽服務器并捆綁其眾所周知端口，即使以前建立的將此端口用做他們的本地端口的連接仍存在。這通常是重啟監聽服務器時出現，若不設置此選項，則bind時將出錯。

SO_REUSEADDR允許在同一端口上啟動同一服務器的多個實例，只要每個實例捆綁一個不同的本地IP地址即可。對于TCP，我們根本不可能啟動捆綁相同IP地址和相同端口號的多個服務器。

SO_REUSEADDR允許單個進程捆綁同一端口到多個套接口上，只要每個捆綁指定不同的本地IP地址即可。這一般不用于TCP服務器。

4. SO_REUSEADDR允許完全相同的地址和端口的重復綁定。但這只用于UDP的多播，不用于TCP。

SO_REUSEADDR允許完全重復的捆綁：當一個IP地址和端口綁定到某個套接口上時，還允許此IP地址和端口捆綁到另一個套接口上。一般來說，這個特性僅在支持多播的系統上才有，而且只對UDP套接口而言（TCP不支持多播）。

SO_REUSEPORT選項有如下語義：此選項允許完全重復捆綁，但僅在想捆綁相同IP地址和端口的套接口都指定了此套接口選項才行。

如果被捆綁的IP地址是一個多播地址，則SO_REUSEADDR和SO_REUSEPORT等效。

使用這兩個套接口選項的建議：在所有TCP服務器中，在調用bind之前設置SO_REUSEADDR套接口選項；當編寫一個同一時刻在同一主機上可運行多次的多播應用程序時，設置SO_REUSEADDR選項，并將本組的多播地址作為本地IP地址捆綁。

設置方法如下：

if(setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,
(constvoid*)&nOptval,sizeof(int))0)
...

附

Q:編寫 TCP/SOCK_STREAM 服務程序時，SO_REUSEADDR到底什么意思？

A:這個套接字選項通知內核，如果端口忙，但TCP狀態位于 TIME_WAIT ，可以重用端口。如果端口忙，而TCP狀態位于其他狀態，重用端口時依舊得到一個錯誤信息，指明"地址已經使用中"。如果你的服務程序停止后想立即重啟，而新套接字依舊使用同一端口，此時SO_REUSEADDR 選項非常有用。必須意識到，此時任何非期望數據到達，都可能導致服務程序反應混亂，不過這只是一種可能，事實上很不可能。

一個套接字由相關五元組構成，協議、本地地址、本地端口、遠程地址、遠程端口。SO_REUSEADDR 僅僅表示可以重用本地本地地址、本地端口，整個相關五元組還是唯一確定的。所以，重啟后的服務程序有可能收到非期望數據。必須慎重使用 SO_REUSEADDR 選項。

舉例

例子1:測試上面第一種情況。

#include
#include
#include
#include
#include
#defineMAXLINE100

intmain(intargc,char**argv)
{
intlistenfd,connfd;
structsockaddr_inservaddr;
charbuff[MAXLINE+1];
time_tticks;
unsignedshortport;
intflag=1,len=sizeof(int);

port=10013;

if((listenfd=socket(AF_INET,SOCK_STREAM,0))==-1)

{
perror("socket");
exit(1);
}

bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(port);

if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&flag,len)==-1)
{
perror("setsockopt");
exit(1);
}

if(bind(listenfd,(structsockaddr*)&servaddr,sizeof(servaddr))==-1)
{
perror("bind");
exit(1);
}
else
printf("bindcallOK!
");

if(listen(listenfd,5)==-1)
{
perror("listen");
exit(1);
}

for(;;)
{
if((connfd=accept(listenfd,(structsockaddr*)NULL,NULL))==-1)
{
perror("accept");
exit(1);
}
if(fork()==0)/*childprocess*/
{
close(listenfd);/*關閉監聽套接字，子進程不需要。*/

ticks=time(NULL);
snprintf(buff,100,"%.24s
",ctime(&ticks));

write(connfd,buff,strlen(buff));
close(connfd);

sleep(1);

execlp("run",NULL);
perror("execlp");
exit(1);
}
close(connfd);
exit(0);/*endparent*/
}
}

gcc123.c-orun
sudocprun/sbin
sudochmod777/sbin/run

測試：編譯為run程序，放到一個自己PATH環境變量里的某個路徑里，例如$HOME/bin，運行run，然后telnet localhost 10013看結果。

第一步運行程序，此時程序阻塞在accept（）這個位置。

第二步重新打開一個終端，執行以下命令。

第三步：可以看到次異步運行的程序退出，并打印了bind call OK!說明子進程被執行，并且成功綁定了端口10013，驗證了第一種情況。

2. 第二種情況我沒有環境測，所以就不給測試程序了，大家有條件的可以自己寫一個來測試一下。

3. 測試第三種情況的程序讀取本地ip地址

可以得到本地地址為：

eth0：192.168.43.171
lo:127.0.0.1

測試代碼

#include
#include
#include
#include
#include
#defineMAXLINE100

intmain(intargc,char**argv)
{
intfd1,fd2;
structsockaddr_inservaddr1,servaddr2;
charbuff[MAXLINE+1];
time_tticks;
unsignedshortport;
intflag=1,len=sizeof(int);

port=10013;

if((fd1=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(1);
}

if((fd2=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(1);
}

bzero(&servaddr1,sizeof(servaddr1));
bzero(&servaddr2,sizeof(servaddr2));
servaddr1.sin_family=AF_INET;
servaddr2.sin_family=AF_INET;

if(inet_pton(AF_INET,"127.0.0.1",&servaddr1.sin_addr)<=?0)
{
printf("inet_pton()callerror:127.0.0.1
");
exit(1);
}

if(inet_pton(AF_INET,"192.168.43.171",&servaddr2.sin_addr)<=?0)
{
printf("inet_pton()callerror:128.160.1.230
");
exit(1);
}

servaddr1.sin_port=htons(port);
servaddr2.sin_port=htons(port);

if(setsockopt(fd1,SOL_SOCKET,SO_REUSEADDR,&flag,len)==-1)
{
perror("setsockopt");
exit(1);
}

if(setsockopt(fd2,SOL_SOCKET,SO_REUSEADDR,&flag,len)==-1)
{
perror("setsockopt");
exit(1);
}

if(bind(fd1,(structsockaddr*)&servaddr1,sizeof(servaddr1))==-1)
{
perror("bindfd1");
exit(1);
}

if(bind(fd2,(structsockaddr*)&servaddr2,sizeof(servaddr2))==-1)
{
perror("bindfd2");
exit(1);
}

printf("bindfd1andfd2OK!
");

/*putotherprocesshere*/
getchar();
exit(0);/*end*/
}

執行結果

4. 由于第四種情況只用于UDP的多播，和TCP的使用沒多大關系，所以就不寫測試例子了。自己有興趣的可以寫。