socket--socket()、bind()、listen()、connect()、accept()、recv()、send()、select()、close()、shutdown()

侵刪

轉載自 http://blog.csdn.net/amaowolf/article/details/8008575 
轉載自 http://www.cnblogs.com/jianqiang2010/archive/2010/08/20/1804598.html 
轉載自 吳秦http://www.cnblogs.com/skynet/archive/2010/12/12/1903949.html 
轉載自http://blog.csdn.net/lgp88/article/details/7176509 
轉載自http://www.cnblogs.com/ccsccs/articles/4224253.html 
轉載自http://blog.csdn.net/piaojun_pj/article/details/5991968/ 
轉載自http://www.it.uom.gr/teaching/distrubutedSite/dsIdaLiu/labs/lab2_1/sockets.html

一、 網絡中進程之間如何通訊

首要解決的問題是如何惟一標識一個進程，在本地能夠經過進程PID來惟一標識一個進程，可是在網絡中這是行不通的。其實TCP/IP協議族已經幫咱們解決了這個問題，網絡層的ip地址能夠惟一標識網絡中的主機，而傳輸層的協議+端口能夠惟一標識主機中的應用程序（進程）。這樣利用三元組（ip地址，協議，端口）就能夠標識網絡的進程了，網絡中的進程通訊就能夠利用這個標誌與其它進程進行交互。

二、 Socket是什麼

socket起源於Unix，而Unix/Linux基本哲學之一就是「一切皆文件」，均可以用「打開open –> 讀寫write/read –> 關閉close」模式來操做。個人理解就是Socket就是該模式的一個實現，socket便是一種特殊的文件，一些socket函數就是對其進行的操做（讀/寫IO、打開、關閉）。 
說白了Socket是應用層與TCP/IP協議族通訊的中間軟件抽象層，它是一組接口。在設計模式中，Socket其實就是一個門面模式，它把複雜的TCP/IP協議族隱藏在Socket接口後面，對用戶來講，一組簡單的接口就是所有，讓Socket去組織數據，以符合指定的協議。 

三、 Socket的基本操做

3.一、socket()函數

int socket(int domain, int type, int protocol);

socket函數對應於普通文件的打開操做。普通文件的打開操做返回一個文件描述字，而socket()用於建立一個socket描述符（socket descriptor），它惟一標識一個socket。這個socket描述字跟文件描述字同樣，後續的操做都有用到它，把它做爲參數，經過它來進行一些讀寫操做。

正如能夠給fopen的傳入不一樣參數值，以打開不一樣的文件。建立socket的時候，也能夠指定不一樣的參數建立不一樣的socket描述符，socket函數的三個參數分別爲： 
•domain：即協議域，又稱爲協議族（family）。經常使用的協議族有，AF_INET（IPv4)、AF_INET6(IPv6)、AF_LOCAL（或稱AF_UNIX，Unix域socket）、AF_ROUTE等等。協議族決定了socket的地址類型，在通訊中必須採用對應的地址，如AF_INET決定了要用ipv4地址（32位的）與端口號（16位的）的組合、AF_UNIX決定了要用一個絕對路徑名做爲地址。 
•type：指定socket類型。經常使用的socket類型有，SOCK_STREAM（流式套接字）、SOCK_DGRAM（數據報式套接字）、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等 
•protocol：就是指定協議。經常使用的協議有，IPPROTO_TCP、PPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它們分別對應TCP傳輸協議、UDP傳輸協議、STCP傳輸協議、TIPC傳輸協議。

注意：並非上面的type和protocol能夠隨意組合的，如SOCK_STREAM不能夠跟IPPROTO_UDP組合。當protocol爲0時，會自動選擇type類型對應的默認協議。

3.1.一、 命名socket

SOCK_STREAM式套接字的通訊雙方均須要具備地址，其中服務器端的地址須要明確指定，ipv4的指定方法是使用 struct sockaddr_in類型的變量。

struct sockaddr_in {
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};
/* Internet address. */
struct in_addr {
    uint32_t       s_addr;     /* address in network byte order */
};

struct sockaddr_in     servaddr;  
memset(&servaddr, 0, sizeof(servaddr));  
servaddr.sin_family = AF_INET;  
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//IP地址設置成INADDR_ANY,讓系統自動獲取本機的IP地址。  
servaddr.sin_port = htons(DEFAULT_PORT);//設置的端口

INADDR_ANY就是指定地址爲0.0.0.0的地址，這個地址事實上表示不肯定地址，或「全部地址」、「任意地址」。也就是表示本機的全部IP，由於有些機子不止一塊網卡，多網卡的狀況下，這個就表示全部網卡ip地址的意思。客戶端connect時，不能使用INADDR_ANY選項。必須指明要鏈接哪一個服務器IP。

htons將主機的無符號短整形數轉換成網絡字節順序 
htonl將主機的無符號長整形數轉換成網絡字節順序

網絡字節序與主機字節序： 
主機字節序就是咱們日常說的大端和小端模式：不一樣的CPU有不一樣的字節序類型，這些字節序是指整數在內存中保存的順序，這個叫作主機序。引用標準的Big-Endian和Little-Endian的定義以下： 
　　a) Little-Endian就是低位字節排放在內存的低地址端，高位字節排放在內存的高地址端。 
　　b) Big-Endian就是高位字節排放在內存的低地址端，低位字節排放在內存的高地址端。 
網絡字節序：4個字節的32 bit值如下面的次序傳輸：首先是0～7bit，其次8～15bit，而後16～23bit，最後是24~31bit。這種傳輸次序稱做大端字節序。因爲TCP/IP首部中全部的二進制整數在網絡中傳輸時都要求以這種次序，所以它又稱做網絡字節序。字節序，顧名思義字節的順序，就是大於一個字節類型的數據在內存中的存放順序，一個字節的數據沒有順序的問題了。

在將一個地址綁定到socket的時候，請先將主機字節序轉換成爲網絡字節序，而不要假定主機字節序跟網絡字節序同樣使用的是Big-Endian。謹記對主機字節序不要作任何假定，務必將其轉化爲網絡字節序再賦給socket。

當咱們調用socket建立一個socket時，返回的socket描述字它存在於協議族（address family，AF_XXX）空間中，但沒有一個具體的地址。若是想要給它賦值一個地址，就必須調用bind()函數，不然就當調用connect()、listen()時系統會自動隨機分配一個端口。

3.二、bind()函數

bind()函數把一個地址族中的特定地址賦給socket。例如對應AF_INET、AF_INET6就是把一個ipv4或ipv6地址和端口號組合賦給socket。

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

函數的三個參數分別爲： 
•sockfd：即socket描述字，它是經過socket()函數建立了，惟一標識一個socket。bind()函數就是將給這個描述字綁定一個名字。 
•addr：一個const struct sockaddr *指針，指向要綁定給sockfd的協議地址。

struct sockaddr{
    sa_family_t  sin_family;   //地址族（Address Family），也就是地址類型
    char         sa_data[14];  //IP地址和端口號
};

sockaddr 是一種通用的結構體，能夠用來保存多種類型的IP地址和端口號。要想給 sa_data 賦值，必須同時指明IP地址和端口號，例如」127.0.0.1:80「，但沒有相關函數將這個字符串轉換成須要的形式，也就很難給 sockaddr 類型的變量賦值。正是因爲通用結構體 sockaddr 使用不便，才針對不一樣的地址類型定義了不一樣的結構體。 如ipv6對應的是：

struct sockaddr_in6 { 
    sa_family_t     sin6_family;   /* AF_INET6 */ 
    in_port_t       sin6_port;     /* port number */ 
    uint32_t        sin6_flowinfo; /* IPv6 flow information */ 
    struct in6_addr sin6_addr;     /* IPv6 address */ 
    uint32_t        sin6_scope_id; /* Scope ID (new in 2.4) */ 
};

struct in6_addr { 
    unsigned char   s6_addr[16];   /* IPv6 address */ 
};

Unix域對應的是：

#define UNIX_PATH_MAX    108

struct sockaddr_un { 
    sa_family_t sun_family;               /* AF_UNIX */ 
    char        sun_path[UNIX_PATH_MAX];  /* pathname */ 
};

•addrlen：對應的是地址的長度。 
一般服務器在啓動的時候都會綁定一個衆所周知的地址（如ip地址+端口號），用於提供服務，客戶就能夠經過它來接連服務器；而客戶端就不用指定，有系統自動分配一個端口號和自身的ip地址組合。這就是爲何一般服務器端在listen以前會調用bind()，而客戶端就不會調用，而是在connect()時由系統隨機生成一個。

3.3 listen()、connect()函數

若是做爲一個服務器，在調用socket()、bind()以後就會調用listen()來監聽這個socket，若是客戶端這時調用connect()發出鏈接請求，服務器端就會接收到這個請求。

int listen(int sockfd, int backlog);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

listen函數的第一個參數即爲要監聽的socket描述字，第二個參數爲相應socket能夠排隊的最大鏈接個數。socket()函數建立的socket默認是一個主動類型的，listen函數將socket變爲被動類型的，等待客戶的鏈接請求。

connect函數的第一個參數即爲客戶端的socket描述字，第二參數爲服務器的socket地址，第三個參數爲socket地址的長度。客戶端經過調用connect函數來創建與TCP服務器的鏈接。

3.4 accept()函數

TCP服務器端依次調用socket()、bind()、listen()以後，就會監聽指定的socket地址了。TCP客戶端依次調用socket()、connect()以後就向TCP服務器發送了一個鏈接請求。TCP服務器監聽到這個請求以後，就會調用accept()函數取接收請求，這樣鏈接就創建好了。以後就能夠開始網絡I/O操做了，即類同於普通文件的讀寫I/O操做。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

accept函數的第一個參數爲服務器的socket描述字，第二個參數爲指向struct sockaddr *的指針，用於返回客戶端的協議地址，第三個參數爲客戶端協議地址的長度。若是accpet成功，那麼其返回值是由內核自動生成的一個全新的描述字，表明與返回客戶的TCP鏈接。

注意：accept的第一個參數爲服務器的socket描述字，是服務器開始調用socket()函數生成的，稱爲監聽socket描述字；而accept函數返回的是已鏈接的socket描述字。一個服務器一般一般僅僅只建立一個監聽socket描述字，它在該服務器的生命週期內一直存在。內核爲每一個由服務器進程接受的客戶鏈接建立了一個已鏈接socket描述字，當服務器完成了對某個客戶的服務，相應的已鏈接socket描述字就被關閉。

3.5 recv()、send()等函數

至此服務器與客戶已經創建好鏈接了。能夠調用網絡I/O進行讀寫操做了，即實現了網咯中不一樣進程之間的通訊！網絡I/O操做有下面幾組： 
•read()/write() 
•recv()/send() 
•readv()/writev() 
•recvmsg()/sendmsg() 
•recvfrom()/sendto()

它們的聲明以下：

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);
#include <sys/types.h>
#include <sys/socket.h>
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
ssize_t sendto(int sockfd, const void *buf, size_t len, int  flags,const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

read函數是負責從fd中讀取內容。當讀成功時，read返回實際所讀的字節數，若是返回的值是0表示已經讀到文件的結束了，小於0表示出現了錯誤。若是錯誤爲EINTR說明讀是由中斷引發的，若是是ECONNREST表示網絡鏈接出了問題。

write函數將buf中的nbytes字節內容寫入文件描述符fd。成功時返回寫的字節數。失敗時返回-1，並設置errno變量。 在網絡程序中，當咱們向套接字文件描述符寫時有兩種可能。1)write的返回值大於0，表示寫了部分或者是所有的數據。2)返回的值小於0，此時出現了錯誤。咱們要根據錯誤類型來處理。若是錯誤爲EINTR表示在寫的時候出現了中斷錯誤。若是爲EPIPE表示網絡鏈接出現了問題(對方已經關閉了鏈接)。

recv函數和send函數提供了read和write函數同樣的功能，不一樣的是他們提供了四個參數。前面的三個參數和read、write函數是同樣的。第四個參數能夠是0或者是如下組合： 
MSG_DONTROUTE：不查找表，是send函數使用的標誌，這個標誌告訴IP，目的主機在本地網絡上，沒有必要查找表，這個標誌通常用在網絡診斷和路由程序裏面。 
MSG_OOB：表示能夠接收和發送帶外數據。 
MSG_PEEK：查看數據，並不從系統緩衝區移走數據。是recv函數使用的標誌，表示只是從系統緩衝區中讀取內容，而不清楚系統緩衝區的內容。這樣在下次讀取的時候，依然是同樣的內容，通常在有個進程讀寫數據的時候使用這個標誌。 
MSG_WAITALL：等待全部數據，是recv函數的使用標誌，表示等到全部的信息到達時才返回，使用這個標誌的時候，recv返回一直阻塞，直到指定的條件知足時，或者是發生了錯誤。

這裏只描述同步Socket的send函數的執行流程。當調用該函數時，

（1）send先比較待發送數據的長度len和套接字s的發送緩衝的長度， 若是len大於s的發送緩衝區的長度，該函數返回SOCKET_ERROR； 
（2）若是len小於或者等於s的發送緩衝區的長度，那麼send先檢查協議s的發送緩衝中的數據是否正在發送，若是是就等待協議把數據發送完，若是協議尚未開始發送s的發送緩衝中的數據或者s的發送緩衝中沒有數據，那麼send就比較s的發送緩衝區的剩餘空間和len 
（3）若是len大於剩餘空間大小，send就一直等待協議把s的發送緩衝中的數據發送完 
（4）若是len小於剩餘 空間大小，send就僅僅把buf中的數據copy到剩餘空間裏（注意並非send把s的發送緩衝中的數據傳到鏈接的另外一端的，而是協議傳的，send僅僅是把buf中的數據copy到s的發送緩衝區的剩餘空間裏）。

若是send函數copy數據成功，就返回實際copy的字節數，若是send在copy數據時出現錯誤，那麼send就返回SOCKET_ERROR；若是send在等待協議傳送數據時網絡斷開的話，那麼send函數也返回SOCKET_ERROR。

注意：send函數把buf中的數據成功copy到s的發送緩衝的剩餘空間裏後它就返回了，可是此時這些數據並不必定立刻被傳到鏈接的另外一端。若是協議在後續的傳送過程當中出現網絡錯誤的話，那麼下一個socket函數就會返回SOCKET_ERROR。（每個除send外的socket函數在執 行的最開始總要先等待套接字的發送緩衝中的數據被協議傳送完畢才能繼續，若是在等待時出現網絡錯誤，那麼該Socket函數就返回 SOCKET_ERROR）

注意：在Unix系統下，若是send在等待協議傳送數據時網絡斷開的話，調用send的進程會接收到一個SIGPIPE信號，進程對該信號的默認處理是進程終止。

經過測試發現，異步socket的send函數在網絡剛剛斷開時還能發送返回相應的字節數，同時使用select檢測也是可寫的，可是過幾秒鐘以後，再send就會出錯了，返回-1。select也不能檢測出可寫了。

這裏只描述同步Socket的recv函數的執行流程。當應用程序調用recv函數時，

（1）recv先等待s的發送緩衝中的數據被協議傳送完畢，若是協議在傳送s的發送緩衝中的數據時出現網絡錯誤，那麼recv函數返回SOCKET_ERROR，

（2）若是s的發送緩衝中沒有數據或者數據被協議成功發送完畢後，recv先檢查套接字s的接收緩衝區，若是s接收緩衝區中沒有數據或者協議正在接收數據，那麼recv就一直等待，直到協議把數據接收完畢。當協議把數據接收完畢，recv函數就把s的接收緩衝中的數據copy到buf中（注意協議接收到的數據可能大於buf的長度，因此 在這種狀況下要調用幾回recv函數才能把s的接收緩衝中的數據copy完。recv函數僅僅是copy數據，真正的接收數據是協議來完成的），recv函數返回其實際copy的字節數。若是recv在copy時出錯，那麼它返回SOCKET_ERROR；若是recv函數在等待協議接收數據時網絡中斷了，那麼它返回0。

注意：在Unix系統下，若是recv函數在等待協議接收數據時網絡斷開了，那麼調用recv的進程會接收到一個SIGPIPE信號，進程對該信號的默認處理是進程終止。

3.6 select（）函數

connect、accept、recv或recvfrom這樣的阻塞程序（所謂阻塞方式block，顧名思義，就是進程或是線程執行到這些函數時必須等待某個事件的發生，若是事件沒有發生，進程或線程就被阻塞，函數不能當即返回）。但是使用Select就能夠完成非阻塞（所謂非阻塞方式non-block，就是進程或線程執行此函數時沒必要非要等待事件的發生，一旦執行確定返回，以返回值的不一樣來反映函數的執行狀況，若是事件發生則與阻塞方式相同，若事件沒有發生則返回一個代碼來告知事件未發生，而進程或線程繼續執行，因此效率較高）方式工做的程序，它可以監視咱們須要監視的文件描述符的變化狀況——讀寫或是異常。

int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval*timeout);

struct fd_set能夠理解爲一個集合，這個集合中存放的是文件描述符(filedescriptor)，即文件句柄，fd_set集合能夠經過一些宏由人爲來操做。

FD_ZERO(fd_set *set);       //Clear all entries from the set.  
FD_SET(int fd, fd_set *set);    //Add fd to the set.  
FD_CLR(int fd, fd_set *set);    //Remove fd from the set.  
FD_ISSET(int fd, fd_set *set);  //Return true if fd is in the set.

struct timeval表明時間值。

struct timeval {  
int tv_sec;     //seconds  
int tv_usec;    //microseconds，注意這裏是微秒不是毫秒  
};

int maxfdp是一個整數值，是指集合中全部文件描述符的範圍，即全部文件描述符的最大值加1。 
fd_set * readfds是指向fd_set結構的指針，這個集合中應該包括文件描述符，咱們是要監視這些文件描述符的讀變化的，即咱們關心是否能夠從這些文件中讀取數據了，若是這個集合中有一個文件可讀，select就會返回一個大於0的值，表示有文件可讀，若是沒有可讀的文件，則根據timeout參數再判斷是否超時，若超出timeout的時間，select返回0，若發生錯誤返回負值。能夠傳入NULL值，表示不關心任何文件的讀變化。

fd_set * writefds是指向fd_set結構的指針，這個集合中應該包括文件描述符，咱們是要監視這些文件描述符的寫變化的，即咱們關心是否能夠向這些文件中寫入數據了，若是這個集合中有一個文件可寫，select就會返回一個大於0的值，表示有文件可寫，若是沒有可寫的文件，則根據timeout參數再判斷是否超時，若超出timeout的時間，select返回0，若發生錯誤返回負值。能夠傳入NULL值，表示不關心任何文件的寫變化。 
fd_set * errorfds同上面兩個參數的意圖，用來監視文件錯誤異常。

struct timeval * timeout是select的超時時間，這個參數相當重要，它可使select處於三種狀態，第一，若將NULL以形參傳入，即不傳入時間結構，就是將select置於阻塞狀態，必定等到監視文件描述符集合中某個文件描述符發生變化爲止；第二，若將時間值設爲0秒0毫秒，就變成一個純粹的非阻塞函數，無論文件描述符是否有變化，都馬上返回繼續執行，文件無變化返回0，有變化返回一個正值；第三，timeout的值大於0，這就是等待的超時時間，即select在timeout時間內阻塞，超時時間以內有事件到來就返回了，不然在超時後無論怎樣必定返回，返回值同上述。

返回值：返回狀態發生變化的描述符總數。 負值：select錯誤 ；正值：某些文件可讀寫或出錯 ；0：等待超時，沒有可讀寫或錯誤的文件 
理解select模型： 
理解select模型的關鍵在於理解fd_set,爲說明方便，取fd_set長度爲1字節，fd_set中的每一bit能夠對應一個文件描述符fd。則1字節長的fd_set最大能夠對應8個fd。 
（1）執行fd_set set;FD_ZERO(&set);則set用位表示是0000,0000。 
（2）若fd＝5,執行FD_SET(fd,&set);後set變爲0001,0000(第5位置爲1) 
（3）若再加入fd＝2，fd=1,則set變爲0001,0011 
（4）執行select(6,&set,0,NULL,NULL)阻塞等待 
（5）若fd=1,fd=2上都發生可讀事件，則select返回，此時set變爲0000,0011。注意：沒有事件發生的fd=5被清空。

基於上面的討論，能夠輕鬆得出select模型的特色：

（1)可監控的文件描述符個數取決與sizeof(fd_set)的值。我這邊服務器上sizeof(fd_set)＝512，每bit表示一個文件描述符，則我服務器上支持的最大文件描述符是512*8=4096。聽說可調，另有說雖然可調，但調整上限受於編譯內核時的變量值。

（2）將fd加入select監控集的同時，還要再使用一個數據結構array保存放到select監控集中的fd，一是用於再select返回後，array做爲源數據和fd_set進行FD_ISSET判斷。二是select返回後會把之前加入的但並沒有事件發生的fd清空，則每次開始 select前都要從新從array取得fd逐一加入（FD_ZERO最早），掃描array的同時取得fd最大值maxfd，用於select的第一個參數。

（3）可見select模型必須在select前循環array（加fd，取maxfd），select返回後循環array（FD_ISSET判斷是否有時間發生）。 
使用select和non-blocking實現server處理多client實例 

3.7 close()/shutdown()函數

int close(int sockfd);

close 一個套接字的默認行爲是把套接字標記爲已關閉，而後當即返回到調用進程，該套接字描述符不能再由調用進程使用，也就是說它不能再做爲read或write的第一個參數，然而TCP將嘗試發送已排隊等待發送到對端，發送完畢後發生的是正常的TCP鏈接終止序列。 
在多進程併發服務器中，父子進程共享着套接字，套接字描述符引用計數記錄着共享着的進程個數，當父進程或某一子進程close掉套接字時，描述符引用計數會相應的減一，當引用計數仍大於零時，這個close調用就不會引起TCP的四路握手斷連過程。

int shutdown(int sockfd,int howto);

該函數的行爲依賴於howto的值 
SHUT_RD：值爲0，關閉鏈接的讀這一半。 
SHUT_WR：值爲1，關閉鏈接的寫這一半。 
SHUT_RDWR：值爲2，鏈接的讀和寫都關閉。 
終止網絡鏈接的通用方法是調用close函數。但使用shutdown能更好的控制斷連過程（使用第二個參數）。 
close與shutdown的區別主要表如今： 
close函數會關閉套接字ID，若是有其餘的進程共享着這個套接字，那麼它仍然是打開的，這個鏈接仍然能夠用來讀和寫，而且有時候這是很是重要的 ，特別是對於多進程併發服務器來講。 
而shutdown會切斷進程共享的套接字的全部鏈接，無論這個套接字的引用計數是否爲零，那些試圖讀得進程將會接收到EOF標識，那些試圖寫的進程將會檢測到SIGPIPE信號，同時可利用shutdown的第二個參數選擇斷連的方式。 

四、 socket中TCP的三次握手創建鏈接詳解

咱們知道tcp創建鏈接要進行「三次握手」，即交換三個分組。大體流程以下： 
•客戶端向服務器發送一個SYN J 
•服務器向客戶端響應一個SYN K，並對SYN J進行確認ACK J+1 
•客戶端再想服務器發一個確認ACK K+1

只有就完了三次握手，可是這個三次握手發生在socket的哪幾個函數中： 
 
從圖中能夠看出，當客戶端調用connect時，觸發了鏈接請求，向服務器發送了SYN J包，這時connect進入阻塞狀態；服務器監聽到鏈接請求，即收到SYN J包，調用accept函數接收請求向客戶端發送SYN K ，ACK J+1，這時accept進入阻塞狀態；客戶端收到服務器的SYN K ，ACK J+1以後，這時connect返回，並對SYN K進行確認；服務器收到ACK K+1時，accept返回，至此三次握手完畢，鏈接創建。

總結：客戶端的connect在三次握手的第二個次返回，而服務器端的accept在三次握手的第三次返回。

五、 socket中TCP的四次握手釋放鏈接詳解

上面介紹了socket中TCP的三次握手創建過程，及其涉及的socket函數。如今咱們介紹socket中的四次握手釋放鏈接的過程，請看下圖： 
 
圖示過程以下：

•某個應用進程首先調用close主動關閉鏈接，這時TCP發送一個FIN M； 
•另外一端接收到FIN M以後，執行被動關閉，對這個FIN進行確認。它的接收也做爲文件結束符傳遞給應用進程，由於FIN的接收意味着應用進程在相應的鏈接上再也接收不到額外數據； 
•一段時間以後，接收到文件結束符的應用進程調用close關閉它的socket。這致使它的TCP也發送一個FIN N； 
•接收到這個FIN的源發送端TCP對它進行確認。 
這樣每一個方向上都有一個FIN和ACK。

六、代碼

CLIENT

#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netdb.h>

#define SERV_TCP_PORT 8000 /* server's port */

int main(int argc, char *argv[])
{
  int sockfd;
  struct sockaddr_in serv_addr;
  char *serv_host = "localhost";
  struct hostent *host_ptr;
  int port;
  int buff_size = 0;

  /* command line: client [host [port]]*/
  if(argc >= 2) 
     serv_host = argv[1]; /* read the host if provided */
  if(argc == 3)
     sscanf(argv[2], "%d", &port); /* read the port if provided */
  else 
     port = SERV_TCP_PORT;

  /* get the address of the host */
  if((host_ptr = gethostbyname(serv_host)) == NULL) {
     perror("gethostbyname error");
     exit(1);
  }

  if(host_ptr->h_addrtype !=  AF_INET) {
     perror("unknown address type");
     exit(1);
  }

  bzero((char *) &serv_addr, sizeof(serv_addr));
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_addr.s_addr = 
     ((struct in_addr *)host_ptr->h_addr_list[0])->s_addr;
  serv_addr.sin_port = htons(port);


  /* open a TCP socket */
  if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
     perror("can't open stream socket");
     exit(1);
  }

  /* connect to the server */    
  if(connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
     perror("can't connect to server");
     exit(1);
  }

  /* write a message to the server */
  write(sockfd, "hello world", sizeof("hello world"));

  close(sockfd);
}

SERVER

#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>

#define SERV_TCP_PORT 8000 /* server's port number */
#define MAX_SIZE 80

int main(int argc, char *argv[])
{
  int sockfd, newsockfd, clilen;
  struct sockaddr_in cli_addr, serv_addr;
  int port;
  char string[MAX_SIZE];
  int len;

  /* command line: server [port_number] */

  if(argc == 2) 
     sscanf(argv[1], "%d", &port); /* read the port number if provided */
  else
     port = SERV_TCP_PORT;

  /* open a TCP socket (an Internet stream socket) */
  if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
     perror("can't open stream socket");
     exit(1);
  }

  /* bind the local address, so that the cliend can send to server */
  bzero((char *) &serv_addr, sizeof(serv_addr));
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  serv_addr.sin_port = htons(port);

  if(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
     perror("can't bind local address");
     exit(1);
  }

  /* listen to the socket */
  listen(sockfd, 5);

  for(;;) {

     /* wait for a connection from a client; this is an iterative server */
     clilen = sizeof(cli_addr);
     newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);

     if(newsockfd < 0) {
        perror("can't bind local address");
     }

     /* read a message from the client */
     len = read(newsockfd, string, MAX_SIZE); 
     /* make sure it's a proper string */
     string[len] = 0;
     printf("%s\n", string);

     close(newsockfd);
  }  
}