socket編程原理

socket編程原理

一、問題的引入  

1) 普通的I/O操做過程:

UNIX系統的I/O命令集，是從Maltics和早期系統中的命令演變出來的，其模式爲打開一讀/寫一關閉（open-write-read-close）。在一個用戶進程進行I/O操做時，它首先調用「打開」得到對指定文件或設備的使用權，並返回稱爲文件描寫敘述符的整型數，以描寫敘述用戶在打開的文件或設備上進行I/O操做的進程。而後這個用戶進程屢次調用「讀/寫」以數據傳輸。當所有的傳輸操做完畢後，用戶進程關閉調用，通知操做系統已經完畢了對某對象的使用。 

2) TCP/IP協議被集成到UNIX內核中

TCP/IP協議被集成到UNIX內核中時，至關於在UNIX系統引入了一種新型的I/O操做。UNIX用戶進程與網絡協議的交互做用比用戶進程與傳統的I/O設備相互做用複雜得多。首先，進行網絡操做的兩個進程在不一樣機器上，怎樣創建它們之間的聯繫？其次，網絡協議存在多種，怎樣創建一種通用機制以支持多種協議？這些都是網絡應用編程界面所要解決的問題。 

3) 需要一種通用的網絡編程接口:  獨立於詳細協議和通用的網絡編程

在UNIX系統中，網絡應用編程界面有兩類：UNIX BSD的套接字（socket）和UNIX System V的TLI。由於Sun公司採用了支持TCP/IP的UNIX BSD操做系統，使TCP/IP的應用有更大的發展，其網絡應用編程界面──套接字（socket）在網絡軟件中被普遍應用，至今已引進微機操做系統DOS和Windows系統中，成爲開發網絡應用軟件的強有力工具，本章將要具體討論這個問題。 

2 、套接字編程基本概念  

         開始使用套接字編程以前，首先必須創建下面概念。 

2.1 網間進程通訊  

進程通訊的概念最初來源於單機系統。由於每個進程都在本身的地址範圍內執行，爲保證兩個相互通訊的進程之間既互不干擾又協調一致工做，操做系統爲進程通訊提供了對應設施，

如UNIX BSD有：管道（pipe）、命名管道（named pipe）軟中斷信號（signal）

UNIX system V有：消息（message）、共享存儲區（shared memory）和信號量（semaphore)等.

他們都僅限於用在本機進程之間通訊。網間進程通訊要解決的是不一樣主機進程間的相互通訊問題（可把同機進程通訊看做是當中的特例）。爲此，首先要解決的是網間進程標識問題。同一主機上，不一樣進程可用進程號（process ID）惟一標識。但在網絡環境下，各主機獨立分配的進程號不能惟一標識該進程。好比，主機A賦於某進程號5，在B機中也可以存在5號進程，所以，「5號進程」這句話就沒有意義了。 其次，操做系統支持的網絡協議衆多，不一樣協議的工做方式不一樣，地址格式也不一樣。所以，網間進程通訊還要解決多重協議的識別問題。 爲了解決上述問題，TCP/IP協議引入了下列幾個概念。 

1）port 

網絡中可以被命名和尋址的通訊port，是操做系統可分配的一種資源。 

依照OSI七層協議的描寫敘述，傳輸層與網絡層在功能上的最大差異是傳輸層提供進程通訊能力。從這個意義上講，網絡通訊的終於地址就不不過主機地址了，還包含可以描寫敘述進程的某種標識符。爲此，TCP/IP協議提出了協議port（protocol port，簡稱端口）的概念，用於標識通訊的進程。 

port是一種抽象的軟件結構（包含一些數據結構和I/O緩衝區）。應用程序（即進程）經過系統調用與某端口創建鏈接（binding）後，傳輸層傳給該port的數據都被對應進程所接收，對應進程發給傳輸層的數據都經過該port輸出。在TCP/IP協議的實現中，對port的操做相似於通常的I/O操做，進程獲取一個port，至關於獲取本地惟一的I/O文件，可以用通常的讀寫原語訪問之。 相似於文件描寫敘述符，每個port都擁有一個叫port號（port number）的整數型標識符，用於差異不一樣port。

由於TCP/IP傳輸層的兩個協議TCP和UDP是全然獨立的兩個軟件模塊，所以各自的port號也相互獨立，如TCP有一個255號port，UDP也可以有一個255號port，兩者並不衝突。 

port號的分配是一個重要問題。有兩種基本分配方式：第一種叫全局分配，這是一種集中控制方式，由一個公認的中央機構依據用戶需要進行統一分配，並將結果發佈於衆。另一種是本地分配，又稱動態鏈接，即進程需要訪問傳輸層服務時，向本地操做系統提出申請，操做系統返回一個本地惟一的port號，進程再經過合適的系統調用將本身與該port號聯繫起來（綁紮）。TCP/IPport號的分配中綜合了上述兩種方式。TCP/IP將port號分爲兩部分，少許的做爲保留port，以全局方式分配給服務進程。所以，每一個標準server都擁有一個全局公認的port（即周知口，well-known port），即便在不一樣的機器上，其port號也一樣。剩餘的爲自由port，以本地方式進行分配。TCP和UDP均規定，小於256的port號才幹做保留port。 

2）地址 

網絡通訊中通訊的兩個進程分別在不一樣的機器上。在互連網絡中，兩臺機器可能位於不一樣的網絡，這些網絡經過網絡互連設備（網關，網橋，路由器等）鏈接。所以需要三級尋址： 

1. 某一主機可與多個網絡相連，必須指定一特定網絡地址； 

2. 網絡上每一臺主機應有其惟一的地址； 

3. 每一主機上的每一進程應有在該主機上的惟一標識符。 

一般主機地址由網絡ID和主機ID組成，在TCP/IP協議中用32位整數值表示；TCP和UDP均使用16位port號標識用戶進程。 

3）網絡字節順序 

不一樣的計算機存放多字節值的順序不一樣，有的機器在起始地址存放低位字節（小端序），有的存高位字節（大端序）。爲保證數據的正確性，在網絡協議中須指定網絡字節順序。TCP/IP協議使用16位整數和32位整數的高價先存格式，它們均含在協議頭文件裏。 具體解釋http://blog.csdn.net/hguisu/article/details/7449955#t1

4）鏈接 

兩個進程間的通訊鏈路稱爲鏈接。鏈接在內部表現爲一些緩衝區和一組協議機制，在外部表現出比無鏈接高的可靠性。 

5）半相關 

綜上所述，網絡中用一個三元組可以在全局惟一標誌一個進程： 

（協議，本地地址，本地port號） 這樣一個三元組，叫作一個半相關（half-association），它指定鏈接的每半部分。 

6）全相關 

一個完整的網間進程通訊需要由兩個進程組成，並且僅僅能使用同一種高層協議。也就是說，不可能通訊的一端用TCP協議，而還有一端用UDP協議。所以一個完整的網間通訊需要一個五元組來標識： 

（協議，本地地址，本地port號，遠地地址，遠地port號） 這樣一個五元組，叫作一個相關（association），即兩個協議一樣的半相關才幹組合成一個合適的相關，或全然指定組成一鏈接。 

2.2 服務方式  

在網絡分層結構中，各層之間是嚴格單向依賴的，各層次的分工和協做集中體現在不一樣層之間的界面上。「服務」是描寫敘述不一樣層之間關係的抽象概念，即網絡中各層向緊鄰上層提供的一組操做。下層是服務提供者，上層是請求服務的用戶。服務的表現形式是原語（primitive），如系統調用或庫函數。系統調用是操做系統內核向網絡應用程序或高層協議提供的服務原語。網絡中的n層總要向n+1層提供比n-1層更完備的服務，不然n層就沒有存在的價值。 在OSI的術語中，網絡層及其下面各層又稱爲通訊子網，僅僅提供點到點通訊，沒有程序或進程的概念。而傳輸層實現的是「端到端」通訊，引進網間進程通訊概念，同一時候也要解決差錯控制，流量控制，數據排序（報文排序），鏈接管理等問題，爲此提供不一樣的服務方式： 

1）面向鏈接（虛電路）或無鏈接 

面向鏈接服務（TCP協議） ：是電話系統服務模式的抽象，即每一次完整的傳輸數據都要通過創建鏈接，使用鏈接，終止連 接的過程。在傳輸數據過程當中，各數據分組不攜帶目的地址，而使用鏈接號（connect ID）。本質上，鏈接 是一個管道，收發數據不但順序一致，而且內容一樣。TCP協議提供面向鏈接的虛電路。

無鏈接服務（UDP協議）：是郵政系統服務的抽象，每個分組都攜帶完整的目的地址，各分組在系統中獨立傳送。無鏈接服務不能保證分組的前後順序，不進行分組出錯的恢復與重傳，不保證傳輸的可靠性。UDP協議提供無鏈接的數據報服務。 

如下給出這兩種服務的類型及應用中的樣例： 

2）順序 

在網絡傳輸中，兩個連續報文在端－端通訊中可能通過不一樣路徑，這樣到達目的地時的順序可能會與發送時不一樣。「順序」是指接收數據順序與發送數據順序一樣。TCP協議提供這項服務。 

3）差錯控制 

保證應用程序接收的數據無差錯的一種機制。檢查差錯的方法一般是採用檢驗「檢查和（Checksum）」的方法。而保證傳送無差錯的方法是兩方採用確認應答技術。TCP協議提供這項服務。 

4）流控制 

在傳輸數據過程當中控制傳輸數據速率的一種機制，以保證數據不被丟失。TCP協議提供這項服務。 

5）字節流 

字節流方式指的是僅把傳輸中的報文看做是一個字節序列，不提供數據流的不論什麼邊界。TCP協議提供字節流

服務。 

6）報文 

接收方要保存發送方的報文邊界。UDP協議提供報文服務。 

7）全雙工/半雙工 

端－端間數據同一時候以兩個方向/一個方向傳送。 

8）緩存/帶外數據 

在字節流服務中，由於沒有報文邊界，用戶進程在某一時刻可以讀或寫隨意數量的字節。爲保證傳輸正確或採用有流控制的協議時，都要進行緩存。但對某些特殊的需求，如交互式應用程序，又會要求取消這樣的緩存。 在數據傳送過程當中，但願不經過常規傳輸方式傳送給用戶以便及時處理的某一類信息，如UNIX系統的中斷鍵（Delete或Control-c）、終端流控制符（Control-s和Control-q），稱爲帶外數據。邏輯上看，好象用戶進程使用了一個獨立的通道傳輸這些數據。該通道與每對鏈接的流相聯繫。由於Berkeley Software Distribution中對帶外數據的實現與RFC 1122中規定的Host Agreement不一致,爲了將互操做中的問題減到最小，應用程序編寫者除非與現有服務互操做時要求帶外數據外，最好不使用它。 

2.3 客戶/server模式  

在TCP/IP網絡應用中，通訊的兩個進程間相互做用的主要模式是客戶/server模式（Client/Server model），即客戶向server發出服務請求，server接收到請求後，提供對應的服務。客戶/server模式的創建基於以下兩點：首先，創建網絡的原由是網絡中軟硬件資源、運算能力和信息不均等，需要共享，從而造就擁有衆多資源的主機提供服務，資源較少的客戶請求服務這一非對等做用。其次，網間進程通訊全然是異步的，相互通訊的進程間既不存在父子關係，又不共享內存緩衝區，所以需要一種機制爲但願通訊的進程間創建聯繫，爲兩者的數據交換提供同步，這就是基於不一樣的客戶/server模式的TCP/IP。 客戶/server模式在工做過程當中採取的是主動請求方式： 

server方：

首先server方要先啓動，並依據請求提供對應服務： 

1. 打開一通訊通道並告知本地主機，它願意在某一公認地址上（周知口，如FTP爲21）接收客戶請求； 

2. 等待客戶請求到達該port； 

3. 接收到反覆服務請求，處理該請求併發送應答信號。接收到併發服務請求，要激活一新進程來處理這個客戶請求（如UNIX系統中用fork、exec）。新進程處理此客戶請求，並不需要對其餘請求做出應答。服務完成後，關閉此新進程與客戶的通訊鏈路，並終止。 

4. 返回第二步，等待還有一客戶請求。 

5. 關閉server 

客戶方： 

1. 打開一通訊通道，並鏈接到server所在主機的特定port； 

2. 向server發服務請求報文，等待並接收應答；繼續提出請求...... 

3. 請求結束後關閉通訊通道並終止。 

從上面所描寫敘述過程可知： 

1. 客戶與server進程的做用是非對稱的，所以編碼不一樣。 

2. 服務進程一般是先於客戶請求而啓動的。僅僅要系統執行，該服務進程一直存在，直到正常或強迫終止。 

2.4 套接字類型  

TCP/IP的socket提供下列三種類型套接字。 

流式套接字（SOCK_STREAM）：

提供了一個面向鏈接、可靠的傳輸數據服務，數據無差錯、無反覆地發送，且按發送順序接收。內設流量控

制，避免數據流超限；數據被看做是字節流，無長度限制。文件傳送協議（FTP）即便用流式套接字。 

數據報式套接字（SOCK_DGRAM）：

提供了一個無鏈接服務。數據包以獨立包形式被髮送，不提供無錯保證，

數據可能丟失或反覆，並且接收順序混亂。網絡文件系統（NFS）使用數據報式套接字。 

原始式套接字（SOCK_RAW） ：

該接口贊成對較低層協議，如IP、ICMP直接訪問。常用於檢驗新的協議實現或訪問現有服務中配置的新設備。 

2.4 典型套接字調用過程舉例  

如前所述，TCP/IP協議的應用通常採用客戶/server模式，所以在實際應用中，必須有客戶和server兩個進 程，並且首先啓動server，其系統調用時序圖例如如下。  面向鏈接的協議（如TCP）的套接字系統調用如圖2.1所看到的：

 

server必須首先啓動，直到它運行完accept()調用，進入等待狀態後，方能接收客戶請求。假如客戶在此前啓動，則connect()將返回出錯代碼，鏈接不成功。 無鏈接協議的套接字調用如圖2.2所看到的：  

無鏈接server也必須先啓動，不然客戶請求傳不到服務進程。無鏈接客戶不調用connect()。所以在數據發送以前，客戶與server之間還沒有創建全然相關，但各自經過socket()和bind()創建了半相關。發送數據時，發送方除指定本地套接字號外，還需指定接收方套接字號，從而在數據收發過程當中動態地創建了全相關。 

實例 

本實例使用面向鏈接協議的客戶/server模式，其流程如圖2.3所看到的： 

server方程序： 

/* File Name: streams.c */ 
#include <winsock.h> 
#include <stdio.h> 
#define TRUE 1 
/* 這個程序創建一個套接字，而後開始無限循環；每當它經過循環接收到一個鏈接，則打印出一個信息。
當鏈接斷開，或接收到終止信息，則此鏈接結束，程序再接收一個新的鏈接。命令行的格式是：streams */
 

main( ) 
{ 
int sock, length; 
struct sockaddr_in server; 
struct sockaddr tcpaddr; 
int msgsock; 
char buf[1024]; 
int rval, len; 

/* 創建套接字 */ 
sock = socket(AF_INET, SOCK_STREAM, 0); 
if (sock < 0) { 
perror(「opening stream socket」); 
exit(1); 
} 

/* 使用隨意port命名套接字 */ 
server.sin_family = AF_INET; 
server.sin_port = INADDR_ANY; 
if (bind(sock, (struct sockaddr *)&server, sizeof(server)) < 0) { 
perror(「binding stream socket」); 
exit(1); 
} 

/* 找出指定的port號並打印出來 */ 
length = sizeof(server); 
if (getsockname(sock, (struct sockaddr *)&server, &length) < 0) { 
perror(「getting socket name」); 
exit(1); 
} 
printf(「socket port #%d/n」, ntohs(server.sin_port)); 

/* 開始接收鏈接 */ 
listen(sock, 5); 
len = sizeof(struct sockaddr); 
do { 
msgsock = accept(sock, (struct sockaddr *)&tcpaddr, (int *)&len); 
if (msgsock == -1) 
perror(「accept」); 
else do{ 
memset(buf, 0, sizeof(buf)); 
if ((rval = recv(msgsock, buf, 1024)) < 0) 
perror(「reading stream message」); 
if (rval == 0) 
printf(「ending connection /n」); 
else 
printf(「-->;%s/n」, buf); 
}while (rval != 0); 
closesocket(msgsock); 
} while (TRUE); 

/* 因爲這個程序已經有了一個無限循環，因此套接字「sock」歷來不顯式關閉。然而，當進程被殺死或正
常終止時，所有套接字都將本身主動地被關閉。*/ 
exit(0); 
} 

客戶方程序： 

/* File Name: streamc.c */ 
#include <winsock.h> 
#include <stdio.h> 
#define DATA 「half a league, half a league ...」 
/* 這個程序創建套接字，而後與命令行給出的套接字鏈接；鏈接結束時，在鏈接上發送 
一個消息，而後關閉套接字。命令行的格式是：streamc 主機名 port號 
port號要與server程序的port號一樣 */ 
main(argc, argv) 
int argc; 
char *argv[ ]; 
{ 
int sock; 
struct sockaddr_in server; 
struct hostent *hp, *gethostbyname( ); 
char buf[1024]; 

/* 創建套接字 */ 
sock = socket(AF_INET, SOCK_STREAM, 0); 
if (sock < 0) { 
perror(「opening stream socket」); 
exit(1); 
} 

/* 使用命令行中指定的名字鏈接套接字 */ 
server.sin_family = AF_INET; 
hp = gethostbyname(argv[1]); 
if (hp == 0) { 
fprintf(stderr, 「%s: unknown host /n」, argv[1]); 
exit(2); 
} 
memcpy((char*)&server.sin_addr, (char*)hp->;h_addr, hp->;h_length); 
sever.sin_port = htons(atoi(argv[2])); 

if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0) { 
perror(「connecting stream socket」); 
exit(3); 
} 

if (send(sock, DATA, sizeof(DATA)) < 0) 
perror(「sending on stream socket」); 
closesocket(sock); 
exit(0); 
} 

2.5 一個通用的實例程序  

在上一節中，咱們介紹了一個簡單的socket程序實例。從這個樣例咱們可以看出，使用socket編程差點兒有一 個模式，即所有的程序差點兒毫無例外地按一樣的順序調用一樣的函數。所以咱們可以設想，設計一箇中間層 ，它向上提供幾個簡單的函數，程序僅僅要調用這幾個函數就可以實現普通的網絡傳輸數據，程序設計者沒必要 太多地關心socket程序設計的細節。  本節咱們將介紹一個通用的網絡程序接口，它向上層提供幾個簡單的函數，程序設計者僅僅要使用這幾個函數 就可以完畢絕大多數網絡傳輸數據。這些函數將socket編程和上層隔離開來，它使用面向鏈接的流式套接字 ，採用非堵塞的工做機制，程序僅僅要調用這些函數查詢網絡消息並做出對應的響應就能夠。這些函數包含： 

l InitSocketsStruct：初始化socket結構，獲取服務port號。客戶程序使用。 

l InitPassiveSock：初始化socket結構，獲取服務port號，創建主套接字。server程序使用。 

l CloseMainSock：關閉主套接字。server程序使用。 

l CreateConnection：創建鏈接。客戶程序使用。 

l AcceptConnection：接收鏈接。server程序使用。 

l CloseConnection：關閉鏈接。 

l QuerySocketsMsg：查詢套接字消息。 

l SendPacket：發送數據。 

l RecvPacket：接收數據。 

2.5.1 頭文件  

/* File Name: tcpsock.h */ 

/* 頭文件包含socket程序經常用到的系統頭文件（本例中給出的是SCO Unix下的頭文件，其餘版本號的Unix的頭文件可能略有不一樣），並定義了咱們本身的兩個數據結構及事實上例變量，以及咱們提供的函數說明。*/

/* File Name: tcpsock.h */ 
/*  頭文件包含 socket 程序經常用到的系統頭文件（本例中給出的是 SCO Unix下的頭文件，其餘版本號的 Unix的頭文件
可能略有不一樣），並定義了咱們本身的兩個數據結構及事實上例變量，以及咱們提供的函數說明。*/ 
#include <stdio.h> 
#include <string.h> 
#include <time.h> 
#include <sys/tape.h> 
#include <sys/signal.h> 
#include <sys/errno.h> 
#include <sys/types.h> 
#include <sys/ioctl.h> 
#include <sys/select.h> 
#include <sys/socket.h> 
#include <sys/stat.h> 
#include <sys/netinet/in.h> 
#include <sys/netinet/tcp.h> 
#include <arpa/inet.h> 
#include <netdb.h> 
  
typedef struct SocketsMsg{ /*  套接字消息結構 */ 
    int AcceptNum;  /*  指示是否有外來鏈接等待接收 */ 
    int ReadNum;   /*  有外來數據等待讀取的鏈接數 */ 
    int ReadQueue[32];   /*  有外來數據等待讀取的鏈接隊列 */ 
    int WriteNum;   /*  可以發送數據的鏈接數 */ 
    int WriteQueue[32];   /*  可以發送數據的鏈接隊列 */ 
    int ExceptNum;  /*  有例外的鏈接數 */ 
    int ExceptQueue[32];   /*  有例外的鏈接隊列 */ 
} SocketsMsg; 
 typedef struct Sockets {  /*  套接字結構 */ 
    int DaemonSock;  /*  主套接字 */ 
    int SockNum;   /*  數據套接字數目 */
    int Sockets[64];  /*  數據套接字數組 */ 
    fd_set readfds, writefds, exceptfds; /*  要被檢測的可
    int Port;    /*  port號 */ 
} Sockets; 
  
Sockets Mysock;   /*  全局變量 */ 
SocketsMsg SockMsg; 
  
int InitSocketsStruct(char * servicename) ; 
int InitPassiveSock(char * servicename) ; 
void CloseMainSock(); 
int CreateConnection(struct in_addr *sin_addr); 
int AcceptConnection(struct in_addr *IPaddr); 
int CloseConnection(int Sockno); 
int QuerySocketsMsg(); 
int SendPacket(int Sockno, void *buf, int len); 
int RecvPacket(int Sockno, void *buf, int size); 

2.5.2 函數源文件  

/* File Name: tcpsock.c */ 
/*  本文件給出九個函數的源碼，當中部分地方給出中文凝視 */ 
#include "tcpsock.h" 
  
int InitSocketsStruct(char * servicename)  
/* Initialize Sockets structure. If succeed then return 1, else return error code (<0) */ 
/*  此函數用於僅僅需要主動套接字的客戶程序，它用來獲取服務信息。服務的定義 
    在/etc/services 文件裏 */ 
{ 
  struct servent *servrec; 
     struct sockaddr_in serv_addr; 
  
  if ((servrec = getservbyname(servicename, "tcp")) == NULL) { 
         return(-1); 
     }         
     bzero((char *)&Mysock, sizeof(Sockets));
	 Mysock.Port = servrec->s_port;  /* Service Port in Network Byte Order */ 
     return(1);     
} 
  
int InitPassiveSock(char * servicename)  
/* Initialize Passive Socket. If succeed then return 1, else return error code (<0) */ 
/*  此函數用於需要被動套接字的server程序，它除了獲取服務信息外，還創建 
    一個被動套接字。*/ 
{ 
    int mainsock, flag=1; 
    struct servent *servrec; 
    struct sockaddr_in serv_addr; 
  
    if ((servrec = getservbyname(servicename, "tcp")) == NULL) { 
        return(-1); 
    }         
    bzero((char *)&Mysock, sizeof(Sockets)); 
    Mysock.Port = servrec->s_port;  /* Service Port in Network Byte Order */ 
  
    if((mainsock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 
        return(-2); 
    }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 = servrec->s_port; 
   if (bind(mainsock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) { 
        close(mainsock); 
      return(-3); 
    } 
  
    if (listen(mainsock, 5) == -1) { /*  將主動套接字變爲被動套接字，準備好接收鏈接 */ 
      close(mainsock); 
       return(-4); 
    } 
  
    /* Set this socket as a Non-blocking socket. */ 
    if (ioctl(mainsock, FIONBIO, &flag) == -1) { 
      close(mainsock); 
      return(-5); 
    } 
     
    Mysock.DaemonSock = mainsock; 
    FD_SET(mainsock, &Mysock.readfds);  /*  申明對主套接字「可讀」感興趣 */ 
    FD_SET(mainsock, &Mysock.exceptfds);  /*  申明對主套接字上例外事件感興趣 */ 
    return(1);     
} 
void CloseMainSock() 
/*  關閉主套接字，並清除對它上面事件的申明。在程序結束前關閉主套接字是一個好習慣 */ 
{ 
    close(Mysock.DaemonSock); 
    FD_CLR(Mysock.DaemonSock, &Mysock.readfds); 
    FD_CLR(Mysock.DaemonSock, &Mysock.exceptfds); 
} 
  
int CreateConnection(struct in_addr *sin_addr) 
/* Create a Connection to remote host which IP address is in sin_addr.  
   Param: sin_addr indicates the IP address in Network Byte Order.  
   if succeed return the socket number which indicates this connection, 
   else return error code (<0) */ 
{ 
    struct sockaddr_in server;  /* server address */ 
    int tmpsock, flag=1, i; 
  
   if ((tmpsock = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
      return(-1); 
      
    server.sin_family = AF_INET; 
    server.sin_port = Mysock.Port; 
    server.sin_addr.s_addr = sin_addr->s_addr; 
	/* Set this socket as a Non-blocking socket. */ 
    if (ioctl(tmpsock, FIONBIO, &flag) == -1) { 
      close(tmpsock); 
      return(-2); 
    } 
     
    /* Connect to the server. */ 
   if (connect(tmpsock, (struct sockaddr *)&server, sizeof(server)) < 0) { 
      if ((errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { 
		 /*  假設錯誤代碼是 EWOULDBLOCK 和 EINPROGRESS，則不用關閉套接字，因爲系統將在以後繼續爲套接字建
		立鏈接，鏈接是否創建成功可用 select()函數來檢測套接字是否「可寫」來肯定。*/ 
           close(tmpsock); 
       return(-3); /* Connect error. */ 
      } 
   }
   FD_SET(tmpsock, &Mysock.readfds); 
   FD_SET(tmpsock, &Mysock.writefds); 
   FD_SET(tmpsock, &Mysock.exceptfds); 
  
    i = 0; 
    while (Mysock.Sockets[i] != 0) i++; /* look for a blank sockets position */ 
    if (i >= 64) { 
		close(tmpsock); 
		return(-4); /* too many connections */ 
    } 
  
    Mysock.Sockets[i] = tmpsock; 
    Mysock.SockNum++; 
    return(i); 
} 
  
int AcceptConnection(struct in_addr *IPaddr) 
/* Accept a connection. If succeed, return the data sockets number, else return -1. */ 
{ 
    int newsock, len, flag=1, i; 
    struct sockaddr_in addr; 
  
    len = sizeof(addr); 
    bzero((char *)&addr, len); 
    if ((newsock = accept(Mysock.DaemonSock, &addr, &len)) == -1)  
    return(-1); /* Accept error. */ 
  
    /* Set this socket as a Non-blocking socket. */ 
    ioctl(newsock, FIONBIO, &flag); 
  
    FD_SET(newsock, &Mysock.readfds); 
    FD_SET(newsock, &Mysock.writefds); 
    FD_SET(newsock, &Mysock.exceptfds); 
  
    /* Return IP address in the Parameter. */ 
	IPaddr->s_addr = addr.sin_addr.s_addr; 
  
	 i = 0; 
	while (Mysock.Sockets[i] != 0) i++; /* look for a blank sockets position */ 
	if (i >= 64) { 
		close(newsock); 
		return(-4); /* too many connections */ 
	 } 
	  
	Mysock.Sockets[i] = newsock; 
	Mysock.SockNum++; 
	return(i); 
}
int CloseConnection(int Sockno) 
/* Close a connection indicated by Sockno. */ 
{ 
    int retcode; 
     
	 if ((Sockno >= 64) || (Sockno < 0) || (Mysock.Sockets[Sockno] == 0））
	  return(0); 
	 retcode = close(Mysock.Sockets[Sockno]); 
    FD_CLR(Mysock.Sockets[Sockno], &Mysock.readfds); 
    FD_CLR(Mysock.Sockets[Sockno], &Mysock.writefds); 
    FD_CLR(Mysock.Sockets[Sockno], &Mysock.exceptfds); 
  
    Mysock.Sockets[Sockno] = 0; 
    Mysock.SockNum--; 
    return(retcode); 
}
int QuerySocketsMsg() 
/* Query Sockets Message. If succeed return message number, else return -1. 
  The message information stored in struct SockMsg. */ 
{ 
    fd_set rfds, wfds, efds; 
     int retcode, i; 
     struct timeval TimeOut; 
     
     rfds = Mysock.readfds; 
     wfds = Mysock.writefds; 
     efds = Mysock.exceptfds; 
     TimeOut.tv_sec = 0;  /*  立刻返回，不堵塞。*/ 
     TimeOut.tv_usec = 0; 
     
     bzero((char *)&SockMsg, sizeof(SockMsg)); 
     if ((retcode = select(64, &rfds, &wfds, &efds, &TimeOut)) == 0) 
      return(0); 
     
     if (FD_ISSET(Mysock.DaemonSock, &rfds)) 
      SockMsg.AcceptNum = 1;  /* some client call server. */ 
      
     for (i=0; i<64; i++)  /* Data in message */ 
     { 
      if ((Mysock.Sockets[i] > 0) && (FD_ISSET(Mysock.Sockets[i], &rfds)))  
           SockMsg.ReadQueue[SockMsg.ReadNum++] = i; 
     } 
     
     for (i=0; i<64; i++)  /* Data out ready message */ 
     { 
      if ((Mysock.Sockets[i] > 0) && (FD_ISSET(Mysock.Sockets[i], &wfds)))  
           SockMsg.WriteQueue[SockMsg.WriteNum++] = i; 
     } 
     
     if (FD_ISSET(Mysock.DaemonSock, &efds)) 
      SockMsg.AcceptNum = -1;  /* server socket error. */ 
      
     for (i=0; i<64; i++)  /* Error message */ 
     { 
      if ((Mysock.Sockets[i] > 0) && (FD_ISSET(Mysock.Sockets[i], &efds)))  
           SockMsg.ExceptQueue[SockMsg.ExceptNum++] = i; 
     } 
   return(retcode); 
} 
  
int SendPacket(int Sockno, void *buf, int len) 
/* Send a packet. If succeed return the number of send data, else return -1 */  
{ 
    int actlen; 
     
    if ((Sockno >= 64) || (Sockno < 0) || (Mysock.Sockets[Sockno] == 0)) 
  return(0); 
  
    if ((actlen = send(Mysock.Sockets[Sockno], buf, len, 0)) < 0) 
  return(-1); 
 return(actlen); 
} 
  
int RecvPacket(int Sockno, void *buf, int size) 
/* Receive a packet. If succeed return the number of receive data, else if the connection 
  is shutdown by peer then return 0, otherwise return 0-errno */  
{ 
   int actlen; 
   if ((Sockno >= 64) || (Sockno < 0) || (Mysock.Sockets[Sockno] == 0)) 
  return(0); 
   if ((actlen = recv(Mysock.Sockets[Sockno], buf, size, 0)) < 0) 
  return(0-errno); 
 return(actlen); /* actlen 是接收的數據長度，假設爲零，指示鏈接被對方關閉。*/ 
}

2.5.3 簡單server程序演示樣例  

/* File Name: server.c */ 
/*  這是一個很是easy的反覆server程序，它初始化好被動套接字後，循環等待接收鏈接。假設接收到鏈接，它顯示數據
套接字序號和client的 IP 地址；假設數據套接字上有數據到來，它接收數據並顯示該鏈接的數據套接字序號和接收到
的字符串。*/ 
#include "tcpsock.c" 
main(argc, argv) 
int argc; 
char **argv; 
{ 
 struct in_addr sin_addr; 
     int retcode, i; 
    char buf[32]; 
  
/*  對於server程序，它經常是處於無限循環狀態，僅僅有在用戶主動 kill 該進程或系統關機時，它才結束。對於使用 kill
強行終止的server程序，由於主套接字沒有關閉，資源沒有主動釋放，可能會給隨後的server程序又一次啓動產生影響。
所以，主動關閉主套接字是一個良好的變成習慣。如下的語句使程序在接收到 SIGINT、SIGQUIT和 SIGTERM 等信號
時先運行 CloseMainSock()函數關閉主套接字，而後再結束程序。所以，在使用 kill 強行終止server進程時，應該先使
用 kill -2 PID 給server程序一個消息使其關閉主套接字，而後在用 kill -9 PID 強行結束該進程。*/ 
    (void) signal(SIGINT, CloseMainSock);  
    (void) signal(SIGQUIT, CloseMainSock); 
    (void) signal(SIGTERM, CloseMainSock); 
  
 if ((retcode = InitPassiveSock("TestService")) < 0) { 
      printf("InitPassiveSock: error code = %d\n", retcode); 
  exit(-1); 
     } 
  
     while (1) { 
  retcode = QuerySocketsMsg(); /*  查詢網絡消息 */ 
  if (SockMsg.AcceptNum == 1) { /*  有外來鏈接等待接收？*/ 
       retcode = AcceptConnection(&sin_addr); 
       printf("retcode = %d, IP = %s \n", retcode, inet_ntoa(sin_addr.s_addr)); 
  } 
  else if (SockMsg.AcceptNum == -1) /*  主套接字錯誤？*/ 
    printf("Daemon Sockets error.\n"); 
  for (i=0; i<SockMsg.ReadNum; i++) { /*  接收外來數據 */ 
       if ((retcode = RecvPacket(SockMsg.ReadQueue[i], buf, 32)) > 0) 
        printf("sockno %d Recv string = %s \n", SockMsg.ReadQueue[i], buf); 
   else /*  返回數據長度爲零，指示鏈接中斷，關閉套接字。*/ 
    CloseConnection(SockMsg.ReadQueue[i]); 
  } 
  } /* end while */ 
}

2.5.4 簡單客戶程序演示樣例

/* File Name: client.c */ 
/*  客戶程序在運行時，先初始化數據結構，而後等待用戶輸入命令。它識別四個命令： 
conn(ect)：  和server創建鏈接； 
send：  給指定鏈接發送數據； 
clos(e)：  關閉指定鏈接； 
quit：   退出客戶程序。 
*/ 
#include "tcpsock.h" 
  
main(argc, argv) 
int argc; 
char **argv; 
{ 
  char cmd_buf[16]; 
     struct in_addr sin_addr; 
     int sockno1, retcode; 
     char *buf = "This is a string for test."; 
     sin_addr.s_addr = inet_addr("166.111.5.249");    /*  執行server程序的主機的 IP 地址 */ 
     
	  if ((retcode = InitSocketsStruct("TestService")) < 0) { /*  初始化數據結構 */ 
		  printf("InitSocketsStruct: error code =  %d\n", retcode); 
	  exit(1); 
	 } 
	  
		 while (1) { 
	   printf(">"); 
	  gets(cmd_buf); 
	  if (!strncmp(cmd_buf, "conn", 4)) { 
		   retcode = CreateConnection(&sin_addr); /*  創建鏈接 */ 
		   printf("return code: %d\n", retcode); 
	  } 
	  else if(!strncmp(cmd_buf, "send", 4)) { 
		   printf("Sockets Number:"); 
		   scanf("%d", &sockno1); 
		   retcode = SendPacket(sockno1, buf, 26); /*  發送數據 */ 
		   printf("return code: %d\n", retcode, sizeof(buf)); 
	  } 
	  else if (!strncmp(cmd_buf, "close", 4)) { 
		   printf("Sockets Number:"); 
		   scanf("%d", &sockno1); 
		   retcode = CloseConnection(sockno1);  /*  關閉鏈接 */ 
		   printf("return code: %d\n", retcode); 
	  } 
	  else if (!strncmp(cmd_buf, "quit", 4))  
		   exit(0); 
	  else 
		   putchar('\007'); 
	  } /* end while */ 
}

3 基本套接字系統調用

爲了更好地說明套接字編程原理，如下給出幾個基本套接字系統調用說明。

3.1 建立套接字──socket()

應用程序在使用套接字前，首先必須擁有一個套接字，系統調用socket()嚮應用程序提供建立套接字的手段，其調用格式例如如下：

 SOCKET PASCAL FAR socket(int af, int type, int protocol);

該調用要接收三個參數：af、type、protocol。參數af指定通訊發生的區域，UNIX系統支持的地址族有：AF_UNIX、AF_INET、AF_NS等，而DOS、WINDOWS中僅支持AF_INET，它是網際網區域。所以，地址族與協議族一樣。參數type 描寫敘述要創建的套接字的類型。參數protocol說明該套接字使用的特定協議，假設調用者不但願特別指定使用的協議，則置爲0，使用默認的鏈接模式。依據這三個參數創建一個套接字，並將對應的資源分配給它，同一時候返回一個整型套接字號。所以，socket()系統調用實際上指定了相關五元組中的「協議」這一元。

3.2 指定本地地址──bind()

 當一個套接字用socket()建立後，存在一個名字空間(地址族),但它沒有被命名。bind()將套接字地址（包含本地主機地址和本地port地址）與所建立的套接字號聯繫起來，即將名字賦予套接字，以指定本地半相關。其調用格式例如如下：

 int PASCAL FAR bind(SOCKET s, const struct sockaddr FAR * name, int namelen);

參數s：是由socket()調用返回的並且未做鏈接的套接字描寫敘述符(套接字號)。
參數name： 是賦給套接字s的本地地址（名字），其長度可變，結構隨通訊域的不一樣而不一樣。
參數namelen：代表了name的長度。
假設沒有發生錯誤，bind()返回0。不然返回值SOCKET_ERROR。
地址在創建套接字通訊過程當中起着重要做用，做爲一個網絡應用程序設計者對套接字地址結構必須有明白認識。好比，UNIX BSD有一組描寫敘述套接字地址的數據結構，當中使用TCP/IP協議的地址結構爲：

struct sockaddr_in{
    short sin_family; /*AF_INET*/
    u_short sin_port; /*16位端口號，網絡字節順序*/
    struct in_addr sin_addr; /*32位IP地址，網絡字節順序*/
    char sin_zero[8]; /*保留*/
    }

3.3 創建套接字鏈接──connect()與accept()

這兩個系統調用用於完畢一個完整相關的創建，當中connect()用於創建鏈接。無鏈接的套接字進程也可以調用connect()，但這時在進程之間沒有實際的報文交換，調用將從本地操做系統直接返回。這樣作的長處是程序猿沒必要爲每一數據指定目的地址，而且假設收到的一個數據報，其目的port未與不論什麼套接字創建「鏈接」，便能推斷該端靠紀紀可操做。而accept()用於使server等待來自某客戶進程的實際鏈接。
    connect()的調用格式例如如下：
 

 int PASCAL FAR connect(SOCKET s, const struct sockaddr FAR * name, int namelen);

    參數s：是欲創建鏈接的本地套接字描寫敘述符。
    參數name：指出說明對方套接字地址結構的指針。
    namele：對方套接字地址長度由namelen說明。
    假設沒有發生錯誤，connect()返回0。不然返回值SOCKET_ERROR。在面向鏈接的協議中，該調用致使本地系統和外部系統之間鏈接實際創建。
    由於地址族總被包括在套接字地址結構的前兩個字節中，並經過socket()調用與某個協議族相關。所以bind()和connect()無須協議做爲參數。
    accept()的調用格式例如如下：

SOCKET PASCAL FAR accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);

參數s：爲本地套接字描寫敘述符，在用作accept()調用的參數前應該先調用過listen()。
參數addr： 指向客戶方套接字地址結構的指針，用來接收鏈接實體的地址。addr的確切格式由套接字建立時創建的地址族決定。
參數addrlen: 爲客戶方套接字地址的長度（字節數）。假設沒有發生錯誤，accept()返回一個SOCKET類型的值，表示接收到的套接字的描寫敘述符。不然返回值INVALID_SOCKET。
    accept()用於面向鏈接server。參數addr和addrlen存放客戶方的地址信息。調用前，參數addr 指向一個初始值爲空的地址結構，而addrlen 的初始值爲0；調用accept()後，server等待從編號爲s的套接字上接受客戶鏈接請求，而鏈接請求是由客戶方的connect()調用發出的。當有鏈接請求到達時，accept()調用將請求鏈接隊列上的第一個客戶方套接字地址及長度放入addr 和addrlen，並建立一個與s有一樣特性的新套接字號。新的套接字可用於處理server併發請求。
    四個套接字系統調用，socket()、bind()、connect()、accept()，可以完畢一個全然五元相關的創建。socket()指定五元組中的協議元，它的使用方法與是否爲客戶或server、是否面向鏈接無關。bind()指定五元組中的本地二元，即本地主機地址和port號，其使用方法與是否面向鏈接有關：在server方，不論是否面向鏈接，均要調用bind()；鑰紀紀戶方，若採用面向鏈接，則可以不調用bind()，而經過connect()本身主動完畢。若採用無鏈接，客戶方必須使用bind()以得到一個惟一的地址。
    以上討論僅對客戶/server模式而言，實際上套接字的使用是很靈活的，惟一需遵循的原則是進程通訊以前，必須創建完整的相關。

 3.4 監聽鏈接──listen()

 

    此調用用於面向鏈接server，代表它願意接收鏈接。listen()需在accept()以前調用，其調用格式例如如下：
int PASCAL FAR listen(SOCKET s, int backlog);
    參數s標識一個本地已創建、還沒有鏈接的套接字號，server願意從它上面接收請求。backlog表示請求鏈接隊列的最大長度，用於限制排隊請求的個數，眼下贊成的最大值爲5。假設沒有發生錯誤，listen()返回0。不然它返回SOCKET_ERROR。
    listen()在運行調用過程當中可爲沒有調用過bind()的套接字s完畢所必須的鏈接，並創建長度爲backlog的請求鏈接隊列。
    調用listen()是server接收一個鏈接請求的四個步驟中的第三步。它在調用socket()分配一個流套接字，且調用bind()給s賦於一個名字以後調用，而且必定要在accept()以前調用。
    2.3節中提到鑰紀紀戶/server模式中，有兩種類型的服務：反覆服務和併發服務。accept()調用爲實現併發服務提供了極慷慨便，因爲它要返回一個新的套接字號，其典型結構爲：

 int initsockid, newsockid;
    if ((initsockid = socket(....)) < 0)
    error(「can’t create socket」);
    if (bind(initsockid,....) < 0)
    error(「bind error」);
    if (listen(initsockid , 5) < 0)
    error(「listen error」);
    for (; {
    newsockid = accept(initsockid, ...) /* 堵塞 */
    if (newsockid < 0)
    error(「accept error「);
    if (fork() == 0){ /* 子進程 */
    closesocket(initsockid);
    do(newsockid); /* 處理請求 */
    exit(0);
    }
    closesocket(newsockid); /* 父進程 */
    }

    這段程序運行的結果是newsockid與客戶的套接字創建相關，子進程啓動後，關閉繼承下來的主server的initsockid,並利用新的newsockid與客戶通訊。主server的initsockid可繼續等待新的客戶鏈接請求。由於在Unix等搶先多任務系統中，在系統調度下，多個進程可以同一時候進行。所以，使用併發server可以使server進程在同一時間可以有多個子進程和不一樣的客戶程序鏈接、通訊。鑰紀紀戶程序看來，server可以同一時候併發地處理多個客戶的請求，這就是併發server名稱的來由。
    面向鏈接server也可以是反覆server，其結構例如如下：

int initsockid, newsockid;
    if ((initsockid = socket(....))<0)
    error(「can’t create socket」);
    if (bind(initsockid,....)<0)
    error(「bind error」);
    if (listen(initsockid,5)<0)
    error(「listen error」);
    for (; {
    newsockid = accept(initsockid, ...) /* 堵塞 */
    if (newsockid < 0)
    error(「accept error「);
    do(newsockid); /* 處理請求 */
    closesocket(newsockid);
    }

    反覆server在一個時間僅僅能和一個客戶程序創建鏈接，它對多個客戶程序的處理是採用循環的方式反覆進行，所以叫反覆server。併發server和反覆server各有利弊：併發server可以改善客戶程序的響應速度，但它添加了系統調度的開銷；反覆server正好與其相反，所以用戶在決定是使用併發server仍是反覆server時，要依據應用的實際情考網考網來定。

3.5 傳輸數據──send()與recv()

    當一個鏈接創建之後，就可以數據傳輸了。常用的系統調用有send()和recv()。
    send()調用用於鑰紀紀數s指定的已鏈接的數據報或流套接字上發送輸出數據，格式例如如下：

int PASCAL FAR send(SOCKET s, const char FAR *buf, int len, int flags);

參數s:爲已鏈接的本地套接字描寫敘述符。
buf 指向存有發送數據的緩衝區的指針，
len :buf長度由len 指定。
flags 指定傳輸控制方式，如是否發送帶外數據等。
假設沒有發生錯誤，send()返回總共發送的字節數。不然它返回SOCKET_ERROR。
    recv()調用用於鑰紀紀數s指定的已鏈接的數據報或流套接字上接收輸入數據，格式例如如下：

   int PASCAL FAR recv(SOCKET s, char FAR *buf, int len, int flags);

參數s 爲已鏈接的套接字描寫敘述符。
buf:指向接收輸入數據緩衝區的指針，
len :buf長度由len 指定。
flags 指定傳輸控制方式，如是否接收帶外數據等。
假設沒有發生錯誤，recv()返回總共接收的字節數。假設鏈接被關閉，返回0。不然它返回SOCKET_ERROR。

3.6 輸入/輸出多路複用──select()

     select()調用用來檢測一個或多個套接字的狀態。對每一個套接字來講，這個調用可以請求讀、寫或錯誤狀態方面的信息。請求給定狀態的套接字集合由一個fd_set結構指示。在返回時，此結構被更新，以反映那些知足特定條件的套接字的子集，同一時候， select()調用返回知足條件的套接字的數目，其調用格式例如如下：
    int PASCAL FAR select(int nfds, fd_set FAR * readfds, fd_set FAR * writefds, fd_set FAR * exceptfds, const struct timeval FAR * timeout);
參數nfds:指明被檢查的套接字描寫敘述符的值域，此變量通常被忽略。
參數readfds:指向要作讀檢測的套接字描寫敘述符集合的指針，調用者但願從中讀取數據。
參數writefds :指向要作寫檢測的套接字描寫敘述符集合的指針。
exceptfds指向要檢測是否出錯的套接字描寫敘述符集合的指針。
imeout指向select()函數等待的最大時間，假設設爲NULL則爲堵塞操做。
select()返回包括在fd_set結構中已準備好的套接字描寫敘述符的總數目，或者是錯誤發生則返回SOCKET_ERROR。

3.7 關閉套接字──closesocket()

      closesocket()關閉套接字s，並釋放分配給該套接字的資源；假設s涉及一個打開的TCP鏈接，則該鏈接被釋放。closesocket()的調用格式例如如下：

BOOL PASCAL FAR closesocket(SOCKET s);

參數s待關閉的套接字描寫敘述符。假設沒有發生錯誤，closesocket()返回0。不然返回值SOCKET_ERROR。