一．套接字的一些基礎知識
1．Windows通信相關驅動
netio.sys（Network I/O Subsystem）
ndis.sys（NDIS Driver）
ipnat.sys（IP Network Address Translator）
tcpip.sys（TCP/IP Driver）
tdtcp.sys（TCP Transport Driver）
tdi.sys（TDI wrapper）
afd.sys（Ancillary Function Driver for Winsock）
http.sys（HTTP Protocol Stack）
……
2．socket描述符（套接字句柄）
“在UNIX系統中，任何東西都是一個文件。”這句話描述了這樣一個事實：在UNIX系統中，任何對I/O的操作，都是通過讀或寫一個文件描述符（File DescriptorFile了到對方發送的數據Port+Length+Checksum）來實現的。
一個文件描述符（FD）只是一個簡單的整形數值，代表一個被打開的文件（這裏的文件是廣義的文件，並不只是代表不同的磁盤文件，它可以代表一個網絡上的連接，一個先進先出的隊列，一個終端顯示屏等）。
既然在UNIX系統中任何東西都是一個文件，通過Internet和另外一臺機器進行通訊也是基於文件描述符來實現的。這個文件描述符即套接字內核對象：intsockfd。在早期的UNIX/Linux系統中，可調用read()和write()直接對套接字進行類似文件的讀寫操作，儘管調用recv()和send()顯得更爲專業。
在Windoze系統中，內核對象往往交由一個句柄與外部交互，如文件句柄。在很多WinSock場合我們習慣使用“套接字句柄”這一稱呼：typedefu_intSOCKET。實際上，WinSock中對於套接字的操作，很多也沿襲了文件操作的規範。例如，在Winsock 1中，應用程序可以針對套接字句柄調用ReadFile()和WriteFile()，同時指定重疊結構以利用重疊I/O模型，到Winsock 2中才正式替換爲WSARecv()和WSASend()，以專用於套接字操作。
3．Windows Sockets規範
Sockets本來是UNIX操作系統下流行的一種網絡編程接口(API)，它是1983年在Berkeley(加州大學伯克利分校)4.2 BSD操作系統中被首先引入的，因此被稱爲“Berkeley Socket API”。
Windows Sockets是在Windows環境下使用的一套網絡編程規範，常常簡稱爲WinSock。在Winsock規範中把Winsock API函數集分爲與BSD Socket(用在UNIX中)相兼容的基本函數、網絡數據信息檢索函數和Windows專用擴展函數三類。
Windows Socket 1規範的核心內容是符合Berkeley Socket風格的庫函數，例如可以編寫基於select模型的的socket跨平臺庫。select模型可以很好地實現跨平臺，但對具體操作系統平臺而言，並非性能最佳的I/O模型。爲了使程序員能充分利用Windows消息驅動機制進行編程，又定義開發了一組針對Windows的擴展庫函數，這就是Windows Socket 2規範。Winsock 2.x提供了基於Windows消息機制的WSAAsyncSelcet異步I/O網絡事件通知模型，除此之外WinSock 2.x還提供了基於事件通知的異步I/O網絡事件通知的WSAEventSelect模型和高效的重疊I/O模型。具體平臺實現了各自高效的網絡I/O管理模型,例如Windoze的IOCP模型、Linux的epoll模型，它們用來實現大規模高併發的通信應用程序。
目前常用的Winsock有兩個版本：一個是16位的Winsock 1.1，由動態鏈接庫WINSOCK.DLL提供支持；另一個是32位的Winsock 2.2，由動態鏈接庫WSOCK32.DLL提供支持。
從Win98/NT4開始，Windows支持WinSock 2,而WinSock 1成爲WinSock 2的功能子集。在32位系統下，16位的WINSOCK.DLL(Windows Socket 16-bit DLL)爲Non-resident。
ws2_32.dll和mswsock.dll是WinSock 2真正的實現者。wsock32.dll只是映射了ws2_32.Dll和mswsock.dll兩個文件的一些函數調用，並無具體實現。使用Dependency Walker可以看到wsock32.dll和mswsock.dll都依賴ws2_32.dll。
mswsock.dll提供了微軟特有的WSA擴展，包括AcceptEx/GetAcceptExSockaddrs、ConnectEx/DisconnectEx、TransmitPackets/TransmitFile、WSARecvMsg。其中僅有AcceptEx/GetAcceptExSockaddrs和TransmitFile這三個函數真正從mswsock.dll導出。
如果要求編寫符合Berkeley Socket API標準的程序，則只需要加載wsock32.dll使用WinSock 1.x規範（BSD Socket API for Wndows）就可以了。如果要結合Windows平臺特性編寫WinSock 2.x的程序，則可加載ws2_32.dll和mswsock.dll調用WSA系列（擴展）函數。加載WinSock庫是通過WSAStartup()來指定的。
（1）加載WinSock 1.1
/* WINSOCK.H--definitions to be used with the WINSOCK.DLL
* Copyright (c) Microsoft Corporation. All rights reserved.
*
* This header file corresponds to version 1.1 of the Windows Sockets specification.
*
* (1)Basic system type definitions, taken from the BSD file sys/types.h.
* (2)Structure used in select() call, taken from the BSD file sys/time.h.
* (3)Commands for ioctlsocket(), taken from the BSD file fcntl.h.
* (4)Structures returned by network data base library, taken from the BSD file netdb.h.
* (5)Constants and structures defined by the internet system, Per RFC 790, September 1981, taken from the BSD file netinet/in.h.
* (6)Definitions related to sockets: types, address families, options, taken from the BSD file sys/socket.h.
*
* (7)Microsoft Windows Extension function prototypes：WSA開頭的WSAStartup、WSACleanup等Windows Sockets API。
* (8)Microsoft Windows Extended data types：typedef了SOCKADDR、SOCKADDR_IN等宏。
*/
#include <WinSock.h>
#pragma comment(lib,"WSock32.Lib")
LoadLibrary("C://WINDOWS//system32/wsock32.dll");// Windows Socket 32-Bit DLL
Windows Mobile下對應winsock.h/winsock.lib/winsock.dll。
（2）加載WinSock 2.2
/* Winsock2.h -- definitions to be used with the WinSock 2 DLL and
* WinSock 2 applications.
*
* This header file corresponds to version 2.2.x of the WinSock API
* specification.
*
* #define _WINSOCKAPI_ // Prevent inclusion of winsock.h in windows.h
*/
#include <WinSock2.h>
#pragma comment(lib,"WS2_32.lib")
LoadLibrary("C://WINDOWS//system32//ws2_32.dll");// Windows Socket 2.0 32-Bit DLL
Windows Mobile下對應winsock2.h/ws2.lib/ws2.dll。
（3）加載Microsoft Windows-Specific Extension Functions
/*++
Module Name:
mswsock.h
Abstract:
This module contains the Microsoft-specific extensions to the Windows Sockets API.
--*/
#include <Mswsock.h>
#pragma comment(lib,"MsWSock.Lib")
LoadLibrary("C://WINDOWS//system32//mswsock.dll");// Microsoft Windows Socket 2.0 Service Provider
二．套接字通信基礎
至此，我還不打算直接進入套接字的一些諸如recv()和send()操作。在正式使用套接字進行通信編程之前，有必要先了解一下通信所涉及到地址識別、字節順序等知識點。
1.套接字地址（sockaddr）、TCP/IP套接字地址(sockaddr_in)和IP地址in_addr
1.1 struct sockaddr
struct sockaddr結構用來存儲套接字地址。
/*
* Structure used by kernel to store most addresses.
*/
struct sockaddr {
u_short sa_family;/* address family,AF_X */
char sa_data[14];/* up to 14 bytes of direct address */
};
sa_data包含了一些遠程電腦的地址、端口和套接字的數目，它裏面的數據是雜溶在一起的。sa_data域的定義有些不確定性，註釋暗示內容可能超過14個字節。這種不確定性是經過深思熟慮的。套接字是個非常強大的接口。多數人可能認爲比Internet接口強不到哪裏——大多數應用現在很可能都用它——套接字可被用於幾乎任何種類的進程間通信，Internet（更精確的說是IP）只是其支持的協議簇中的一種。
#define SOCK_MAXADDRLEN 255 /*可能的最長的地址長度 */
socket層涉及到地址的API都是用sockaddr結構，這些API包括bind(服務器綁定本地地址+端口)、connect（連接服務器）/accept（接受客戶端）、recvfrom/sendto。
int bind(int sockfd, struct sockaddr *my_addr,int addrlen);
int accept(int sockfd, struct sockaddr *addr,int* addrlen);
int connect(int sockfd, const struct sockaddr *serv_addr,int addrlen);
1.2 struct sockaddr_in
Sockets API提供了struct sockaddr的TCP/IP版本——struct sockaddr_in，其中in代表“internet”，故sockaddr_in.sa_family=AF_INET。
/*
* Socket address, internet style.
*/
struct sockaddr_in {
short sin_family;/* internet address family */
u_short sin_port;/* port number */
struct in_addr sin_addr;/* internet address */
char sin_zero[8];/* padding bits */
};
這個結構提供了方便的手段來訪問socket address（structsockaddr）結構中的每一個元素。注意sin_zero[8]是爲了使sockaddr和sockaddr_in結構具有相同的尺寸，使用sockaddr_in的時候要把sin_zero全部設爲零（使用memset函數）。
1.3 struct in_addr
in_addr爲IP地址，在IPv4中使用32位無符號整數。
/*
* Internet address (WINSOCK.H)
*/
struct in_addr {
union {
struct {u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
struct {u_short s_w1,s_w2; } S_un_w;
u_long S_addr;
}S_un;
#define s_addr S_un.S_addr/* can be used for most tcp & ip code */
#define s_host S_un.S_un_b.s_b2/* host on imp */
#define s_net S_un.S_un_b.s_b1/* network */
#define s_imp S_un.S_un_w.s_w2/* imp */
#define s_impno S_un.S_un_b.s_b4/* imp # */
#define s_lh S_un.S_un_b.s_b3/* logical host */
};
WinSock對sockaddr、sockaddr_in和in_addr進行了typedef。
/* Microsoft Windows Extended data types */
typedef struct sockaddr SOCKADDR, *PSOCKADDR,FAR *LPSOCKADDR;
typedef struct sockaddr_in SOCKADDR_IN, *PSOCKADDR_IN,FAR *LPSOCKADDR_IN;
typedef struct in_addr IN_ADDR,*PIN_ADDR,FAR *LPIN_ADDR;
2.字節順序
字節順序是多字節數據被存儲的順序。例如，一個32位的長整型0x12345678跨越4個字節（每個字節8位）。Intel x86機器使用小尾順序（little-endian），意思是最不重要的字節首先存儲。因此，數據 0x12345678在內存中以{0x78、0x56、0x34、0x12}順序存放。大多數不使用小尾順序的機器使用大尾順序（big-endian），即最重要的字節首先存儲。同樣的值在內存中以{0x12、0x34、0x56、0x78}順序存放。
因爲協議數據要在這些機器間傳輸，就必須選定其中的一種方式做爲標準，否則會引起混淆。TCP/IP協議統一規定使用大尾方式傳輸數據，也稱爲網絡字節順序（network byte order）。例如，端口號（它是一個 16位的數字）12345（0x3039）的存儲順序是{0x30、0x39}。
上述sockaddr和sockaddr_in結構中，除了 sin_family成員（它不是協議的一部分）外，其他所有值必須以網絡字節順序存儲。Sockets API提供了一些函數，來對內部字節順序與網絡字節順序不同的情況進行字節順序轉換處理。
字節順序轉換函數主要有htonl()/ntohl()和htons()/ntohs()。
u_long htonl (u_long hostlong); /* Host to Network Long */
u_long ntohl (u_long netlong); /* Network to Host Long */
u_short htons (u_short hostshort); /* Host to Network Short */
u_short ntohs (u_short netshort); /* Network to Host Short */
3.IP地址
in_addr把IP地址作爲一個4字節的無符號長整型量存儲起來。IP地址習慣用點分十進制（dotted address）字符串來表示，字符串中由點分開的 4個域是以字符串的形式對in_addr結構中的 4個 u_char值的描述。由於每個字節的數值範圍是 0~255，所以各域的值是不可以超過 255的。
3.1網址歸類
IPv4地址被分爲幾個種類，分別描述地址被分配到網絡的部分和端點的部分，見下表。網絡號和主機號通過子網掩碼區分，例如C類地址的子網掩碼爲“255.255.255.0”，若IP地址爲“192.168.89.125/24”，則網段號爲“192.168.89”，主機號爲“125”。
Winsock中定義了一系列對IP地址進行歸類的宏，包括判斷地址類型的IN_CLASS*，子網掩碼IN_CLASS*_NET，端點數量IN_CLASS*_HOST及其位數IN_CLASSA_NSHIFT。
#define IN_CLASSA(i) (((long)(i) & 0x80000000) == 0)
#define IN_CLASSA_NET 0xff000000
#define IN_CLASSA_NSHIFT 24
#define IN_CLASSA_HOST 0x00ffffff
#define IN_CLASSA_MAX 128
#define IN_CLASSB(i) (((long)(i) & 0xc0000000) == 0x80000000)
#define IN_CLASSB_NET 0xffff0000
#define IN_CLASSB_NSHIFT 16
#define IN_CLASSB_HOST 0x0000ffff
#define IN_CLASSB_MAX 65536
#define IN_CLASSC(i) (((long)(i) & 0xe0000000) == 0xc0000000)
#define IN_CLASSC_NET 0xffffff00
#define IN_CLASSC_NSHIFT 8
#define IN_CLASSC_HOST 0x000000ff
3.2特殊的網絡地址
#define INADDR_ANY (u_long)0x00000000
#define INADDR_BROADCAST (u_long)0xffffffff
#define INADDR_NONE 0xffffffff
其中INADDR_NONE往往用在排錯上，INADDR_ANY往往代表任意有效地址（一個主機可能分配到多個IP地址），INADDR_BROADCAST爲子網廣播地址。
3.3網址轉換函數
inet_addr函數將一個由小數點分隔的十進制 IP地址字符串轉化成由 32位二進制數表示的 IP地址（網絡字節順序）。
unsigned long inet_addr(const char *cp);
以下代碼爲在little endian的Windows下，定義遠程主機220.181.6.18:80。
//定義TCP/IP地址：220.181.6.18:80
sockaddr_in remoteSockAddr;
remoteSockAddr.sin_family = AF_INET;
remoteSockAddr.sin_addr.S_un.S_addr = inet_addr("220.181.6.18");
remoteSockAddr.sin_port = htons(80);
其聯合中的四個S_un_b的四個u_char值依次爲220,181,6,18。
remoteSockAddr.sin_addr.S_un.S_un_b.s_b1 = 220; // 0xdc
remoteSockAddr.sin_addr.S_un.S_un_b.s_b2 = 181; // 0xb5
remoteSockAddr.sin_addr.S_un.S_un_b.s_b3 = 6; // 0x06
remoteSockAddr..sin_addr.S_un.S_un_b.s_b4 = 18; // 0x12
在Windows中，該IP整形值解析爲0x1206b5dc。
inet_ntoa函數是 inet_addr函數的逆函數，它將一個網絡字節順序的32位IP地址轉化成字符串。
char* inet_ntoa(struct in_addrin);
注意inet_ntoa的參數爲in_addr結構，而非無符號長整數！
// 翻譯IP地址：0x1206b5dc
struct in_addr inAddr;
inAddr.s_addr = 0x1206b5dc;
char *szIP =inet_ntoa(inAddr);
printf("ip = %s/n",szIP); // "220.181.6.18"
三．套接字API概覽
以下介紹WinSock 1.x即符合Berkely Socket API標準的基本socket操作接口，不包括具體操作系統的擴展API和I/O通信模型。
1．Winsock庫的加載和卸載
要使用Windows Socket API進行編程，首先必須調用WSAStartup()函數初始化Winsock動態庫。
int WSAStartup(WORD wVersionRequested,LPWSADATA lpWSAData);
參數一wVersionRequested爲我們要求初始化的Winsock版本號，參數二lpWSAData爲實際初始化成功的WSA（Windows Socket API）版本信息。
在程序末尾，需調用intWSACleanup(void)函數卸載Winsock動態庫。
2．套接字的創建和釋放
（1）套接字的創建
要使用套接字，首先必須調用socket()函數創建一個套接字描述符，就如同操作文件時，首先得調用fopen()函數打開一個文件。
// The socket function creates a socket that is bound to a specific service provider.
SOCKET socket(int af,// [in] Address family specification.
int type,// [in] Type specification for the new socket.
int protocol// [in] Protocol to be used with the socket that is specific to the indicated address family.
);
我們往往編寫的是基於IP協議的通信程序，故af一般取AF_INET，type可以取SOCK_RAW、SOCK_STREAM、SOCK_DGRAM。SOCK_RAW表示要創建的是原始套接字，可以進行紅外套接字編程、基於網絡層的編程（例如基於ICMP協議的traceroute和ping程序，直接構建IP數據報的網絡程序）；SOCK_STREAM表示要創建的是面向流的套接字，例如基於TCP協議編程；SOCK_DGRAM則指明創建面向離散消息的數據報套接字，例如基於UDP協議編程。Linux原始套接字甚至提供了鏈路套接字的支持，而WinSock原始套接字則只支持到網絡層，若想在Windoze下直接獲取鏈路層數據包，則需要在NDIS級別進行編程或藉助提供了底層網絡訪問支持的第三方庫winpcap。
通常有af=AF_INET，若type=SOCK_STREAM則protocol參數內定爲IPPROTO_TCP(6);若type=SOCK_DGRAM則protocol參數內定爲IPPROTO_UDP(17)。若type=SOCK_RAW，若protocol=IPPROTO_RAW則這個socket只能用來發送IP包，而不能接收任何的數據，發送的數據需要自己填充IP包頭，並且自己計算校驗和；若protocol=IPPROTO_IP則這個socket用於接收IP數據包，其中的校驗和和協議分析由程序自己完成。
SOCKET RawSocket = socket(AF_INET,SOCK_RAW,IPPROTO_RAW);
SOCKET IpSocket = socket(AF_INET,SOCK_RAW,IPPROTO_IP);
SOCKET UdpSocket = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
SOCKET TcpSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
（2）套接字的釋放
當不使用socket()創建的套接字時，應該調用closesocket()函數將它關閉，就如同調用fclose()函數關閉一個文件。它主要完成套接字資源的釋放。
// The closesocket function closes an existing socket.
int closesocket(
SOCKET s// [in] Descriptor identifying the socket to close.
);
當一個套接字上仍存在掛起的I/O時，如何優雅地關閉一個套接字便至關重要，此話題留待後續探討。
3．綁定套接字到指定的IP地址和端口號
對於傳輸套接字，在執行收發數據前需要對本地端口進行綁定，這是因爲傳輸層需要使用端口來區分具體的通信端點（endpoint）。
// The bind function associates a local address with a socket.
int bind(
SOCKET s,// [in] Descriptor identifying an unbound socket.
const struct sockaddr FAR *name,// [in] Address to assign to the socket from the SOCKADDR structure.
int namelen// [in] Length of the value in the name parameter.
);
bind()函數用在套接字連接建立之前，它的作用是綁定面向連接（connection oriented）的或者面向無連接（transaction oriented）的套接字。當一個套接字被socket函數創建以後，它存在於指定的地址家族裏，但是它是匿名的。bind()函數通過安排一個本地名稱到未命名的socket建立此socket的本地關聯。本地名稱包含3個部分：主機地址、協議號（TCP或UDP）和端口號。
通常服務器綁定本地地址時，不寫死具體的IP（因爲IP是軟件配置的），而是使用INADDR_ANY，綁定到本地任意地址。何謂“任意地址”呢，考慮多網卡多IP的情況，我們希望服務器應用程序在指定端口監聽客戶連接，而不管客戶數據是通過哪個網卡進來的。這是因爲TCP層面，往往使用端口是區分不同的應用程序。
如果想接收到的本機的所有TCP/UDP包（不指定綁定的端口），則最好直接使用原始套接字使用IP層的協議，例如sniffer程序。對於基於傳輸層的普通網絡程序設計，一般都要綁定端口。
When using a connection-oriented protocol, the sockets must be connected before callingrecv. When using a connectionless protocol, the sockets must be bound before callingrecv.—MSDN
TCP/UDP 套接字執行send()/sendto()時若沒有執行本地端口綁定，系統會自動調用綁定，這時可以在該套接字上執行recv()/recvfrom()。在未綁定也未調用send()/sendto()先發探路的情況下，執行recv()/recvfrom()將返回錯誤SOCKET_ERROR（WSAGetLastError()=WSAEINVAL），因爲尚未指定傳輸接收端口。
綁定往往具有獨佔性，某個套接字已經綁定到本機IP地址及端口上時，另一個bind()調用試圖再次綁定另一個套接字到該sockaddr的行爲將以WSAEADDRINUSE錯誤告終。要想實現對某個地址的複用，可在SOL_SOCKET級別調用setsockopt()函數設置SO_REUSEADDR/SO_EXCLUSIVEADDRUSE選項。
4．TCP服務器設置套接字進入監聽狀態
// The listen function places a socket a state where it is listening for an incoming connection.
int listen(
SOCKET s,// [in] Descriptor identifying a bound, unconnected socket.
int backlog// [in] Maximum length of the queue of pending connections.
);
服務器爲了接受連接，首先使用socket()函數創建一個套接字，然後使用bind()函數將它綁定到一個本地地址，再用listen()函數爲到達的連接指定一個backlog。
因爲服務器是伺服系統（servo），它是服務的提供者，故一般必須顯式地聲明在哪個端口（即周知端口）上接受客戶的連接。例如HTTP服務器通常在80端口偵聽客戶的HTTP請求。在一個隨機端口上監聽顯然很荒謬，故服務器在監聽之前往往必須調用bind()函數。即使是在無連接的UDP通信中，準備接收方也需要調用bind()函數。
listen()僅應用在支持連接的套接字上，如SOCK_STREAM類型。函數成功執行之後，套接字s進入了被動模式（passive），到來的連接會被通知，排隊等候接受處理。這裏着重要提醒的是，傳入listen()的套接字是專門用於接受連接的監聽套接字，注意區分會話套接字。
backlog參數指定了正在等待連接的最大隊列長度。這個參數非常重要，因爲完全可能同時出現幾個服務器連接請求。例如，假定backlog參數爲2。如果三個客戶機同時發出請求，那麼頭兩個會被放在一個“待決”（等待處理）隊列中，以便應用程序依次爲它們提供服務。而第三個連接會造成一個WSAECONNREFUSED錯誤。注意，一旦服務器接受了一個連接，那個連接請求就會從隊列中刪去，以便別人可繼續發出請求。
backlog參數其實本身就存在着限制，這個限制是由基層的協議提供者決定的。如果出現非法值，那麼會用與之最接近的一個合法值來取代。一般取SOMAXCONN（5）。
5．客戶端主動連接
// The connect function establishes a connection to a specified socket.
int connect(
SOCKET s,// [in] Descriptor identifying an unconnected socket.
const struct sockaddr FAR *name,// [in] Name of the socket to which the connection should be established.
int namelen// [in] Length of name.
);
客戶端是連接的發起者（initiate），它通過調用connect()函數主動（active）連接服務器。參數二填寫欲連接的目標服務器的地址。如果連接的計算機並沒有在指定端口上監聽，則connect()調用返回SOCKET_ERROR，WSAGetLastError()=WSAECONNREFUSED，另一種錯誤是WSAETIMEOUT，例如由於路由或網絡故障，客戶端遲遲接受不到服務器回饋的[SYN,ACK]信號。
客戶端往往只是想連接到一個遠程主機進行通訊，而並不在乎使用本機上的哪個端口進行通訊（比如Telnet），那麼你可以不調用bind()函數，而直接調用connect()函數。系統將會將自動尋找出本地機器上的一個未使用的端口，然後調用bind()來將socket綁定到那個端口上。
可在客戶端套接字上調用setsockopt()在SOL_SOCKET級別獲取SO_CONNECT_TIME選項值，以秒爲單位。判斷套接字是否已建立連接，以及建立連接的時間。SO_CONNECT_TIME是微軟特有支持選項，往往服務器端在AcceptEx()調用中循環查詢所有未完成的客戶端套接字，從而做出超時處理，避免惡意客戶的服務拒絕攻擊。
在實際應用中，可能需要維持持久連接，以提供/接受持續的數據服務，例如HTTP的“Connection: Keep-Alive”。可以調用setsockopt()在SOL_SOCKET級別設置SO_KEEPALIVE選項，這樣，套接字將定時向通信對方發送保持活躍數據包，保持心跳。
connect()對於UDP套接字的意義隻影響send()調用和接收隊列，對recvfrom()和sendto()沒有影響, 並且可以多次成功connect()。
6．TCP服務器接受客戶連接請求
// The accept function permits an incoming connection attempt on a socket.
SOCKET accept(
SOCKET s,// [in] Descriptor identifying a socket that has been placed in a listening state with the listen function.
struct sockaddr FAR *addr,// [out] receives the address of the connecting entity, as known to the communications layer.
int FAR *addrlen// [out] the length of addr.
);
服務器進入listen狀態後，循環調用accept()接受客戶的連接。參數一爲監聽套接字；參數二爲遠端客戶的地址信息；該函數返回一個套接字句柄，負責後續與該遠端客戶的會話通信。監聽套接字總是默默無聞的在門口守望（listen），迎接（accept）客戶的到來並安排服務員。
connect-accept完成的是TCP三次握手過程(three way or three message handshake)：服務器調用socket的listen函數進入監聽狀態；客戶端調用connect函數連接服務器[SYN]，服務器調用accept函數接受客戶連接[SYN,ACK]。客戶端發送[ACK]完成三次握手，connect函數返回；服務器收到客戶端發送的[ACK]後，accept函數返回。
服務器與客戶端基於IP協議的TCP或UDP通信的過程由一個五元組來唯一標識。這個五元組是（協議，本地IP地址，本地端口號，遠程IP地址，遠程端口號），它體現了socket通信的一一對應關係（插座原理）。
對於面向連接的（TCP協議）通信來說，服務器與客戶之間的連接建立完成後，這個五元組就確立了。
|
五元組 |
<協議> |
<本地IP地址，本地端口號> |
<遠程IP地址，遠程端口號> |
|
服務器 |
由socket()確定 |
調用bind()確定 |
由accept()參數二返回 |
|
客戶端 |
由socket()確定 |
調用bind()確定或自動確定 |
由connect()參數二指定 |
7．在一個已綁定或已連接的套接字上獲取連接名和對方地址信息
7.1獲取sockaddr
int getsockname (SOCKET s, struct sockaddr *name, int* namelen);
getsockname函數獲取已綁定（可能是未調用bind的系統自動綁定）的套接口本地協議地址。
int getpeername (SOCKET s, struct sockaddr *name, int* namelen);
getpeername函數獲得與指定套接口連接的遠程信息（IP:PORT）。
7.2獲取hostname
Host即通常意義上的機器名（Machine Name）或域名（Domain Name）。
int gethostname (char FAR *name, int namelen);
gethostname()函數可以取得調用主機的機器名。返回的這個name傳給gethostbyname()調用可以取得相應IP地址。
struct hostent* gethostbyname(const char* name);
gethostbyname()函數主要用來做DNS解析，傳入域名（例如www.baidu.com），返回hostent結構。struct hostent存放主機信息。
/*
* Structures returned by network data base library, taken from the
* BSD file netdb.h. All addresses are supplied in host order, and
* returned in network order (suitable for use in system calls).
*/
struct hostent {
char FAR *h_name; /* official name of host */
char FAR *FAR *h_aliases; /* alias list */
short h_addrtype; /* host address type */
short h_length; /* length of address */
char FAR *FAR *h_addr_list;/* list of addresses */
#define h_addr h_addr_list[0] /* address, for backward compat */
};
/* Microsoft Windows Extended data types */
typedef struct hostent HOSTENT, *PHOSTENT, *LPHOSTENT;
以下代碼段獲取百度（www.baidu.com）機器名和地址。
struct hostent *pBaiDu =gethostbyname("www.baidu.com");
printf("Host name: %s/n",pBaiDu->h_name);
printf("IP Address: %s/n",inet_ntoa(*((struct in_addr*)pBaiDu->h_addr)));
struct hostent* gethostbyaddr(const char *addr, int len, int type);
gethostbyaddr函數根據主機的IP地址取得主機名和主機地址等信息。
原有的gethostbyname和inet_addr只能處理IPv4地址，在IPv6中，替代他們的函數爲getnameinfo和getaddrinfo，相應的地址信息結構爲structaddrinfo。參考<Ws2tcpip.h>。
8．I/O通信
從I/O的角度來看，套接字也是文件，它提供了同文件讀寫（fread()/fwrite()）對應的收發數據操作接口：send()/recv()。
8.1發送數據
8.1.1 send
// The send function sends data on a connected socket.
int send(
SOCKET s,// [in] Descriptor identifying a connected socket.
const char FAR *buf,// [in] Buffer containing the data to be transmitted.
int len,// [in] Length of the data in buf.
int flags// [in] Indicator specifying the way in which the call is made.
);
send()函數在一個已連接的套接字s上執行數據發送操作。對於客戶機而言，發送的目標地址即connect()調用時所指定的地址；對於服務器而言，發送的目標地址即accept()調用所返回的地址。發送的內容爲保存在緩衝區buf中，發送的內容長度爲len。最後一個參數flags，通常情況下填0。
send()函數只是將欲發送的內容從用戶緩衝區拷貝到系統緩衝區（TCP Send Socket Buffer），系統的默認socket發送緩衝區（SO_SNDBUF）的大小爲8K，我們可以調用setsockopt()將其更改，理論上最大爲64K（The maximum congestion window is related to the amount of buffer space that the kernel allocates for each socket）。
只要系統緩衝區足夠大，send()執行完拷貝立即返回實際拷貝的字節數。如果系統緩衝區不夠大，例如在網絡擁塞或帶寬下降的情況下，用戶大量地投遞send()操作導致TCP Send Socket Buffer迅速充滿，此時再調用send()操作，可能返回的值（即實際拷貝字節數）要小於我們傳入的期待發送數量（len），在超時不得受理的情況下，返回SOCKET_ERROR，WSAGetLastError()=WSAETIMEDOUT。故大塊的數據可能不能一次性“發送”完畢，通常需要檢測send()返回值，多次調用send()直到“發送”完畢，可參考CSocket::Send()實現。關於發送超時限制(send timeout)，可以調用setsockopt()在SOL_SOCKET級別設置SO_SNDTIMEO選項值，以毫秒爲單位。建議最多兩分鐘，因爲TCP的MSL（Maximum Segment Lifetime）即爲兩分鐘。
需要注意的是，用戶可能短時間內需要發送多個小數據包，在TCP/IP中，Nagle算法要求主機等待數據積累到一定數量後或超過預定時間才發送。默認情況下實施Nagle算法，通信方會在向對方發送確認（ACK）信息之前，花費一定的時間來等待要傳入的數據，這樣，主機的就不必發送一個只有確認信息的數據報。發送小的數據包不僅沒有多少意義，而且徒增錯誤檢查和確認的開銷。如果不想是使用Nagle算法，以“保留髮送邊界”，用戶可調用setsockopt()函數在IPPROTO_TCP選項級別設置TCP_NODELAY爲TRUE。例如一次獨立的HTTP GET請求往往希望“保留髮送邊界”，服務器的HTTP Response Header往往希望“保留髮送邊界”以區分後續的HTTP Response Content。體現在TCP層，即開啓“PSH”選項。
具體的發送工作交由系統的傳輸層驅動程序完成。因爲TCP提供可靠有序的傳輸機制，故我們總是很放心地認爲它會將我們的數據發送到目的端。至於TCP分多少次將數據發送至對方，由協商的MSS（Max Segment Size）和接收方的TCP Window決定。
8.1.2 sendto
// The sendto function sends data to a specific destination.
int sendto(
SOCKET s,
const char FAR *buf,
int len,
int flags,
const struct sockaddr FAR *to,// [in] Optional pointer to the address of the target socket.
int tolen// [in] Size of the address in to.
);
sendto()函數只是比send()函數多出了一個目的地址信息參數，主要用於面向無連接的UDP通信。TCP套接字在建立連接(connect-accept)時，便知曉對方地址信息，而UDP套接字通信之前不建立連接，需要通信時，調用sendto()將消息發送給目的地址(to)。無論對方是否在指定端口“監聽”，sendto總是把數據發出去，要知道UDP是沒有迴應確認的。
註釋中，sendto()函數的目標地址是“optional”，當我們忽略最後兩個參數時，完全可以替換send()函數使用。實際上，這很方便我們在編程接口上提供統一。例如live555的writeSocket接口針對TCP和UDP套接字統一使用sendto()。
由於UDP協議基本上只是在IP協議上做了簡單的封裝（Source Port+Destination Port+Length+Checksum），其沒有做可靠性傳輸保障，故對UDP套接字一次sendto()的數據量不宜過大，最好以MTU爲基準。使用UDP套接字往發送大數據塊，往往因爲IP分片等原因丟包，考慮異構網絡及設備的MTU不同，一般一次發送512字節左右比較合適。
我們在一個UDP套接字上執行connect()操作，並未真正建立連接，而是執行一種目的地址“綁定”，事後我們可以使用send()函數替換sendto()函數。要取消UDP套接字與目的地址的關聯，唯一的辦法是在這個套接字上以INADDR_ANY爲目標地址調用connect()。
8.2接收數據
8.2.1 recv
// The recv function receives data from a connected or bound socket.
int recv(
SOCKET s,// [in] Descriptor identifying a connected socket.
char FAR *buf,// [out] Buffer for the incoming data.
int len,// [in] Length of buf.
int flags// [in] Flag specifying the way in which the call is made.
);
recv()函數在一個已連接的套接字s上執行數據接收操作。對於客戶機而言，數據的源地址即connect()調用時所指定的地址；對於服務器而言，數據的源地址即accept()調用所返回的地址。接收的內容爲保存至長度爲len的緩衝區buf，最後一個參數flags，通常情況下填0。
recv()函數只是將TCP層當前接收到的數據流從系統緩衝區（TCP Receive Socket Buffer）拷貝到用戶緩衝區，系統的默認socket接收緩衝區（SO_RCVBUF）的大小爲8K，我們可以調用setsockopt()將其更改，理論上最大爲64K（The maximum congestion window is related to the amount of buffer space that the kernel allocates for each socket）。
recv()函數返回實際接收到的數據，可能小於緩衝區的長度len，可能當前到達的有效數據大於len，但最大返回len。在超時仍無數據到來的情況下，返回SOCKET_ERROR，WSAGetLastError()=WSAETIMEDOUT。關於接收超時限制(receive timeout)，可以調用setsockopt()在SOL_SOCKET級別設置SO_RCVTIMEO選項值，以毫秒爲單位。建議最多兩分鐘，因爲TCP的MSL（Maximum Segment Lifetime）即爲兩分鐘。
如果對方不停發送數據，而本機過於繁忙疲於應付，則可能導致數據大量累積，一旦TCP Receive Socket Buffer或TCP Window充滿，則可能產生數據溢出。TCP滑動窗口機制，由接收方建議性的控制發送量，即每一次確認迴應（ACK）時都告知對方自己當前的接收能力（TCP窗口的大小），發送方據此有效地控制自己的發送行爲，協調雙方的通信步伐。
由於基於流的TCP協議，未保留消息邊界(boundary)的概念，發送者發送的數據很快就會聚集在系統接收緩衝區（TCP堆棧）中。假設這樣一種情景，客戶端連接流媒體服務器（如IP攝像頭）後，發送請求碼流的請求，這以後服務器總是將連續不斷地推送數據過來（如IP攝像頭實時監控碼流）。若客戶端不執行recv()拷貝操作而又尚未關閉連接，則服務器不斷推送數據到客戶端的TCP Stack，直至TCP window size=0。
不管消息邊界是否存在，接收端都會盡量地讀取當前的有效數據。執行拷貝後，數據將立即從系統緩衝區刪除，以釋放部分TCP Window。因爲流的無邊界性，故用戶投遞了三個send()，可能接收端只需一次或兩次recv()即接收完成。若客戶三次send()的是結構化的數據，而接收端收到的是粘連在一起的一大坨數據或兩塊隨機邊界數據，這種情況即通常所說的TCP粘包問題。
具體的接收工作交由系統的傳輸層驅動程序完成。因爲TCP提供可靠有序的傳輸機制，故我們總是很放心地認爲它會將對方發送過來的數據正確的提交給我們。這裏面的“正確”是指應用層面的報文結構及格式，即使TCP層面發生了偶然的丟包重傳（retransmit out of order），但我們得到的仍然是對方提交的完整的報文。應用層協議就需要我們自己解析了。
粘包問題需要我們聯合發送方，採取有效邊界措施在應用層重組出正確的報文。例如，發送方往往在一個數據包的頭4個字節告知對方接下來的數據有多少，這樣接收方就能有效的執行接收，以保留邊界和結構性。假設接收方得知發送方將發送32KB的數據過來，便投遞一個32KB的緩衝區調用recv試圖一次性接收完畢，這將以失敗告終。實際上，發送方的TCP層將按MSS尺寸將TCP報文分解成很多個段（Segment）分多次發送給接收方。當然，它們往往具有相同的確認號（ack），以表示這些段是一個迴應報文。這樣，客戶端才能識別出TCP segment of a reassembled PDU，以正確重組報文。可參考CSocket::Receive()實現。
8.2.2 recvfrom
// The recvfrom function receives a datagram and stores the source address.
int recvfrom(
SOCKET s,
char FAR* buf,
int len,
int flags,
struct sockaddr FAR *from,// [out] Optional pointer to a buffer that will hold the source address upon return.
int FAR *fromlen// [in, out] Optional pointer to the size of the from buffer.
);
recvfrom/recv與sendto/send在行爲學上同功，因爲事先不知發送方爲誰，故只要進來的通信，都將對方的地址保存在參數from中。值得注意的是，儘管UDP中沒有TCP監聽、連接等概念，但是作爲接收方往往需要在本地某個端口上等待，這個端口必須是專用，約定用戶預知的。故通常在調用recvfrom之前，必須顯式調用bind()函數將UDP套接字關聯到本地某個指定端口，進行“監聽”。
UDP通信是基於離散消息（message）的，故要麼收到對方發送的消息包，要麼整包丟失，接收方不得而知。如果整包丟失了，由於接收方不得而知，故沒有反饋信息，也不會重發。這就是UDP通信的不可靠處。
live555中的readSocket接口針對TCP和UDP套接字統一使用recvfrom。
9．關閉TCP連接
在無連接的UDP中不存在關閉連接問題，我們recvfrom/sendto完畢即可調用closesocket()回收套接字內核資源。
對於面向連接的TCP通信，關閉一個連接需要四次揮手，以關閉雙向信道。其中一方A發送FIN報文給另一方B發起關閉，告訴另一方B它再也不會發送數據了，當然它一般會先將發送隊列中尚未發送的數據先發送出去再發送FIN報文。對方B收到FIN通知，迴應ACK關閉AàB方向上的連接。此時，B仍可向A發送數據，A仍可讀取線路上或網絡堆棧上掛起的數據。當另一方B也決定不再發送數據時，它也發出一個FIN報文，關閉BàA方向上的連接。以上即TCP連接的正常關閉。
因爲可能該套接字上仍有未決的I/O，爲了保證通信方能夠接收到應用程序發出的所有數據，一個友好的應用程序應該通知接收端“不再發送數據”，同樣通信對方也應該如此，這就是所謂的“從容關閉”。TCP套接字recv()/send()通信完畢，往往需要調用shutdown()函數從容地關閉TCP連接，而不是立刻調用closesocket()函數釋放套接字資源。
// The shutdown function disables sends or receives on a socket.
int shutdown(
SOCKET s,// [in] Descriptor identifying a socket.
int how// [in] Flag that describes what types of operation will no longer be allowed.
);
需要留意的是第二參數how，一個套接字既可以調用recv接數據也可以調用send發數據，因此它以下三種取值：
SD_RECEIVE—subsequent calls to therecv function on the socket will be disallowed.
SD_SEND—subsequent calls to thesend function are disallowed
SD_BOTH—disables both sends and receives as described above.
如果how=SD_RECEIVE，則該套接口上的後續接收操作將被禁止。對於TCP協議，TCP窗口不改變並接收前來的數據（但不確認）直至窗口滿後，window size爲0，無法接受數據。
通常取how=SD_SEND，表示不允許再調用發送函數，TCP套接字將會在所有數據發送出去並得到對方的確認(ACK)之後生成一個FIN包，斷開與對方的半連接。
在沒有調用shutdown()的情況下，直接調用closesocket()試圖釋放TCP套接字資源，如果沒有對該套接字的其他引用（具體來說是該套接字上是否存在未決I/O），那麼所有與該套接字描述符關聯的資源都會被釋放，其中包括所有傳輸隊列中的數據，包括同步調用和重疊操作。在TCP層面上，closesocket()將向對方發送[RST,ACK]報文，以重置虛擬鏈路。
SOL_SOCKET級別的SO_LINGER/SO_DONTLINGER參數用來控制當未發送的數據在套接字上排隊等待時，一旦執行closesocket()命令該採取什麼樣的動作。structlinger對應的是一段拖延時間，若超出規定的時間便不再拖延，所有未發送或未接收的數據都會被丟棄，同時重設與對方的連接。可調用setsockopt()函數在丟棄任何正在排隊的數據之前啓用拖延功能。
四．Winsock TCP C/S通信示例
套接字的本質是通信過程中所要使用的一些緩衝區及一些相關的數據結構。
通過WSA（WinSock API）構建C/S通信程序的步驟如下：
1．服務器創建監聽套接字，併爲它關聯一個本地地址（IP和端口Port），然後進入監聽狀態準備接受客戶的連接請求。爲了接受客戶的連接請求，服務器必須調用accept函數。服務器端每接收到一個客戶端連接就新建一個套接字負責與該客戶會話。
2．客戶端創建套接字後即可調用connect函數去試圖連接服務器監聽套接字。當服務器端的accept函數返回後，connect函數也返回。此時客戶方使用socket函數創建的套接字clientSocket，服務器方使用accept返回的套接字serverSocket，雙方就可以通信了。
以下爲WinSock通信示例程序：
（1）服務器端程序serverDemo.cpp
- #include <stdio.h>
- #include <WINSOCK.H>
- #pragma comment(lib, "WSOCK32.LIB") // wsock32.dll
- // #include <WINSOCK2.H>
- // #pragma comment(lib, "WS2_32.LIB") // ws2_32.dll
- #define ReportWSAError(s) printf("Error #%d in %s./n", WSAGetLastError(), #s)
- int main(int argc, char* argv[])
- {
- // Initiates use of the wsock32.dll
- WSADATA wsaData;
- WORD sockVersion = MAKEWORD(1,0);
- if (WSAStartup(sockVersion, &wsaData)) // Initiates failure
- {
- ReportWSAError(WSAStartup());
- return 1;
- }
- // Create a socket to listen for all incoming client connection
- SOCKET listenSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
- if(listenSocket == INVALID_SOCKET)
- {
- ReportWSAError(socket());
- WSACleanup(); // Terminates use of the wsock32.dll
- return 1;
- }
- // Fill the local sockaddr_in structure, which the listenSocket will bind to.
- sockaddr_in sin;
- sin.sin_family = AF_INET;
- sin.sin_port = htons(8888);
- sin.sin_addr.S_un.S_addr = INADDR_ANY; // any local address.
- // Associates the listenSocket with a well-known address
- if(bind(listenSocket, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)
- {
- ReportWSAError(bind());
- WSACleanup(); // Terminates use of the wsock32.dll
- return 1;
- }
- // Put the socket into listening mode to wait for incoming connections
- if(listen(listenSocket, 2) == SOCKET_ERROR)
- {
- ReportWSAError(listen());
- WSACleanup(); // Terminates use of the wsock32.dll
- return 1;
- }
- // Create a sockaddr_in structure to contain the client's address information
- sockaddr_in remoteAddr;
- int nAddrLen = sizeof(remoteAddr);
- // The server will create a socket for the session to every client
- SOCKET serverSocket;
- char echo[] = "Message from the server! /r/n";
- while(TRUE) // Listening circulation
- {
- serverSocket = accept(listenSocket, (SOCKADDR*)&remoteAddr, &nAddrLen);
- if(serverSocket == SOCKET_ERROR)
- {
- ReportWSAError(accept());
- continue;
- }
- printf("Accept a connection: %s /r/n", inet_ntoa(remoteAddr.sin_addr));
- send(serverSocket, echo, strlen(echo), 0);
- closesocket(serverSocket);
- }
- // close listenSocket
- if (closesocket(listenSocket) == SOCKET_ERROR)
- {
- ReportWSAError(closesocket());
- WSACleanup();
- return 1;
- }
- // terminates use of the wsock32.dll
- if (WSACleanup() == SOCKET_ERROR)
- {
- ReportWSAError(WSACleanup());
- return 1;
- }
- return 0; // normal exit
- }
（2）客戶端程序clientDemo.cpp
- #include <stdio.h>
- #include <WINSOCK.H>
- #pragma comment(lib, "WSOCK32.LIB") // wsock32.dll
- // #include <WINSOCK2.H>
- // #pragma comment(lib, "WS2_32.LIB") // ws2_32.dll
- #define ReportWSAError(s) printf("Error #%d in %s./n", WSAGetLastError(), #s)
- // class WSAInitializer is a part of the Socket class (on win32)
- // as a static instance - so whenever an application uses a Socket,
- // winsock is initialized
- class WSAInitializer // Winsock Initializer
- {
- public:
- WSAInitializer()
- {
- if (WSAStartup(0x101, &m_wsadata))
- {
- exit(-1);
- }
- }
- ~WSAInitializer()
- {
- WSACleanup();
- }
- private:
- WSADATA m_wsadata;
- }WsaInit;
- int main(int argc, char* argv[])
- {
- // Create a socket stands for the client process
- SOCKET clientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
- if(clientSocket == INVALID_SOCKET) // Socket creation failure
- {
- ReportWSAError(socket());
- return 1;
- }
- // Fill the sockaddr_in structure,
- // which describes the other side(server) of the connection to establish.
- // This demo connect to localhost.
- // Call function bind to associate a specified local address with the socket
- // before connect operation in the case of Multi-NIC.
- sockaddr_in servAddr;
- servAddr.sin_family = AF_INET;
- servAddr.sin_port = htons(8888);
- servAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
- // Establishes a connection to the clientSocket.
- if(connect(clientSocket, (sockaddr*)&servAddr, sizeof(servAddr)) == SOCKET_ERROR)
- {
- ReportWSAError(connect());
- return 1;
- }
- // Receive some echo data from the server, maybe block here to wait some data
- char buf[256];
- int nRecv = recv(clientSocket, buf, 256, 0);
- if(nRecv > 0)
- {
- buf[nRecv] = '/0'; // fill a null-terminated flag of the C string
- printf("Received data: %s/n", buf);
- }
- // closes client socket
- if (closesocket(clientSocket) == SOCKET_ERROR)
- {
- ReportWSAError(closesocket());
- return 1;
- }
- return 0; // normal exit
- }